By RJ Robinson, Sr. Software Engineer, Code Climate
“Technical debt,” a common phenomenon and phrase in software development, conveys the metaphorical price paid for taking shortcuts or postponing upgrades today, which will need to be addressed in the future. This is not unlike borrowing with a credit card – every shortcut or omission increases your project’s technical debt. As with financial debt, it accumulates interest over time, becoming more significant the longer it goes unaddressed.
Likewise, credit management principles provide a wealth of lessons on planning, assessing risk, and prioritizing responses, which align remarkably well with software development challenges, especially the technical debt issue. Applying these lessons can benefit engineering organizations looking to implement stronger practices in managing technical debt.
Understanding Technical Debt through Credit Card Debt
In credit management, preparation is key. The saying “If you fail to plan, you plan to fail” also holds true for software development, particularly regarding technical debt. The first step toward controlling the risk of debt spiraling into an intractable problem is to have a system to identify, track, and manage it.
Understanding and documenting technical debt is paramount, like maintaining a good credit history. It’s about diagnosing the root cause of the problem, pinpointing the shortcuts taken, acknowledging the effect on the software’s performance, and strategizing on how to tackle it. Later we will describe the D.E.B.T.S. framework you can use to assess and properly document your decisions.
Assessing the Urgency and Severity of Technical Debt
Credit card debt can pile up, and it’s important to understand the level of attention required. Time is of particular importance here. We need to identify this point to be clear. Often, there is more leeway to address an issue than initially assumed. As we dig into a problem, we often find that it’s not as simple as we thought, and while every situation is unique, identifying areas of future work is pivotal when managing tech debt. Postponing a refactor, monkey-patching a class, or delaying needed package updates could snowball into a level of work that a team doesn’t expect.
Once these decisions are made, it’s vital to document the decision. Using git, inline comments, or a ticket explaining what the debt relates to and adding context will help the future developer correct or troubleshoot the issue. As most companies participate in some form of code review, this is another area for identifying technical debt. Fellow software engineers might have an eye for introducing a code smell or violating a best practice. As the reviewer, ask the author why they made that decision. Another important point would be not to ask leading questions. When you notice that something isn’t quite right when reading code, ask why they did this, and then provide context as to why you are asking this question. These are a few steps in helping identify tech debt. Other tools that can also help include static code analysis, dependency health checkers, and regular cleanup sessions in an aging legacy codebase.
The Importance of Planning in Addressing Technical Debt
Addressing technical debt effectively requires fully understanding the problem before identifying solutions. Similar to creating a plan to repay credit card debt, a significant amount of time should be dedicated to planning and strategizing a response in software development. If a problem or decision cannot be explained to a colleague, it signifies a need for more understanding and clarity. Recruiting engineers at all levels (early career, associate, senior) is a great step in including different viewpoints. These conversations often uncover the root cause of problems, many of which can be traced back to an earlier decision that failed to consider its downstream implications. This process can be invaluable in devising a plan to deal with existing technical debt and avoiding similar issues in the future. As mentioned before, context in resolving tech debt is immensely important. When you fully understand the context, understanding the problem is the next step.
Prioritizing and Addressing Technical Debt
Similar to creating a credit card debt repayment plan, a strategy for managing technical debt can be adopted. Identifying and prioritizing the most severe instances of debt – those that carry the highest metaphorical “interest rate” in terms of performance impact or time required for future remediation – can help teams manage their debt more effectively. This process requires a holistic understanding of the technical debt landscape, which can only be achieved through meticulous documentation and regular review.
A Methodology for Software Maintenance
The following framework can help assess and organize tech debt:
D.E.B.T.S.
- Discover: The first step in managing technical debt is to identify it. This could involve code reviews, software analysis tools, or even discussions among team members. The goal is to understand where and why the debt exists. “D” could also stand for Document.
- Evaluate: Once the debt is discovered, evaluate its impact. How does it affect the software’s performance, maintainability, or functionality? How urgently does it need to be addressed? This step involves risk assessment and priority assignment.
- Balance: Weigh the cost of repaying the debt against the potential benefits. Sometimes, it might be more cost-effective to leave some technical debt in place while focusing on more critical issues, especially regarding time, resources, and business value. This could also be left in place because you don’t have a better solution now.
- Tackle: This step involves addressing the technical debt. Depending on its nature, it could be remediated through refactoring, rewriting, or replacing the affected code. The approach should be systematic and align with business goals and resources.
- Sustain: Finally, learn from the past and implement measures to avoid accumulating the same kind of debt again. This could involve updating development practices, improving documentation, and ensuring regular reviews.
By following the D.E.B.T.S. framework, teams can effectively manage technical debt, keeping their codebase healthy and maintainable.
Lessons from credit management for software developers managing technical debt are as crucial in software development as handling credit card debt in personal finance. By applying principles of preparation, risk assessment, and planned response from credit management, fresh perspectives on managing technical debt can be gained. At its core, technical debt involves a continuous cycle of preparation, action, and reflection. By incorporating these principles into daily practices, we can not only keep technical debt in check, but also create software that is robust, maintainable, and efficient.
##
ABOUT THE AUTHOR
RJ Robinson is an experienced software developer and computer science graduate dedicated to creating and maintaining complex systems. RJ’s experience as an EMT gives him a unique perspective on software engineering, where he believes in finding and fixing the one issue that could cause system degradation. RJ is committed to delivering high-quality, reliable, and efficient software by focusing on clean and maintainable code. In his free time, RJ enjoys exploring new technologies and software development practices.
