Sema Blog

Using Continuous Software Maintenance to Eliminate Technical Debt

Posted by Sanjay Khunger on Oct 22, 2018 5:02:00 AM
Find me on:

Recently, Jason, one of Sema's founders, posted a thought-provoking article on technical debt. As he points out, technical debt is analogous to financial debt and software accrues technical debt when teams decide to defer all those “little” non-functional things.

Technical debt is the invisible part of software that has negative value. In contrast, a defect or bug is the visible part with negative value, while software design and architecture are the invisible parts that provide positive value.

It’s no surprise that technical debt hides under the visibility line, manifesting as a visible defect or vulnerability only at some inopportune moment. A common example is when technical debt piles up to the point that it starts impacting software performance, thus becoming a visible defect.

sqf_visiblevalue_wbkg-01

 

Whether deliberate or inadvertent, technical debt, in my mind, includes both reckless debt due to ignorance of good design practices as well as prudent debt due to a considered decision that yields a short-term benefit but is not sustainable in the long-term.  And, since technical debt is incurred because of poor design and architecture choice or practice, it is always addressed with a design or architecture change to the software.

So how do we stop accruing technical debt?

At Sema, we call it Continuous Software Maintenance (CSM). With CSM, software is continuously improved. Problems are addressed as they occur, rather than being put on a backlog waiting to be grouped into a maintenance project at some mythical future date. Sounds simple enough, right? Yet most engineering teams lack the time, processes or tools to implement this on their own.

At Sema our goal is to arm software teams, from senior management to architects to developers, with the tools they need to find, fix, and prevent technical debt. That means continuously monitoring and managing the health and quality of the software; identifying hot-spots and software issues; and providing recommendations to address them. And with our tools, we addressed many of the challenges of CSM to enable engineering teams to streamline and accelerate their tech-debt-busting journey.

Finding and Surfacing Technical Debt

Finding and surfacing technical debt starts with defining a set of reliable and easily understood metrics that can be used to assess the health of the software and doing comparative analysis against other software projects or a benchmark. Although there is an abundance of software quality metrics, there is little standardization and even lower adoption of quality metrics by software teams.

The diagram below depicts the framework Sema has developed to structure our software metrics. Metrics are grouped into three sections: code (the “what”), developer & team view (the “who”) and process (the “how”). This approach provides a comprehensive set of software metrics. Depending on their challenges and goals, engineering teams can focus on the metrics that are of most interest to them.

 

sqf_visiblevalue_wbkg-03

The next step is to deterministically and repeatably calculate metrics for all types of software. Sema currently focuses on strongly typed languages, like Java and C#, and some of the most widely-used weakly typed languages, like JavaScript.

Once the metrics are calculated, a manageable set of analytics can be used to identify hotspots or issues in software. To make this information easier to understand, we also render this multi-dimensional problem into easily understandable visualizations.

Fixing Technical Debt

Next in line is the challenge to determine the best way to address the issues that have been identified. This multi-dimensional problem has no known efficient way to find a deterministic solution. The time required to solve this problem increases very quickly as the size of the problem grows, and, therefore does not have a deterministic solution but instead has a set of possible solutions. We apply heuristics, genetic programming and machine learning to generate the optimal solution set instead, to empower the engineering teams to select and apply the optimal solution.

Preventing Technical Debt

The task of preventing technical debt is the key motivation behind continuous software maintenance. Through CSM, software can be methodically and continuously monitored for design and architecture issues, as well as identifying the optimal options to address these issues, which are continuously identified for selection and application by the engineering teams.

It is worth reiterating that continuous software maintenance does not replace continuous testing and integration, rather it extends those processes to make the entire software development and maintenance value chain lean and agile. Furthermore, it does not replace production monitoring and maintenance tools but strengthens them to provide visibility into the code-level design defects in applications.

Contact us at info@semalab.com to learn more about the Sema Software Quality Framework.

Topics: software maintenance, tech debt, technical debt