Pay off your Technical Debt like a Git Analytics Pro
By ZOLTÁN PERESZTEGI
Technical debt stifles software development productivity, causes developers to quit, deadlines to be missed, and it is inevitable. As there’s no way around it, you and your mighty team of software developers must work through it, pay it down, and constantly keep an eye on it. Technical debt is accrued in different ways with planned, unplanned and inevitable forms requiring a wide range of controls like Git analytics. But, how do you know if technical debt is already out of control, and more importantly, how can you get rid of it? Rest easy, the insight you’ll gain here will will help you pay that debt down.
Defining Technical Debt in Software Development
Technical debt is used in software development in reference to the cost of future work as a consequence of taking shortcuts today. Shortcuts may be taken in the software’s code; development tools, practices and procedures; technical documentation, and testing. It is frequently necessary to rapidly provide clients a proof of concept to show investors or to reduce time to market. You may not have time to do everything done before the deadline, so you leave it until later. It’s work you owe and it still needs to be done.
The core point is that technical debt, just like credit card debt, must be carefully managed for its tendency to accumulate interest across each iteration or software version. The longer you don’t address it, the more difficult it becomes and the longer it will take. If you don’t pay down your technical debt, it can spiral out of control and threaten a business’s existence. Someone high up on the food chain is likely to notice something is amiss and take steps to correct it. It’s usually a good idea to not let things reach that point!
This is not to say that technical debt, unto itself is a bad thing – not managing technical debt is very dangerous. That’s especially the case considering the low cost of automated Git analytics that can be used to track developer productivity metrics that can help identify how your debt is being accrued.
It deserves to be noted that, yes – technical debt is an abstract concept, but a useful one. Time is also fairly abstract. We can measure time, predict how much work can be completed and correlate it to an hourly wage. Software developers agree to create a product by a specific date and incur technical deb when a portion of that product isn’t done by that date. It is just as abstract and yet quite nearly as real as a thousand $100 bills.
Three types of technical debt
There are different types of technical debt in software development to go along with the financial allegory, with different strategies that can be used to pay them off. The spread ranges from long-term loans with low interest rates to loan sharks with 400% rates who’ll send someone to break your knees if you don’t pay up immediately. For our purposes, three types of technical debt can help keep your priorities straight with all software development projects.
Planned technical debt. The most frequent way of developing a good credit score is by assuming manageable levels of debt and showing you can reliably pay it back. A good example of using technical debt to help your “credit score” is when you are approached by a startup in urgent need of a proof of concept. The client and anyone they show the PoC to isn’t likely to be concerned about minor features and technical documentation. That work can be done later, with no adverse impact on anyone. Unfortunately, planned technical debt constitutes a small fraction of the overall debt all developers will incur over the long-term. It is usually the easiest to pay back because it’s a known issue.
Unplanned technical debt. This is the frequent result of numerous root causes associated with a lack of knowledge, awareness or experience with software development tools, practices and processes. Unplanned debt can extend from poor communication, poorly defined specifications, newly hired or inexperienced developers without proper supervision, to a lack of testing or awareness of better tools and resources. Even engineers make mistakes. Because unplanned debt can originate from so many different root causes makes it the hardest to track and pay back, especially if you aren’t using Git analytics. It is the most dangerous type of debt to ignore.
Inevitable technical debt. It doesn’t matter how utterly awesome your development team is, technology has a way of changing… frequently. Indeed, the faster technology evolves, the faster it will continue to evolve. Businesses must also evolve to remain competitive and that means you can expect to make a lot of changes to the software you develop for them. It’s likely to comprise the majority of technical debt, maybe not the easiest to pay back, but part of the routine that drives software development.
Laws and legal obligations can force changes in software, too – like the EU’s General Data Protection Regulation (GDPR) that went into effect in 2018. Even legal changes are generally not associated with technical debts they need to be watched and included in plans. If not, they can have the same impact as unplanned technical debt.
When do you have too much technical debt?
This might be something that reminds you of Jeff Foxworthy’s comedy routine or the Dilbert comic strip, though chances are you won’t be laughing. The following points are good indicators that you probably have too much technical debt:
Code complexity makes it difficult to deliver accurate work estimates.
You frequently miss deadlines or have to delay features.
Your Git analytics tracking shows excessive levels of code churn, especially when approaching release dates, when code churn should be minimal.
High-turnover on the software development team can be a solid indicator, if not explicitly associated to technical debt, to specific factors contributing to it.
When software components and modules are so interwoven it becomes difficult to tell where one ends and the next begins (the proverbial big ball of mud).
When your backlog of bug fixes keeps growing instead of shrinking.
There may be other indicators, suffice that openly communicating, maintaining and enforcing best practices and procedures are your key components to preventing its accumulation. Software tools that automatically track a comprehensive range of Git analytics, software development and performance metrics will save you a lot of time and provide you much greater insight into where and how debt is accumulating.
How do you get rid of technical debt?
Remember, there are three basic types of technical debt – planned, unplanned and inevitable. In an absolute best-case scenario you only ever likely to achieve temporary and short-lived periods of being technical-debt free. Even so, the less, the better, so let’s jump into the process to get rid of it.
Have an open conversation with your client about technical debt so they understand what it is and why it happens. This helps to keep your roadmap intact and avoid changes midstream and at the last minute, by helping them to understand that has a cost and consequence.
Track and document all elements of technical debt in the software backlog.
Incorporate automated Git analytics to help measure developer productivity and save time in identifying the root causes creating more technical debt.
Prioritize your technical debt from top to bottom with the highest-priority being anything that may threaten any Service Level Agreements which can lead to legal problems and financial penalties.
Address very high interest threats – code and components that frequently change, sources of critical bugs, and issues that your client or their customers are most vocal about.
Between the highest and lowest threats, there may be a lot of competition over which work to prioritize next. This requires evaluating the severity of the problem, its frequency, the amount of work to fix it and how you can fit it into your work plan.
Lowest-priority is anything that still works as intended, rarely changes or is rarely used, is the source of infrequent, non-critical bugs, regardless how ugly it looks.
As Stefan Wolpers suggests, “Pay down technical debt regularly every single sprint. Consider allocating 15 to 20 percent of the Development Team’s capacity each sprint to handle refactoring and bug fixing.” Regular refactoring is likely your number one way to get rid of technical debt.
If you haven’t done so already, incorporate API-led connectivity to better connect all elements of your tech stack – it’s methodical way to connect data, devices, systems, and applications through reusable and purposeful APIs
Communicate, maintain and enforce best practices that help avoid accumulating technical debt.
Unless you put a halt to how you are accruing technical debt, you’ll probably never make headway in paying it down. It’s like taking loans to pay off loans, at best you might get a lower interest rate. The cost to automate tracking of developer productivity and software development with Git analytics to identify the root causes of your technical debt can provide you an exponential return unto itself. If you make a serious commitment to paying off your technical debt, chunk by chunk over time, it is inevitable that you will succeed.
Putting a Lid on Technical Debt
Technical debt is a deep subject detailed more extensively in books like Managing Software Debt: Building for Inevitable Change by Chris Sterling and Managing Technical Debt: Reducing Friction in Software Development by Phillippe Kruchten, Robert Nord and Ipek Ozkvava. Those are good sources if you’d like to know more. Nevertheless, you can find rapid relief by using software development analytics like we offer in Gitential to help identify some of the leading causes of technical debt in your software projects. You might be able to catch one of your senior developers before she jumps ship.
Your best bet is always to do your best to avoid accruing technical debt in software development in the first place. But we hope our tips and guidance help light the way for you to pay off the technical debt you do have with the same kind of automated Git analytics tools, best practices and strategic thinking comparable to that used by the best banks and investors in tackling financial debt. In the end, yes – technical debt is an abstract concept, but it’s impact in absolute dollars is very real. Make sure to bookmark us and follow us on Twitter @gitential to keep track of the latest developments for using Git analytics and Gitential to keep your team’s technical debt to easily manageable levels. Happy coding!