We all experience technical debt when building software, especially software that has been around for years. Most of us have likely encountered code that we are loathe to touch and modify. At least, we don't touch it twice. We might change things once, but when it doesn't work as expected, most of us put it back in it's previous state and move on to something else.

At the same time, it's hard to define what technical debt is or point it out to managers, who often can't grasp the concept of why technical debt matters to a development team. They can't understand the reasons why new code built on older code takes longer and longer to produce. It's a nebulous concept that can baffle both people new to software development and those with years of experience.

I ran across a few articles that talk about technical debt. This one notes it's commonly used as a phrase and also, it's inevitable. There's a short video from Ward Cunningham, who is said to be the inventor of the term. It's interesting because the explanation isn't bad code, it's more that we don't always understand the problem when we write code, especially at the beginning. As we have a disagreement between what's coded and what's needed, we accumulate debt. Ward talks about refactoring regularly as we gain understanding.

There is another piece that uses the Chernobyl disaster as a comparison with software development. This one looks at cost-cutting in both situations. The emphasis in software development is something Jeff Moden will appreciate: developers not writing robust code. There is also a section on designing to meet only 95% (or less) of perceived use cases, which I think is just reality. We can't write software, in any practical sense, to cover 100% of use cases.

The final section talks about incomplete testing. While software development has gotten better here, there is still plenty of work to be done, especially with database software. I find far too few database engineers wrap tests around their code and often have problems with new data or when code is refactored. A few more tests added early often prevent issues later, or at least, save time when debugging. This is one place I think AI might really help with labor savings by writing these tests for us.

Technical debt is a reality of life. We have imperfect engineers, we have the pressures to get things done, the increasing complexity of software systems, and perhaps most of all, the pressure to keep moving forward with something new instead of refactoring something old. I don't have any great solutions, but I also do see software developers working better than they did in the past. That gives me hope for a future where software is embedded in more places and used more every day.