What is Technical Debt?
Technical Debt is a programming concept that originated from making ‘Quick & Dirty’ development decisions
The software industry is a volatile world. Technologies trending today will be outdated in the near future. When the .NET Framework was released in the early 90s, developers were crazy about learning this new technology. But cut to 2010, and no one was keen on learning this framework. It’s because its days of glory were long over. Objective C and Perl are also following the same roadmap, and we won’t be surprised to see these languages completely out of production soon.
Machine Learning, Deep Learning, Blockchain, AR/VR right now are the hottest concepts in the market but we don’t know if we still will be working with these technologies 20 years down the road or not.
In short, as time progresses and new technologies arrive in the market, the old programs are labeled outdated and their demand and support tremendously decrease. In this writeup, we will be discussing the concept of ‘Technical Debt’ and we will also have a look at how changing technologies have an impact on Technical Debt.
We all have taken loans from the banks, right? When you take a loan from the bank, the bank charges you a certain interest and you have to repay the sum of the original amount and the interest to the bank. Therefore, it can also be said that you are officially in ‘debt’ i.e. you owe money to someone. The longer it takes you to close your loan, the worse it gets.
The case is the same with Technical Debt as well. Technical Debt is a programming concept that originated from making ‘Quick & Dirty’ development decisions. The overall result is that there is now an overhead cost involved in reworking the code, which is now not working up to the expectations, because of taking the shorter route. But, is debt a bad thing? It certainly depends upon the situation and how you use it. Stay tuned as we read more about Technical Debt.
Get Alex Gostev’s stories in your inbox
Join Medium for free to get updates from this writer.
Everything has a reason. Similarly, there is a reason behind Technical Debt as well. While Technical Debt now has become a recurring event in the life of Software Developers, it is important to know the reasons behind it. The following are some of the main reasons behind this concept.
1.Time Constraints:
Software Developers are always working with tight deadlines. Call it the overpromise by the management or the laziness on the part of the developers, it is a true thing that Software Developers are always under pressure to meet deadlines. With such a scarcity of time, it’s reasonable that developers are looking forward to making the code work than anything else. Therefore, they often forget to keep track of concepts like Time and Space Complexity, Code Quality, and Scalability. Therefore, at present, the code works perfectly fine but as time progresses, the client sees a lot of bugs in the program and might also notice that the speed is not what he/she expected. This leads to a situation of Technical Debt.
2.Miscommunication & Business Decisions without consulting the Development Team:
As surprising as this may sound, this is actually one of the major reasons behind the concept of Technical Debt. Most of the clients are non-technical in nature and while making the requirements, they cannot distinguish if the feature is implementable or not. Also, the question is whether the feature is really required or not. This often creates miscommunication between the development team, the managers and the clients. This leads to the random implementation of features & if the client is not satisfied, a redo is assigned in the case.
3.Lack of Future Planning:
Let us suppose a Software Team is building a SaaS Product. Initially, they thought that their servers would receive 1000 requests/hr. Therefore, they implemented the concepts in such a way that their server could handle 1000 requests + some overhead/hr. But, suddenly their product gained popularity and now there is an inflow of 100000 requests/hour. The software developers are therefore unable to manage the requests as they have not thought about the scalability factor. This would require them to rework their code again and hence a situation of technical debt arises.
4.Changing Programming Languages:
As mentioned in the first paragraph, changing programming languages also play an important role in the concept of ‘Technical Debt’. Though it is a long-term effect, it surely contributes to this concept. A new software written in some very unpopular and old programming language would surely need to be reworked in the coming times.
5.Lack of Coding Standards & development by Junior Devs:
Big companies care a lot about coding standards. Startups, not so much. The end result, the code becomes messier and messier and at one point in time, it becomes problematic to debug and add new features in the code. Similarly, Junior Devs and recent graduates need to be trained on Coding Standards & Code Quality, otherwise, the code might be messy and it will become difficult for future devs to understand the code. In either way, a situation of technical debt is created.
Once, we have identified the reasons behind Technical Debt it is now important to understand how we can reduce the debt. We mentioned some of these, however, we won’t be describing them in detail. Some of them are suggested below:
1.Recurring Code Reviews
2.Choosing a Flexible Architecture
3.Proper Testing (Automation Preferred)
4.Keeping a record of the changes
Conclusion
We hope you have now understood what technical debt is and why it is important for software teams to successfully negate it. We also hope you would follow the above-mentioned suggestions to reduce the technical debt.
Originally published at https://duecode.io
