Bjarne Stroustrup has been designing the same programming language since 1979. He started at Bell Labs, in the office down the hall from Dennis Ritchie, and the problem was simple: he needed a language that had Simula’s ability to organize complex systems into objects but ran as fast as C. Nobody had built one. He decided to build one himself. He called it “C with Classes.” Then he renamed it C++, because the ”++” operator in C means “increment by one,” and the name was a programmer joke. The joke is now running inside your car’s engine controller, your phone’s operating system, your browser’s rendering engine, every video game you’ve ever played, and the guidance systems of approximately everything that flies.
Forty-five years later, he’s still working on it. Not maintaining it — actively designing new features, arguing about syntax, writing papers on template metaprogramming, attending standards committee meetings where fifty engineers debate the semantics of a single keyword for three days. He could have stopped decades ago. The language is the world’s third most popular. It powers billions of devices. He could retire, take a chair at any university on earth, and write his memoirs. Instead he’s in a committee room arguing about whether “concepts” should be constrained or unconstrained, and he cares about the answer the way other people care about their children.
The Frequency Count
Talk to Stroustrup and you’d realize within five minutes that C++ isn’t a language to him. It’s an organism. He talks about features the way a gardener talks about plants — this one grew well, that one needed pruning, this other one was a mistake he’s been trying to correct for twenty years but can’t remove without killing everything that depends on it.
“Every successful language accumulates features,” he’d say, in the soft, precise Danish accent that forty years in America hasn’t erased. “The art is knowing which features to resist.” He’d tell you about the ones he resisted — garbage collection (too slow for systems programming), mandatory bounds checking (too expensive for embedded systems), a simpler syntax (tried it; broke backward compatibility; reverted). He’d describe each rejected feature with the specificity of a doctor describing a surgery they decided not to perform.
The language has become, by his own admission, too complex. The C++20 standard runs to 1,800 pages. He knows this. He wrestles with it publicly. “C++ is a large language,” he wrote, “and there’s a temptation to describe it as an ocean. But every feature is there because someone needed it for a real program.” The obsession isn’t with adding features. It’s with the impossible problem of adding features without adding complexity, which is like trying to grow a tree without adding branches.
The Thing You Can’t Change the Subject Away From
Try to talk about something other than programming languages and Stroustrup will let you. For about ninety seconds. Then: “That’s interesting. It reminds me of the type system problem in C++17, where…” And you’re back. Not because he’s rude. Because his mind processes everything through the lens of language design. Politics is a type safety problem. Music is pattern matching. Human relationships are interface contracts with insufficient error handling.
He’d laugh at that last one. He has a dry, self-aware sense of humor that surprises people who expect language designers to be humorless. “There are only two kinds of languages,” he’s said. “The ones people complain about and the ones nobody uses.” He says it like a man who’s heard every complaint and considers them evidence of success.
Why It Matters
The obsession serves a purpose. C++ is the thin layer between the abstractions humans think in and the hardware that actually executes. Every other popular language — Python, JavaScript, Java — is built on top of layers of abstraction that eventually reach C or C++ at the bottom. Stroustrup isn’t maintaining a language. He’s maintaining the floor.
He’d want you to understand that. The obsession isn’t vanity. It’s responsibility. Billions of lines of C++ code run systems where failure means planes crash, medical devices malfunction, financial systems collapse. The man who designed the language carries the weight of every decision he made in 1983 and every decision he’ll make next Tuesday, because the code written on top of those decisions doesn’t care how old the decision is. It only cares whether it works.
He’s been designing the same language for forty-five years. He could stop. The language can’t.
Talk to Bjarne Stroustrup — but be prepared: every conversation eventually becomes a conversation about type systems.