“C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off.”
The Story
In 1979, Bjarne Stroustrup was a young Danish computer scientist at Bell Labs working on his PhD research — simulating distributed systems. He needed the low-level efficiency of C and the organizational power of Simula's classes. Neither language alone was sufficient. So he started building "C with Classes," which evolved into C++ by 1983.
The design philosophy was radical in its conservatism: you don't pay for what you don't use. Every abstraction C++ introduced — classes, virtual functions, templates, exceptions — was designed to compile down to code no worse than a skilled C programmer would write by hand. This zero-overhead principle meant C++ could live everywhere C lived: operating systems, embedded systems, game engines, financial trading platforms.
Templates, introduced in the early 1990s, turned out to be accidentally Turing-complete. What was designed as a type-safe macro system became a compile-time programming language in its own right — spawning template metaprogramming, a technique so powerful and so unreadable that it became its own category of technical debt.
RAII (Resource Acquisition Is Initialization) was Stroustrup's answer to the memory management problem. Tie resource lifetimes to object lifetimes. Let destructors clean up automatically. It was elegant, it worked, and it was entirely opt-in — meaning developers could still bypass it and reach for raw pointers whenever they wanted. Smart pointers (unique_ptr, shared_ptr) formalized this pattern decades later, but by then, billions of lines of raw-pointer C++ already existed.
C++ didn't replace C. It layered on top of it. Every C footgun remained loaded and accessible. The language gave you the tools to be safe, but never required you to use them.
Why They're in the Hall
Stroustrup is both Pioneer and Builder — he didn't just create a language, he defined the design space that systems programming has occupied for four decades.
Pioneer: The zero-overhead abstraction principle influenced every systems language that followed. Rust's entire ownership model is, in a sense, an answer to the question Stroustrup posed: can we get C++ safety guarantees without C++ complexity? The question only exists because Stroustrup demonstrated that abstraction and performance weren't mutually exclusive.
Builder: C++ is infrastructure. The browser you're reading this in, the game engines behind AAA titles, the databases storing your data, the compilers compiling other languages — most of them are written in C++ or were at some point. The language's influence is so pervasive it's invisible.
The complexity problem is the honest part of the story. C++ accumulated features for 40 years. Templates, exceptions, multiple inheritance, operator overloading, move semantics, concepts, coroutines — the language became so large that no single developer could claim to know all of it. The complexity itself became a source of bugs. Not memory bugs or logic bugs, but comprehension bugs — code that does something subtly different from what its author believed, because the interaction between features was unintuitable.
Stroustrup's famous quote about shooting your leg off isn't self-deprecation. It's an honest acknowledgment that power and danger are the same axis. C++ gave programmers more power than any language before it. The blast radius scaled accordingly.