Stroustrup fires back: complexity is not a bug, it's the price of power
Bjarne Stroustrup has run out of patience with the endless parade of “why is C++ so hard?” hot takes. In a terse post on his personal FAQ, the Danish engineer reminds the industry that the language was never meant to be cuddly—it was meant to put spacecraft in orbit, micro-seconds in bank trading engines and photons in game consoles. “There are only two kinds of languages: those people complain about and those no one uses,” he writes, recycling his own 30-year-old punch line because the complaint cycle refuses to die.
The myth of zero-friction coding
Python wrappers, Rust evangelists and no-code startups keep promising that complexity can be abstracted into oblivion. Stroustrup’s answer is surgical: abstractions leak. When a Python script suddenly hits a GIL wall or a TensorFlow model demands a CUDA driver from 2019, the developer is yanked back to the metal. C++ front-loads that pain instead of hiding it. The result is code that still compiles when the kernel changes, chips shrink or regulators demand reproducible builds a decade later.
He points to the two-speed reality that now dominates software procurement. In lane one sit languages that ship with gigabytes of runtime and a Twitter account ready to apologize for every breaking change. In lane two sits C++, still compiled down to a few megabytes, still without a corporate marketing department, still blamed for every segfault. “The perceived difficulty is a measurement artifact,” Stroustrup told a recent ISO gathering. “We count the crashes we see, not the catastrophes we prevented.”
Success leaves scars
The numbers back him up. The Linux kernel holds 3.3 million commits; 40 % of the critical fixes touch C or C++ headers. Chrome’s 35 million lines—same story. Even Java’s bytecode interpreter is written in C++. The closer the code sits to silicon, the less room there is for garbage-collected forgiveness. Stroustrup’s verdict: “If your runtime saves you from a dangling pointer today, it will cost you a millisecond in production tomorrow. Someone always pays.”
Meanwhile, the so-called simpler ecosystems keep ballooning. A vanilla Node project in 2023 pulls in 1,200 dependencies on average; a hello-world Rust binary ships a 7 MB standard library. Complexity did not disappear—it was displaced, outsourced to package.json and Cargo.toml. C++ keeps it in one place: the developer’s head. That concentration feels hostile until the bill arrives in the form of a zero-day that can’t be patched by bumping a semver string.
Perfection is the enemy of uptime
Stroustrup ends with a warning aimed at CS departments hypnotized by syntax sugar. “Chasing a perfect language is like chasing a perfect chess opening: the opponent changes, the board stays 8×8.” The industry, he argues, should teach students to reason about hardware, cache lines and aliasing rules instead of seducing them with yet another DSL that promises to make memory safety disappear. The reward for mastering complexity is not a medal; it is a system that still boots when the next solar storm hits.
Bottom line: the loudest complaints emerge from the most trafficked codebases. Stroustrup’s advice is characteristically blunt—choose your scars wisely, because every widely used language is covered in them.