Thompson's razor: why less code means more power

Ken Thompson, the quiet architect of Unix, B, and Go, isn't giving interviews. Instead, he’s offering a brutally simple, and profoundly impactful, lesson: delete code.

A philosophy of minimalist mastery

For over half a century, Thompson has been shaping the very foundations of software. From his pivotal role in crafting Unix at Bell Labs to his later co-creation of Go, a language prized for its stark elegance, he’s consistently championed a philosophy of ruthless efficiency. And his most recent assertion – that one of his most productive days involved eliminating 1,000 lines of code – isn’t a casual remark. It’s a testament to a core principle that's increasingly vital in a world drowning in complexity.

He famously argued that writing only what’s necessary, stripping away redundancy, and striving for systems that are demonstrably simpler than they need to be, yields superior results. It’s a counterintuitive idea in an era where adding features – often superficially – is relentlessly prioritized. But Thompson’s approach, honed over decades, speaks to a fundamental truth about software development: bloat is a silent killer.

The debt of complexity

Each line of code added represents a potential vulnerability, a point of failure, a layer of obfuscation. It’s a burden for future developers to decipher, a hurdle to overcome when modifying or extending the system. This accumulation of ‘technical debt’ – a term coined by Ward Cunningham – can cripple a project, transforming seemingly minor changes into high-stakes operations. The longer a system grows, the more fragile it becomes, and the greater the risk of unintended consequences.

Thompson’s method isn't about regression; it’s about fortification. By actively pruning unnecessary code, you reduce the attack surface, clarify the architecture, and create a system that's inherently more resilient. It demands a level of discipline rarely seen in contemporary development practices – a deep understanding of the system’s core functionality, coupled with the courage to discard what isn't essential.

Go's legacy: a model for simplicity

The design of Go, heavily influenced by Thompson’s principles, exemplifies this approach. Unlike C++ or Java, which often embrace verbose syntax and intricate features, Go deliberately minimizes complexity. Its type system is straightforward, its concurrency mechanisms are designed for clarity, and its overall structure prioritizes readability above all else. This isn't a matter of aesthetic preference; it’s a strategic decision rooted in the understanding that simplicity breeds maintainability.

“Only two types of programming languages exist,” Bjarne Stroustrup, the creator of C++, once famously declared: “Those people complain about and those nobody uses.” Thompson’s philosophy resonates with that sentiment – promoting a style of programming that is both powerful and elegant, demanding respect for its users and a relentless pursuit of clarity. The internet is currently ablaze with a visualization showing the exponential growth of software bloat – a stark reminder that less can indeed be more.

Ultimately, Thompson’s ‘razor’ cuts through the noise, urging us to prioritize substance over superfluous code.