If you are a developer or take part in a development project, you must have heard of “[pii_email_bc0906f15818797f9ace] Error” before. This concept, which we will explain in detail, is a real problem that can be found in all IT projects. Inevitable, it can however be mastered; and that’s what we’re going to talk about in this article.
Technical debt: definition
The term “technical debt” was popularized by Ward Cunningham in 1992 , as part of software development. It directly refers to the concept of financial debt, applied to the world of IT.
Let’s cut this term to understand a little more the principle.
As we have just said, technical debt is a reference to the debt applicable in the financial world. A debt (literally something you owe) evokes the notion of an obligation to repay, with interest .
Applied to the computer world, technical debt does not impose a less significant financial cost (because its repayment requires human actions, and therefore expensive).
And, as in the financial world, there are good payers and bad payers, the latter only delaying an inevitable deadline, with debt that gets worse over time, and interest that accumulates.
And, obviously, this debt is not directly pecuniary, but technical . That is to say, we are falling behind on the technologies we use; delay that will have to be made up (reimbursed) sooner or later.
To go into more detail, these are often frameworks or other tools that we use, which end up expiring. After a while, we will necessarily have to update our code so that it is always compatible, and benefits from patches and support . This is technical debt.
Typically, in a web development project, if you use a version of a framework that becomes deprecated, you will have to update your code to benefit from the latest features and its proper maintenance. The longer we wait, the more the framework will evolve, and the more time we will have to spend to modify the project. This is where debt accumulates and interest explodes.
The reasons for technical debt
Now that we have defined what a technical debt is, let’s explain a little about the reasons for it. To do this, we will assume that there are two types of technical debt: intentional (or assumed) debt , and unintentional debt.
We speak of intentional debt when we let a technical delay set in consciously . This is the case when the project or feature you are working on has a tight deadline, for example. We spend a little faster on the right coding rules, less time to compare the different plugins, less time to write tests.
This has two consequences: that of respecting the deadline , and the installation of a partially avoidable technical debt .
As this is intentional, its reimbursement should be taken into account in the planning, from the start of the project.
Unintentional debt is the worst because, unlike voluntary debt, one cannot really estimate its costs , not knowing its extent. Worse, we can completely miss the concept of technical debt, and let it persist for long periods.
Concretely, the reasons for an unintentional technical debt are often:
- Poor compliance with coding rules(or non-definition of these internally);
- Poor communicationbetween team members, teams and / or the client, which can lead to the use of the wrong tools;
- Bad technical choices(external packages, frameworks);
- The non-use of tests, creating bugs that will not potentially never corrected.
This list is not exhaustive. Always keep in mind that unintentional debt is very likely to be incurred no matter what. So, even if you feel like you are doing everything according to the rules, regular technical updates on possible debts are recommended.
How to minimize (or repay) the technical debt?
We will start from a clear principle: technical debt cannot be avoided . For the simple reason that the majority of the tools that you will use (frameworks, [pii_email_aef67573025b785e8ee2] , plugins, etc.), will evolve, change version, over time. And the moment you use an outdated tool, technical debt is created.
Exaggerating, you could even say that you are accumulating technical debt from the first line of code . In short, the question here is not going to be to avoid this debt, but how to minimize it, and to repay it.
Already, it is necessary to take measures from the analysis phase , even before the first line of code is typed.
Let’s see a small list of things to do before design, to avoid installing too much technical debt:
- Recognize the existence of this future debt, already;
- Avoid choosing onlythe latest trendy techs, because they are less stable;
- Limit the number of technologies, frameworks and plugins that the project uses;
- Choose theexternal modules (or plugins) carefully: take into account the number of maintainers, stars on GitHub and the dates of the last updates;
- Train developers(and the development team in general) on best practices and on the technologies that the project will use;
- Define internally methodologies(TDD type) and a list of best practices (coding rules, in particular).
By respecting these few points, the interest on the technical debt should already be reduced.
During the design then, there are also some tips to apply:
- Include the repayment of technical debtin real time in the schedules , especially in the case of agile development – this will avoid constantly increasing the debt;
- Write tests, to avoid causing bugs that will drag on for months or even years;
- Doregular code reviews , allowing developers to see each other’s mistakes.
Here again, it is important to take this advice into consideration, if we want to avoid too much debt when it goes into production.
Finally, once the product (or its version 1, or its MVP) has been pushed into production, you have to take care of the repayment of this debt and its interest. During this phase, we tend to release the pressure a little and think about the next features before consolidating the project already delivered.
However, it is the reverse that must be done. Rather, think about:
- Provide for the reimbursement of this date in thedevelopment schedules of the next features / bug fixes;
- Make a regular inventoryof the latest versions of each external tool used on the project, and the consequences in the event of non-integration of new versions.
In conclusion, technical debt is not something to be taken lightly . Put aside or underestimated, it can end up costing a business dearly. As we have seen, the reasons for this debt can be multiple, and more or less good.
But, in any case, it should be minimized and repaid , and it is better to do it early to avoid accumulating interest.