Fields of Investigation

The technical debt challenge can be reduced to the central question: how easily can the code be extended with new features? Or, to put it another way, how easy is it to adapt the code to future requirements?

Focusing on the Really Problematic Technical Debt – Through DETANGLE®!

Technical debt in software is therefore not all of equal value. Not all of it has to be eliminated with the same priority. The developers should first address the technical debt for which the best effort/benefit ratio exists. With the Cape of Good Code analysis, both the effort and the benefit can be estimated. This approach preserves scarce development resources and yet delivers a significant quality improvement in the software base, leaving enough developer capacity to continue to develop new features and bring them to market on time.

Identifying technical debt with new KPIs

Cape of Good Code derives various innovative performance indicators on the location and dimension of technical debt in the software from the analysis results of the DETANGLE® scan. Following important DETANGLE® KPIs are the starting point for measuring the “interest costs” as a result of the debt:

  1. Maintenance Effort Ratio: It shows the share of maintenance effort in relation to total development effort. A normal ratio would be a maintenance effort share of maximally 20%. This value ensures that there is still enough development capacity for value-adding developments such as new features. If the maintenance ratio is above 20% and the trend has been increasing for some time, the technical debt should be urgently analysed, localised and prioritized with DETANGLE® and subsequently reduced.
  2. Feature Effort Effectiveness Index: This KPI shows whether adding new features absorbs more developer capacity than one would budget for. Technical debt makes it more difficult and costly to change existing code and add new features.
Technical Debt and Maintenance Costs

Technical Debt in relation to maintenance along the software life cycle

If analysed regularly, both KPIs mentioned are meaningful early indicators of whether technical debt is building up in a critical way in the code.

When critical thresholds are exceeded, the system-level KPIs can be broken down to individual code areas. This makes it possible to identify the really risky hotspots of the code with little effort. These can then be subjected to a detailed analysis to identify the root causes and recommend tailor-made countermeasures.

The following figure shows the most important problem sources for unstable functionality, poor performance and problematic further development of software on the left-hand side. On the right-hand side, the KPIs already mentioned and other KPIs are listed in order to uncover the critical code areas and examine them for the root causes of the problems.

Root Causes of Technical Debt

Root causes of Technical Debt and their measurement by a DETANGLE® analysis

For good software, architecture quality is often more relevant than code quality.

This is especially the case when dealing with high quality software with the expectation of a long life cycle. Our DETANGLE® metrics for architecture quality clearly correlate with the occurrence of high maintenance effort and are thus an effective indicator of architecture deficits and resulting problems in the further development of the software.

For further investigation of code quality metrics (such as cognitive complexity, code duplications, potential bugs or security vulnerabilities ), proven static code analysis tools such as Sonarqube are integrated into the DETANGLE® platform.

The strength of the DETANGLE® analysis is that technical debt is comprehensively quantified as “unnecessary” additional effort. This gives the project manager, for example, the facts to make a timely decision about refactoring the code hotspots to reduce the “interest costs” of the technical debt.

Contact us for more details.

What are the Requirements for a Technical Debt Analysis with DETANGLE®?

A basic prerequisite for the efficient analysis of technical debt is the use of a code repository for version management (such as Git) in software development. In this repository, individual change steps of the source code development are stored by the development teams. It thus functions as a kind of historical memory of the code versions. DETANGLE® supports both in-house hosted repositories and all common online services, such as GitHub, GitLab and Bitbucket.

In addition, information from a bug/issue tracker (such as Jira or AzureDevOps) and its connections to the code repository are evaluated. The use of these tools has proven to be best practice in software engineering and is now widespread. If such tools are used, a quick configuration of DETANGLE® and immediate execution of the analysis are possible.

If these best practices are deviated from, a pre-analysis is required to make the project data analysable. This effort is necessary to clean up the unstructured development data and convert it into a format that can be analysed. A valuable additional finding of such a pre-analysis are concrete suggestions for technical process improvement in order to modernise the development methodology through a best-practice use of a code repository and a bug/issue tracker.

The following parameters influence the duration of the analysis:

  • code size (number of lines of code)
  • the history of the code (=number and extent of changes or age of the code in years)
  • number of developers
  • number of repositories
  • level of detail of the root cause analysis
  • scope of the final report and management presentation.

An analysis of technical debt thus takes between 5 and 20 days, depending on the initial situation.

What Distinguishes a DETANGLE® Analysis from Other Code Analyses?

Current methods of code quality analysis often have the following limitations:

  • The focus of the quality analysis is solely on code, i.e. neither the architectural nor the functional perspective is covered.
  • There are too many irrelevant findings (false positives). For example, areas of the code that have not been changed over a long period of time do not necessarily need to be improved.
  • Prioritization of the findings with an effort vs. impact matrix is not possible in an automated way.

In contrast, the DETANGLE® analysis

  • provides its insights based on the analysis of product features (their development effort, error density and quality in the code) instead of pure code analysis or subjective estimates by developers, managers and customers. For example, features with low usage but high maintenance needs can also be quickly identified and pushed to the back of the prioritization.
  • looks at the history of the code in the code repository and correlates this with bugs and features, in order to then use feature-centred KPIs to arrive at statements about the technical debt and its causes, right through to forecasting the refactoring effort.

Resolving Technical Debt With the Help of DETANGLE®

The Cape of Good Code analysis creates transparency about whether and where problematic technical debt exists in the code and how it can be remedied. In detail, Cape of Good Code provides the following services:

  • Evaluate the extent to which technical debt is already impacting the current maintenance effort (and stability) of the software.
  • Evaluate and identify the technical debt that needs to be reduced in order to ensure the development of new functionalities within the normal cost framework.
  • Quantify the investment required to reduce the really problematic technical debt.
  • Identify the code areas that have the most problematic technical debt.
  • Show trends in development effort for innovation versus overhead to identify the risk of launch delays early.
  • Use a common KPI-based terminology and discussion basis for all project participants, so that discussions can be held internally on an equal footing with the same data and decisions can be made in a comprehensible manner.
  • Achieve better reasoning in project, budget and resource planning to account for the unavoidable effort required to reduce technical debt.

Ask for Our Offer

Are you interested in a Technical Debt analysis with DETANGLE®? For an offer for you and your software product, we need the following information:

  • type and number of issue/bug tracking systems used
  • type and number of repository systems used
  • code size (number of lines of code)
  • age of the code in years
  • number of active developers

Contact us to clarify any questions or to discuss further details.