Stroustrup: complexity in programming isn't a bug, it's a feature
Bjarne Stroustrup, the architect of C++, isn't backing down from his nuanced perspective on programming languages. In a recent resurgence of his debate around language selection, the computer scientist is arguing that complexity, far from being a drawback, is a necessary component of robust software engineering—a sharp rejoinder to the prevailing trend of prioritizing perceived ease of use above all else.
The two-tiered landscape of software development
Stroustrup’s point is simple, yet provocative: the software industry inherently divides into two distinct camps. On one side are the languages—C++, Java, Python—that programmers often lament for their intricacies and steeper learning curves. These, however, are the workhorses of large-scale, mission-critical systems, demanding a level of control and performance that simpler languages simply cannot deliver. The other camp comprises languages that are theoretically “perfect,” lauded for their elegance and apparent simplicity, but relegated to academic exercises or experimental projects due to a lack of practical power.
“There are only two kinds of programming languages,” Stroustrup famously quipped, “those whose users complain and those that nobody uses.” The statement, now a recurring theme in his commentary, highlights a fundamental truth: true power inevitably comes with a degree of complexity. To achieve the reliability and efficiency required in demanding applications, developers must grapple with the underlying mechanisms of the system.
Consider C++, a language Stroustrup readily acknowledges isn't the largest by user base compared to C# or Java. Yet, its reputation for complexity belies its design philosophy. The original goal was to create a language with broad versatility and extensive capabilities, not necessarily one of immediate simplicity. It's a tool honed over decades to address real-world engineering challenges, and its continued relevance speaks volumes.
The rise of low-code and no-code platforms, while offering tempting shortcuts, often mask underlying complexity. Reliance on external libraries and heavy environments can introduce vulnerabilities and limitations that ultimately diminish flexibility and efficiency. Stroustrup’s stance isn't a dismissal of these tools, but rather a caution against prioritizing superficial ease over fundamental control.
Beyond this particular debate, Stroustrup's commentary consistently challenges conventional wisdom within the developer community. He has previously asserted the impossibility of mastering programming solely through online resources and discouraged the notion that exceptional intelligence is a prerequisite for success in the field. He emphasizes the importance of a deep understanding of foundational principles, regardless of the specific language employed.
“Perfection is the enemy of utility,” Stroustrup concludes, a sentiment that encapsulates his pragmatic approach to software engineering. It’s a reminder that the most effective tools are those that empower developers to solve complex problems, even if those tools aren't always the easiest to wield. The demand for robust, scalable, and dependable systems will continue to drive the need for languages that embrace complexity, not shy away from it.