Avoid Technical Debt Like You're Borg
By GITENTIAL TEAM
The Pareto Principle and Git Analytics
80% of the effects are the result of 20% of the causes.
Also known as the 80/20 rule, odds are you know all about it. It’s not always so exact as 80/20, but it’s amazing how well this applies when analyzing nearly any economy of scale (like lines of code). The principle extends on a more or less consistent ratio across all subgroups, which leads to the notion that over half of effects (51%) can be tied to just 1% of the causes.
TLDR; There’s a good chance that you can achieve a 50% reduction in the rate your software project is accruing unplanned technical debt by addressing one issue – code reviews.
The Pareto Principle makes two other assertions helpful for software project managers:
Roughly 30% of the other factors likely associated with your rate of accruing unplanned technical debt can be handled with a small handful of solutions. These likely include unit and functional testing, continuous integration, and starting software projects off with more detailed requirements.
A minority of effects are caused by the majority of causes. The last 20% of causes leading to unplanned technical debt stem from a much wider range of causes. Automated developer performance and software development analytics like Gitential are your most cost-effective means of identifying and solving them.
The key to radically reducing the rate you accumulate technical debt is knowing which root causes are contributing to it the most. They are likely to be fairly few in number. As you come to grips with one, you can tackle another and another.
Quantifying the impact of technical debt
Twenty percent is still a huge number. If measured by dollars and profit margins, is enough to put most businesses out of business. Most software project managers are not oblivious to technical debt. They do factor it into their work projections and it is included in cost estimates provided to clients. Nevertheless, technical debt has an adverse impact on competitiveness, overall throughput, and a software development team’s ability to take on additional software projects.
Taking $108,000 as the average wage of software developers in the United States lets us make a few very simple calculations. Taking an average of $1 million of technical debt per business application infers you need 9 software developers for a year to pay it down. For every 10% lapse in efficiency, you may need another developer. Of course, it’s not nearly that simple, but even a vague idea of the cost of technical debt and its impact on software projects is an incentive to avoid it.
Avoiding planned technical debt
Planned debt is often incurred with software projects at an early stage, and can be instrumental for meeting tight deadlines. Simply knowing about it is half the battle, and for that reason I don’t consider it dangerous. To the contrary, it is often desirable. It can mean the difference between taking on or turning away a client urgently needing a proof of concept. Used responsibly, it can help to meet deadlines that might otherwise be missed due to sickness or real-life emergencies of your team members. It’s the unknown and unplanned technical debt that deserves extra effort to keep in check. Unplanned technical debt can spill over and cause your best laid plans to go awry when trying to pay off your planned technical debt.
Tips to avoid unplanned technical debt
The methods to avoid technical debt are as vast as the different ways it can be incurred. With unplanned technical debt, you’re in the dark, not knowing or being able to quantify how much work you owe, where it is, when, why, or how it got there. And, until the root causes are identified and contained, you don’t know how much more technical debt is being added daily through bad practices, poor definitions and procedures. If you don’t get a grip on unplanned technical debt it will cause inaccurate work estimates leading to missed deadlines, or worse – cause serious problems with Service Level Agreements.
Most unplanned and a portion of inevitable debt can be avoided by observing the following tips.
Awareness of what technical debt is and the many ways it may be incurred is the first step in being able to avoid it.
Consider the risks and advantages of development decisions from the outset of a software project and with any changes in requirements.
Make use of software development and Git analytics tools to automatically track performance metrics that can help identify causes and contributors to unplanned debt.
Strive to clearly define project requirements for software developers from the start.
Communicate, maintain, and enforce consistent quality standards so all team members and outsourcing providers know what is expected of them.
Good code is self-documenting, avoid ambiguous variables, names and statements.
Conduct frequent (daily) software code reviews, the advantages are numerous.
Try to keep components modular and avoid coupling components together too tightly.
Regularly include refactoring in every sprint to prevent code rot.
Take extra steps to ensure new hires and junior software developers are mentored in best coding practices. Many teams use code reviews as part of their onboarding and training processes.
This is just the tip of the iceberg of root causes contributing to unplanned technical debt. Maybe you’d like to tell us on Twitter about the strangest or scariest root causes of unplanned technical debt that you’ve seen? We’d love to hear about them, and with your permission, would be happy to add them to our list.
Inevitable technical debt
Argument could be made that many of the factors considered here are not strictly speaking, technical debt. Even so, they can have the same impact. They deserve to be addressed because with awareness you can plan for or avoid them. Inevitable technical debt examples are typically a consequence of changes in technology, law, and the market. It can also be the result of social and political shifts, as well as changes in a client’s business direction. You have little control over these kinds of changes, but they often have a very real and sometimes very large impact on your work.
Just recently, Apple and Google Play stopped supporting 32-bit apps. Throughout 2018 and 2019, most developers stopped support for 32-bit OS’s as over 90% of Windows users either had or could upgrade to a 64-bit version. New laws, like the European Union’s General Data Protection Regulation (GDPR) generated a lot of extra work, with enough advanced notice that most software developers were easily able to include it in their work plans. Then there’s the on-off-on-off-again-and-finally-done Brexit which will impact EU and UK software developers needing to comply with European and British standards.
One of the next major changes for software developers already in progress involves the roll-out of 5G networks and whether you choose to make use of Huawei components or not. For that matter, though possibly behind us, issues like the US-China trade war can also have an impact on technical debt, especially when developing companion apps and software for IoT devices.
Changes in the cost or availability of a chip can lead to changes in the architecture of a device and corresponding code of software components. Hardware and device software developed in parallel are predisposed to frequent changes in requirements during initial prototyping. The discovery of security vulnerabilities or release of newer chips with much higher performance can also prompt changes at any point. A company initially deciding to use Huawei components finds the US and European countries (i.e. NATO) or key customers blocking them and reversing course is another example.
Tips to avoid inevitable technical debt
Beleaguered software developers and project managers may begin to think that the entire world is conspiring to keep their software project in deep technical debt. You can take solace that this is not by malicious design or a nefarious cabal seeking to make your life difficult. It’s worse than that! You can blame Ray Kurzweil’s Law of Accelerating Returns.
Okay, seriously, inevitable technical debt is more good than bad. For now at least, it’s a guarantee of job stability. The following tips won’t prevent the inevitable, but can go a long way to help you mitigate it:
Keep current on news, events, industry trends, and new technologies that could have an impact on your clients and the software you are developing for them. Scan the headlines and set up alerts so you can keep abreast of developments that could impact your team’s work.
Following industry trends and market adoption rates of new technologies and devices can help you plan major changes well in-advance.
Keep an eye on the performance of any third-party resources you are using, and how the companies themselves are faring financially. This may be a big ask, but new, potentially better solutions are rolling out fairly regularly from the 100 million or so startups formed each year. Conversely, some 80-90% of startups are likely to go out of business or be acquired over the next five years.
Consider options and devise contingency plans for the most likely negative scenarios so you can rapidly switch gears should it become necessary.
The Singularity is coming…
For as sure as the sun will rise tomorrow for the next few billion years, or until we achieve Singularity, software developers must continuously sharpen their edge. Whether inevitable or unplanned technical debt or its net effect is the result of sloppy code, an accelerated roll-out of 6G networks, or social-political induced boycotts you can only manage it if you are aware of it. Automated software development analytics and developer performance metrics will save you time, help identify and enable you to prioritize efforts to avoid technical debt. If you’d like to Analyze your repos and boost development productivity I welcome you to sign up for a free 15-day trial – no credit card needed!