Measure And Control The Technical Debt
Previous articles of mine explained about, what is the technical debt and how this impacts the total cost of ownership. The articles also included why a Product Should care about the technical debt and allow the development team to refactor the code to control the technical debt.
Anything that can be measured can be improved. For improving (lower) the technical debt, the pre-requisite is to measure it first.
Developers or sometimes the Product companies do categorize the technical debts. There are no rules defined, but one can organize the technical debts and then use some methods to deal with that.
- The debt classification:
- The debt of defects
- The debt of design
- The debt of compliance and documentation
- The debt of ignored tests
- The debt of algorithms and flawed logics
- The debt os the architecture
- The debt of team skills
- Many more…..
These debts lead to the Product pains of reliability, maintainability, portability, security, recurring issues, and many more that elevates the Product operational cost.
To deal with technical debt, the developers should follow three simple steps:
There could be various ways and tools in the market that help measure the technical debt, but the one popular amongst all is the static code analysis tool “SONARCUBE.”
SONARQUBE is an open-source tool that comes with plugins for various coding languages. The tool measures the technical debt in days for the lines of code written for the Product. The tools help navigate developers to the lines in the code requires considerations.
This tool could help with the coding standards and clean coding practices that developers should follow when writing the code.
For dealing with tech debts from the legacy codes, the extreme programming practices are of great help.
Signs of a Healthy Product
Things the developer could do to control the technical debt:
1. Define and track technical debts.
2. Place the technical debt under the Product Backlog and collaborate with the Product Owner to prioritize it.
3. Use the Test-Driven Development approach for any new code development.
4. Identify the sensitive sections/modules which carry most the logics that gets touched when developers develop the new functionality or maintaining the existing functionalities. Write the test cases for those logics and scenarios.
5. Bring as much automation as possible.
6. Block a percentage of the Sprint capacity for refactoring the code.
7. Integrate the code as frequently as possible for the early feedback.
8. Continuous skill development for the developers utilizing pieces of training
9. Use continuous integration with the help of tools and limit the technical debt
As a Product Owner, one must care about the technical debt, failing which causes a long-term catastrophe, where Product maintenance cost becomes higher than the revenues, and the Product ultimately gets grave.