We live in an increasingly debt-driven society.
Think about it. Without a credit history, you are likely to struggle to be accepted for a mortgage or a tenancy agreement, your chances of landing that job you wanted might significantly be reduced, and wonder of wonders, irony of ironies — even a basic credit card could be strictly off the table!
Perhaps unsurprisingly, therefore, in many ways, the same holds true for our software systems. While here, debt is never accumulated as a result of borrowing more funds, it does nonetheless still manifest itself by accruing dues of another kind — technical debt, as it is known.
Put simply, the term refers to the implied cost of additional work that is caused by choosing an easy solution now as opposed to taking a better, yet more complicated approach that would likely take much longer to deliver.
Not necessarily bad
Of course, just as in finances, getting yourself into technical debt is not always a terrible thing. Consider a planned overdraft, for instance. With a little wisdom, you can borrow just enough money that will allow you to pay off any unexpected bills or enjoy a weekend getaway without any major consequences.
Similarly, planned technical debt occurs when software companies knowingly generate a small, but crucially, controllable measure of debt with the total understanding of both benefits and consequences. By taking it on, what developers are really trying to accomplish is buy some extra flexibility, maintain their team velocity, and more often than not, succeed at meeting your deadlines.
In any event, however, it is critical to document which decision has been made, similar in fact to a borrower’s agreement.
As an example, a team leader may record: “in order to meet December’s deadline, we’ve decided not to make use of any unit tests throughout the project’s final week. These will be made up as soon as possible, shortly after our product’s release.”
This, without a doubt, is an excellent way to keep the issue to a minimum, but it is equally paramount to maintain a level of vigilance. After all, the longer technical debt is left ignored or unaddressed, the greater the danger of generating a snowball effect.
As in the monetary variety, technical debt may also progressively accrue interest. In this case, however, the “interest” becomes the additional time it will take to retroactively implement any pending alterations.
The problem here is this is often the result of unintentional technical debt, and in addition to a higher cost of ownership, it can also engender a longer time to market, reduced agility and a damaging effect on the security and experience of one’s customers.
Thankfully, nonetheless, while there are certainly no quick fixes, an efficient countermeasure exists in the form of code refactoring.
In a nutshell, this is the process of improving the structure of one’s software source code without incurring any changes to behaviour or functionality. Yet even though refactoring can often be as simple as merely renaming and reorganising classes, in many companies today, it is rarely used as frequently — or as aptly — as it should.
Boy scout rule
By contrast, at Software Planet, we believe in the importance of fostering a refactor-ready culture — and nowhere is this made clearer than in a trusty ol’ boy scout rule we trumpet: always leave the campground even cleaner than you found it!
Or, to be slightly less metaphorical, whenever you encounter technical debt, make sure to pay your dues.
Along with the obvious benefit of performing constant maintenance, by encouraging our developers to refactor at all times, we are able to keep your code both more readable and less complex.
This, in turn, has the knock-on effect of making further future changes even easier than before, as developers will no longer be plagued with confusing, undecipherable code chaos.
If you can’t beat it, tame it
Whether you like it or not, technical debt is a natural part of any software project. The important thing, therefore, is to not allow it to spiral out of control.
By keeping tabs on our own debt through extensive documentation and cultivating a mindset of continuous refactoring, SPG are fully capable of keeping technical debt in check whilst simultaneously providing you with code of the highest quality.
Our world may be debt-driven, but it doesn’t have to be debt-ridden.