C++: Power With a Maintenance Fee

Key points

1. RAII is the idea that changed everything else: resources tied to object lifetime (destructors run deterministically) means the 'finally' families of every other modern language are C++'s scope behavior; smart pointers (unique_ptr/shared_ptr) turned manual memory into an ownership discipline.
2. The modernization arc is real: move semantics, range-based patterns, structured bindings, and the ranges library across standards (C++11 through C++23) reward teams that keep their toolchains new; the same language deployed via decade-old compilers reads like a different product.
3. The maintenance fee is build/binary logistics: templates compile slowly, CMake-class build systems are a discipline of their own, library ABIs (libstdc++ versus libc++) and symbol visibility make 'works on my machine but not on the server' a real failure family; containerized builds are the pragmatic bandage that keeps these problems contained.
4. Exception/error-code heterogeneity is an architectural decision: exceptions vs std::expected-style results remain a team policy decision; mixing both within one codebase is where maintenance debt multiplies quietly.
5. Where C++ keeps first choice: game engines, HPC, real-time graphics, embedded-adjacent performance work, and rewriting hot paths inside larger systems; where the language comparisons say otherwise: service backends (Go's simplicity, Rust's safety guarantees, Python's velocity) each beat C++ when its strengths aren't required.
6. Hiring truth: C++ skill pools split between modern-C++ engineers and legacy-dialect veterans, and modern code review discipline (clang-tidy, sanitizers in CI, ownership rules) is what keeps large codebases trainable rather than tribal.

Field note

The C++ codebase that ran a payment stack for 15 years survived by policy, not luck: clang-tidy in CI, sanitizers on test builds, and ownership rules written down in the onboarding doc. The discipline is the modernization.

Frequently asked questions