By Andrew Park | 2024-07-17
Software engineering, while crucial to modern technology, is the most inefficient field of engineering. This conclusion is based on an analysis of 340+ companies, encompassing 9.6 billion lines of code and 557,000 full-time software developers. Our findings reveal that the shelf life of industry source code is notably short, with obsolescence increasing over time. Typically, organizations can expect that 50% of every dollar invested in software development, testing, and operations for functional code will be discarded by future engineers within five years.
The Main Source of Waste
The primary source of waste in software engineering arises from the eventual discarding of labor invested in source code due to practices and perceptions surrounding legacy code and technical debt. This inefficiency stems from a cycle where new developers rewrite existing code, which is then deemed outdated and burdensome by future engineers. This recurring waste is largely overlooked because the source code, despite substantial investments in development, testing, and operations, remains invisible to the company leaders who fund the software development teams.
The Legacy Code Paradox
At the core of this inefficiency is the paradox of legacy code. As developers cycle in and out of companies, the code they leave behind is often labeled as legacy because it is difficult to understand, primarily due to poor documentation and high cognitive complexity, often resulting from a lack of conceptual integrity. Current developers label this code as outdated, hard to understand, and burdened with technical debt. New developers, faced with the challenge of maintaining and extending this perceived archaic code, frequently choose to discard it and rewrite it from scratch. This decision, often seen as the lesser of two evils, is usually considered cheaper and faster for delivering new software releases. However, this rewriting process is an extremely wasteful use of software development time and resources, especially given that the original legacy code was functional and provided value to the company and its customers up until the moment it was discarded.
Technical Debt and Its Mismanagement
Technical debt, a metaphor for the future cost of expedient but suboptimal decisions, compounds this inefficiency. While intended to highlight areas needing improvement, it often becomes a blanket justification for discarding existing working code. Developers perceive rewriting as a cleaner solution than incrementally improving existing code, further fueling the cycle of waste. Each new iteration of code, created to replace the old, eventually succumbs to the same fate, deemed inefficient and burdened by technical debt by successive developers.
The Invisible Nature of Code
The invisibility of code exacerbates this problem. Unlike physical engineering disciplines where inefficiencies are visible and measurable, software engineering's outputs are intangible. The discarding and rewriting of code occur behind the scenes, away from the scrutiny of those funding these efforts. This lack of visibility allows the cycle of waste to persist unchecked, with the true cost of inefficiency hidden from financial decision-makers.
Conclusion
In summary, software engineering's unique challenges of managing legacy code and technical debt, coupled with the intangible nature of its outputs, create a cycle of inefficiency unparalleled in other engineering disciplines. The constant rewriting of functional code, driven by successive waves of developers, results in significant labor investment being discarded. This cyclical waste remains largely unnoticed by those funding these endeavors, underscoring the need for a paradigm shift in how software engineering efficiency is perceived and managed.
Comments