How to Reduce Technical Debt?
It does not matter if you are Manager, Scrum Master, CTO or Team Leader, you probably know how annoying is the technical debt in your projects and how it negatively affects to the workflow of your engineering teams.
Software companies encounter many serious problems when they try to ship to production in time. Normally, software factories have a large client portfolio which they have to deal with daily and respond to different demands. This use to create a certain lack of control inside the teams, so they have to move depending on technical needs.
Having big and diverse demands, companies must know how to manage very well the technical needs of the project where the engineers work. Most of the occasions, the solutions companies propose are:
- Relocation of engineers in other projects or repositories
- Leave tasks that are in progress (WIP) back to quarantine
- Reuse of code in several projects (which can be very critical)
- Defragment work units between various repositories
This kind of solutions have a tremendously negative impact on the workflow of the software engineering teams. Some of them are:
- The control of every task ends up being relocated
- Out of control of the workflow
- Increase of the team stress
- Decrease in the motivation of engineers since they don’t ship on time
But, ¿how can we reduce technical debt?
1. Detecting the root of the problem
The truth is that the different organization methodologies like Agile, Lean or Scrum are the first approach or a starting point to the problem, which ultimately lies in the work that engineers do.
Do not set clear code policies finally generates technical debt in the medium and long term of most software companies, mainly in consulting and software factories companies.
Eliminate this problem start by establishing good coding practices in the engineering teams since they have the power of generating the work that will be later produced to the different clients.
Establish good coding practices is the very first step to approach the problem correctly. The good coding practices are a very clear example of how a coding standard inside the code methodology will seriously decrease the error frequency.
Of course, inside the coding practices, there is a fundamental premise: the reviews should be inside the engineering teams. Follow good practices and, in consequence, making good reviews is the base to reduce technical debt from the beginning.
Making good reviews we achieve some of the key points to produce good code quality:
- We avoid refactorizing
- We stop creating junk code
- We keep the code clean
- We involucre to the team in all the processes, generating more knowledge about them
2. Establish a secure organization methodology
The different work organization methodologies established in the software industry are commonly used and, of course, they are very useful if the patterns to follow are correct.
However, it is not only enough to organize sprint and retrospective meetings every so ofter. The objectives must be very well defined. To achieve establish clear objectives we must have clear metrics that we have to follow, respect and analyze. We have been already talking about the best software engineering key metrics to make sprint and retrospective meetings more productive and effective. Basically, we need to understand what we have to measure to produce better.
If we want to resolve code problems, we have to control some basic metrics like:
- Time of Pull Requests
- Time engineers take to Review the code
- Time engineers take to Open new Pull Requests
- Control the workflow of Work in Progress and Work Finished
- Pull Request Frequency
With these metrics, in addition, we may be able to predict and measure technical debt, having a clear idea of what is generating the problem inside the code.
3. Make use of a software that controls the engineer’s workflow
Metrics by themselves does not apport much information if there is no data that can clearly introduce us about the progress and evolution of those metrics. There are so many tools that can explain how the workflow is going on. In Scope, our proposal is very precise - control time and the impact of every engineer’s task helps to predict technical debt:
- The time required that a software company needs to finish a product
- The cost that every project takes in base on time to complete every task
- Detect technical debt that is generated, assuming costs for refactoring dirty code
Scope helps Managers and Team Leaders to control, know and predict technical debt that is being produced. Knowing the average response time to a review request or the average time that the Pull Requests are opened gives us a fairly useful approximation to predict the future time needs and, ultimately, the overall costs.
Finally, technical debt is something inherent in the code, but reducing it has a positive impact on the workflow of software engineers, in the work organization of the different teams and, definitely, on the deficit and achievement of objectives of a Project Manager within a company.