Presented by Georgios Digkas from the University of Groningen and Macedonia. Technical debt is already a well-known subject in software engineering. Doing things quick and dirty might be good in the beginning, but may hamper future maintenance.
One could also say, it is the result of sins of development. So, what are these sins? how frequent are they, how does it behave over time? With SonarQube they created a set of rules to analyze technical debt, and studied 66 projects. They studied the question: “how does TD in the apache ecosystem evolve over time?”. They created a time series per project and performed a Mann-Kendall test to detect trends in the timeseries. However, the data is not normalized to the size of the project: projects increase in lines of code. Otherwise, the comparison is not fair. Although SonarQube defines a scale factor, they decided to go for their own. This normalization shows that over time it gets better:
Next, they study the most frequent types, and what are the most costly. Duplication counts for 20% (!), exceptions are on the second place. So, although it seems technical debt increases, per line of code it decreases, and most frequent are low-level details, and only a few problems cause the majority of the technical debt. Of course, more research is needed in different languages and ecosystems to find the most costly technical debts, and to know which ones to repair first.