Software pioneer ken thompson found productivity in code elimination
Ken Thompson, a titan of computing, believes deleting code can be more valuable than writing it. The creator of Unix, the designer of the B language (a precursor to C), and a co-creator of Go, Thompson’s insights carry weight, especially his recent assertion about the surprising benefits of code reduction.
The art of subtracting complexity
Thompson’s perspective stems from decades spent shaping the foundations of software development. His work on Unix in the late 1960s, alongside Dennis Ritchie at Bell Labs, wasn’t just about creating an operating system; it was about a fundamental shift in how computers could be structured – using small, modular tools that work together.
The B language, which he designed, paved the way for Ritchie’s development of C, the language that dominated systems programming for decades. Decades later, at Google, Thompson co-created Go, a language built on the same principle: simplicity over complexity, clarity over intricacy. Go's design intentionally omits features to reduce the burden on programmers.
Why is removing code sometimes more effective than adding it? Each line of code introduces a potential point of failure – a bug, a maintenance headache, a future complication. As systems grow, technical debt accumulates, turning even minor changes into high-risk operations. Therefore, Thompson argues, eliminating unused code isn't a step backward; it's a strategic move to simplify architecture and enhance future development speed and security.
This approach demands depth of understanding. It requires identifying what truly matters and having the discipline to discard the rest. Bjarne Stroustrup, the creator of C++, famously stated: “There are only two kinds of programming languages: those people complain about and those nobody uses.”
Go’s design philosophy directly addresses the current trend of measuring productivity by lines of code written. This metric overlooks the hidden costs – the time other developers spend deciphering complex codebases and the fragility inherent in overly intricate systems. Thompson’s core idea is simple: good programming isn't about writing more; it’s about writing exactly what’s necessary.
The emphasis on clarity in Go contrasts sharply with languages like C++ and Java, known for their extensive features and complex syntax. Go’s design ensures that programmers don’t have to wrestle with unnecessary complexity. This philosophy is gaining traction as developers grapple with ever-increasing codebases and the challenges of maintaining them.
Thompson’s insights are a powerful reminder that effective software development isn't always about adding more; it’s often about strategically removing what doesn’t contribute to the core functionality. His legacy isn’t just in the languages he created, but in the enduring principle of elegant simplicity.
The rise of AI-powered code assistants may soon validate Thompson’s long-held belief. Perhaps the future of software isn’t about writing more code, but about intelligently curating what remains.