In auto pian world, every software project finishes in time and within budget. We can add new features and functionalities and test everything that one more time too. But we don’t live in a Utopian world, do we?
In the real world, software product development has its share of difficulties. These often cause project delays. One of those difficulties is carried-over technical debt.
The truth about technical debt
Technical debt is a reality. There is no escaping it.
For clarity’s sake, let me define technical debt in the context of this essay. To me, technical debt comprises all the additional work you need to do to complete software product development. It can be summed up as the difference between what was promised and what was delivered and includes the technical shortcuts taken to meet the delivery deadlines.
However, technical debt does not reside with the boundaries of a development project alone. The race to the finish line of never-ending build cycles presents technical debt that carries forward as code bases become a collection of ‘band-aid’ fixes. Technical debt then spills over into future projects as well.
How does this debt accumulate?
Technical debt can manifest in many ways. Take for example a module written in a legacy technology. Now assume that the development team has to add new features or functionalities. The task becomes much more complex as the underlying technology may not be easy, or may even be impossible, to scale. This means a fundamental change of technology -or a compromise on the overall performance or stability of the software.
Not addressing accumulated technical debt of ten leads to more debt. Pretty much like financial debts, if this technical debt is not resolved it accrues interest. And over time, this interest will become even harder to pay off.
A poll early last year found that 9 out of 10 development organizations were “struggling with technical debt, saying it was delaying software delivery.”
Difficulty in making changes to the software, poor software performance, issues with maintainability and security and the risk of breaking the software after every new update are just the tip of the iceberg.
Technical debt can manifest in several ways such as :
- Poor source code formatting
- Poor test coverage
- Lack of Modularity
- Code complexity
- Poor documentation
For development teams working on a project that has accumulated high technical debt, it becomes imperative to first address this debt and then move to the actual development/deployment process. Why? Because unless you do so, you accrue more debt. This impacts development cycles and developer productivity. And all that takes effort. How much? Well, a Science Direct study of multiple case studies across 15 large software organizations in 2018 found, “The cost of managing TD in large software organizations is estimated to be, on average, 25% of the whole development time.”
Do you know if you have technical debt?
Chances are, you do. If you don’t here’s a laundry list to look for:
- Your development team is struggling to understand the code (because technical debt has transformed it into spaghetti code).
- New bugs emerge each time you test new features.
- Adding new features means re-writing and re-programming and thus writing out dozens of new documents.
- The software product runs on legacy systems and you continue to live with security and maintainability issues that you know you can solve with new technology.
- Production incidents and defects emerge suddenly and your development team stays busy with these.
- You have issues with unit testing and are unable to test a module by itself.
At a granular level, like a pre-programmed missile, technical debt seems to have a definite target – developer productivity.
Bad code attracts more bad code. Unless the development team addresses the technical debt they have accumulated it will impact the developers’ productive development time. It will also impact the sustainability and agility of the software
Technical debt in the agile world
Well, clearly, there is no place for technical debt in the agile world of software development. New development methodologies are gaining ground and working in short iterations and short bursts has become mainstream. In this new world, developers have to become conscious about addressing and accumulating technical debt. They, therefore, need to work towards leaving the code cleaner than they discovered it. Refactoring helps. Having stringent actions to define code and following code guidelines, addressing inferior code, automating tests for high code coverage etc. also helps to lower technical debt.
If you want to be agile in the long run and consistently deliver high-quality software, address your technical debt. Technical debt is the mortgage you take to get that initial development boost. But like every loan, you need to pay it off or be weighed down later. One thing is clear, accumulated technical debt will impact your developer productivity. Addressing it early and ensuring it doesn’t carry over or accumulate can save productive time -25% at least!