Technological debt is not a new phenomenon. The representatives of the IT industry know this phrase all too well, as they are very often forced to face its consequences. The point is not only to know that you have a debt, but above all to be able to deal with it. The technical problems caused by the above-mentioned point make it difficult, and sometimes even impossible, for a company to deliver value – thus its development slows down and labor costs increase. The key to success in technology debt management is regular problem solving as part of the daily work of programmers. The overdue must be settled – otherwise the company could also start from scratch. To put it simply: technical debt is everything that slows down or hinders the development process by preventing programmers from achieving full productivity.
Where does technology debt come from?
The specialists agree on the sources of technological debt. They claim that it is mainly due to negligence and rushing to achieve results more quickly. Sometimes it is the result of badly or hastily written code. It also happens that this code on the day at its origin is the eighth wonder of the world, but after some time it does not perform so well. It’s also possible to incur debt completely consciously, for the sake of the project, expecting some consequences.
On the way to perfection
Optimists believe that technological debt, although usually troublesome, eventually leads the company to where it should be. It’s all about constantly improving the code on the never-ending road to perfection.
The repayment of the technological debt can be compared to rebuilding the source code. Let’s imagine that we have just built the perfect house – everything is in its place and every element is in line with the latest trends. Does this mean that we don’t have any work ahead of us for the rest of our lives? Not at all! After all, we will still have to replace a few elements, such as windows or roof. The changes will not necessarily be caused by time or overuse, but simply by our decision – after all, we want our environment to stay in line with current standards. This way, our house will always look fresh and serve us just as well as it did when it was originally put into use. The same goes for the source code.
Improving is a never-ending journey. Perfection is a state that cannot be achieved – we will always strive for it. The important thing is not to stay behind.
Unfortunately, the technological debt has this unpleasant characteristic and that is that we often fail to notice it until a critical moment. Let’s return to our ideal home for a moment. Imagine that it is already old, but still looks and performs perfectly. There is no indication that the roof has aged and needs renovating. We only find out about it when it starts dripping on our heads. Then comes the time for radical action. If we stay diligent, we will avoid the delays that can cost our company money (regardless of whether we measure these losses in revenue, time or employee commitment). The key to success lies in keeping the code constantly updated so that… the roof doesn’t collapse on our heads.
How to pay off technical debt?
The condition for paying off the technological debt is to have enough time, which, as we well know, we usually lack. Persuading the board to allow us to work on improvements and new functions that will allow us to pay off the debt borders on a miracle. Spending a whole week refactoring the project? That’s probably not going to work.
So what to do? It’s easy. Stay diligent Every time we get a bad code that doesn’t eat up much of our time, we should deal with it immediately. You don’t have to fix everything at once – just make sure that with every approval the code is better than before our intervention. By adhering to this principle, we will improve the quality of the entire code over time, without ceasing to provide the customer with the highest quality product. The robustly tested code based on independent of each other modules saves time. Why? It’s easy! If code is written in modules, it will be easier to fix it by working on its independent elements. Changes made during such a process will not affect the rest of the project, so we will be protected in case of a real catastrophe.
It is a good habit to pay small amounts of technological debt every time we manage to complete our tasks ahead of time. Squeezing out working time in this way is not overzealous, but rather a simple way to reduce the likelihood of an unpleasant surprise.
Another issue is communication within the team. A group of programmers operating within one company should hold regular discussions on the repayment of technological debt. In this way, thanks to a common sense of responsibility for the project, their work will be even more efficient. Detecting and immediately correcting a bug before it is actually integrated into the system is extremely valuable because it does not generate new technical debt.
Specialists highlight the need to prepare plans to pay off any debts. Because, as we know, the precautionary is always protected.
It is worth maintaining good contact with management by sending regular reports on our progress. Even if stakeholders, on average, want to know how we managed to remove dozens of lines of duplicate code, they will be pleased to hear that our refactoring helped to fix a bug that no one wanted to deal with before.
What about this debt? Conclusion
Although the phrase “technological debt” sounds dangerous, sometimes we can easily live with it. The most important thing is to be aware of its existence and know what consequences it entails. For some companies, fixing a bug can mean 100 hours of programmer’s work, while leaving it “unfixed” is a matter of someone from the staff intervening once every 12 months. With such an assumption, fixing the bug would probably pay for itself only after several years. Yes, this is quite an extreme case, but it shows us that the technological debt simply has to be managed skillfully – you don’t always have to get rid of it as quickly as possible, and sometimes it doesn’t even make sense to “pay it back”.