Technical Debt

With DETANGLE, Cape of Good Code provides analysis results quickly and clearly and thus supports in focusing on the most important quality risks based on facts in order to set the necessary development priorities.

Thorsten Braun, Head of TrainIT Technology and Architecture, Siemens Mobility

 

 

Digital business models also change the challenges for software development. In addition to stabilising and optimising the software, innovations must be worked on continuously and intensively. Therefore, the development of new functionalities, the features, has a very high priority. In the course of the life cycle, however, so-called Technical Debt also arises that stands in the way of this. Technical Debt is understood to be

both the intentional and unintentional violations of good architectural and coding practices. These cause increasing (unplanned) effort and costs for the maintenance and extension of the software.

Without suitable countermeasures, the effort for maintenance increases with each new feature to the point where the further development of software is no longer worthwhile or no longer possible

Measuring, Limiting and Prioritising the Reduction of Technical Debt

Software products are “never-ending stories”. They grow with the user base and their ever-new expectations of further innovations. In some cases, new use cases are opened up, which in turn require further adaptations and additionally increase the complexity of the software base. The big challenge is therefore to keep the maintenance and development costs in the life cycle of a software within an economically sensible balance.

With DETANGLE®, Cape of Good Code has developed a software suite to locate and measure technical debt. The technical stakeholders of software engineering projects are supported with these analyzes in limiting the maintenance effort in the software lifecycle. The developers retain enough free capacity to develop new features and extensions, which means that the software remains competitive and profitable in the long term.

Who Should Know Their Technical Debt?

Cape of Good Code looks at the impact of technical debt in software development in a similar way to the impact of financial debt. It asks similar questions in its analysis a debt counselor would ask:

  1. What is the amount of the technical debt?
  2. What is the amount of interest and compound interest to be paid as increasing additional expenses on top of the normal maintenance and further development of the software?
  3. How can an amortisation rate be achieved where there are no exploding “interest costs” due to compound interest that would absorb the capacity for innovation and further development?

Based on the results of the Cape of Good Code analysis using the DETANGLE® Analysis Suite and specific interviews, the following concrete findings emerge for stakeholders in software development:

Stakeholder Insights 
Project manager,
Product owner
  • Overview of whether the “interest costs” of the technical debt exceed critical thresholds, e.g. through the measurement and observation of increased additional expenses or the detection of recurring postponements of agreed launch dates.
  • Automated prediction of the effort required to prioritise the reduction of technical debt and addressing its causes.
  • Factual basis to identify debt hotspots. The prioritised processing (effort vs. effect) of these hotspots derived from the analysis enables an optimal use of the always scarce development resources.
  • Well-founded allocation of the budget for the development of new features versus repayment of technical debt becomes possible.
Technical Manager
  • The evaluation of a large number of potential technical causes for code areas with high technical debt facilitates the prioritisation when initiating countermeasures. Issues to be addressed are:
    • Extensibility of the code architecture,
    • Maintainability of the code based on its quality,
    • Extent of documentation gaps,
    • Extent of test code or test coverage,
    • Team efficiency of the development team,
    • Quality of the technical processes
Founder,

Head of Development,CTO,

COO

  • Key performance indicators across the product landscape on the impact of technical debt in each software product.
  • Data and fact-based decision making to prioritise innovation versus technical debt across the product landscape.

 


Contact us for more information on our Analysis with DETANGLE®


Why Should You Know Your Technical Debt?

The dynamic development of requirements for new features leads to fuzziness in the product backlog or in the specifications (depending on the development methodology). This fuzziness is amplified by the increasing volatility of the software and development technologies used.

Thus, a software project undergoes many changes of direction in the course of its development. In principle, the software architecture and the code never reach a final state. As a result, the many small inadequacies and errors, best practice violations, workarounds and quick fixes accumulate into ever-increasing technical debt. This in turn makes the maintenance and integration of new features more and more costly and sooner rather than later no longer useful.

To break this negative trend, the Cape of Good Code team takes an analytical and data-based approach. In addition to applying a DETANGLE® scan, specific interviews can be conducted with all stakeholders in addition. From the data and responses, a roadmap for improving the code and the architecture is proposed, taking into account budget and capacity constraints. Below are some examples of the questions that should be answered:

  1. What is the composition of my technical debt? Does it predominantly arise from problems in the architecture, from poor code quality, from lack of documentation and inadequate testing, or a mixture of all?
  2. What is the distribution of technical debt across the code base? Where are the hotspots of technical debt?
  3. How can I estimate the remediation effort?
  4. How can I detect and locate rising debt early?
  5. How should technical debt be measured to decide on the countermeasures with the best cost/benefit ratio for quality and customer/user satisfaction?

Managers and employees in software development thus receive fact-based insights regarding solvable problems that could endanger the future of their software if no countermeasures are taken.

With the results of the Cape of Good Code analysis, you can control the priorities in software development with important new performance indicators. This means that it is up to you to decide which technical debt should be resolved, when and with what effort, instead of just leaving it to gut feeling. It also makes communication easier to explain changing budget and capacity requirements in the project.

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

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?

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.

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.

Does Cape of Good Code also Help to Reduce and Control Technical Debt?

After the analysis, Cape of Good Code also takes responsibility to assist in implementing the recommendations of its analysis. Alternatively, Cape of Good Code can take on a project management or coaching role for the team in charge of the implementation.

In detail, Cape of Good Code offers the following services in supporting the implementation of the elaborated measures after the analysis of the technical debt:

  1. Coordination of the implementation of the recommendations on the part of the client and the partners.
  2. Recording of refactoring measures as issues, including their description and justification.
  3. Training of the development teams on best practices in dealing with issue trackers and code repositories.
  4. Training of development teams on best practices for code design and testability.
  5. Conceptual consulting if a major redesign or transformation of the code architecture is necessary.

It is also advisable to use these analyses regularly, i.e. at least once per release, to verify the impact of the measures, identify new trends and implement the newly made recommendations.

In this way, it will also be possible in the future to keep the always inherent technical debt in check in the long term.

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.