How to avoid and deal with technical debt
Technical debts are part and parcel of the software development process and no matter how careful we approach the development process, there will always be possibility that we may encounter them along the way.
Technical debts imply that a developer, at some point applied the easiest route to a solution instead of using a better approach to a problem that would take time. The most vulnerable time for making these haste decision is when the deadline for release of a software product is nearing and there is still work to be done.
These debts can also be incurred during bug fixing. A lot can go wrong during debugging, and removing a minor bug on a large projects sometimes can cause the whole system to stop functioning as required. This can also be incurred unintentionally where bugs can literally slip through the tester’s hands.
The challenge for the developers becomes how to avoid the debts as much as possible. For situations where they are unavoidable, the developers need to have a working strategy on how to deal with these debts.
Types of debts and how to avoid or deal with them
The first step in addressing the technical debt is understanding the different types of debt. By categorizing this problem, a framework can be drawn on how best to address this problem in your development process. There are different ways of categorizing the technical debt with the most common one classifying it into 3 different classes; deliberate technical debt, outdated or accidental technical design and bot rot technical debt.
In each of this classification, we can address the problems individually, look into how each category can be avoided, and also make a recommendation on how to deal with it if it occurs.
Deliberate technical debt
These are the type of debts that developers know they exist, they know there is a better approach to rectify the problem but chose the quickest way of doing a task instead of the right way. The main reason developers might take this approach is when a product is needed and there is not enough time to go through the long process.
How to avoid this debt
Allocation of enough time to your development team should be a priority. Proper planning, therefore, is needed to avoid this debt.
The project tasks allocation should also be distributed to team members in terms of their abilities. This will avoid team members from always postponing, taking shortcuts or failing to have completed the software development before the stipulated time.
The documentation should also clearly define the requirements of the project and have clear development stories, which are easy to follow.
Dealing with this debt.
In case at the end of the development cycle, a team has deliberate technical debts, it is recommended to track down these debts in the backlog and try to repay them during the next phase of implementation. Failure to do this will have severe consequences in the future.
Accidental or outdated design technical debt
This is when the design or implementation of code is flawed. Developers understand far too well about this problem. They argue that nobody gets it right all the time and they are aware that this type of debt can happen.
Unfortunately, this type of debt is very hard to prevent because of its complexity. Technicalities such as some of your functionalities becoming slow over time or even difficult to implement is a realty that developers must deal with when it occurs.
Dealing with Accidental/ outdated tech debt
System refactoring is a discipline on its own, it is complex, timely but necessary. Teams should set aside time and resources in their settings to ensure that they can address this issue. The teams should also know that the root causes of these issues are design decisions and changing requirements. Therefore, documentation and stories should be well defined in each phase of development to prevent this from happening.
Bit rot technical debt
A system that has existed a long time is exposed to this debt because of constant incremental changes, which causes it to devolve into unnecessary complexity. It is also true that some developers working on this project may not be well equipped and may end up leaving bugs into the system. The developers who are working on this project may also be unaware of the original design. This may also lead to debts.
Avoiding this debt
This debt can be avoided by restricting incremental development to person who is savvy with the system. This is also the only way to deal with this debt when it occurs, one must ensure that the team correcting the bug or debt has a proper understanding of the design and core principles of the system. It is also important for the teams to understand how this debt is slowing their systems down. You must try to understand how the debt is slowing your team down, and balance efforts of delivering features in the short term with increasing overall productivity in the mid to long-term.
Reads:
Leave a Reply