How to measure code quality? Top code quality metrics

What is code quality?

Engineering organizations have to balance the speed and quality of the services, features and updates that they deliver to customers. The foundation of the quality is the code; the code has to meet expectations of the customer - any defects, errors or issues with user experience can have a damaging effect on the reputation of the engineering organization. 

The quality of code is integral to everything you do in your software development lifecycle. It impacts how easy it is to make changes, the functionality and readability of code, the user experience, the product’s success and the long-term management of the code including costs for labor and maintenance, as well as time to market. 

Good quality code provides a better user experience; it’s easy to understand and update, it promotes reuse (and collaboration), improves software performance, reduces bugs and errors, provides a good foundation to build upon new capabilities and features, and will ultimately provide confidence to your customers. 

Bad quality code can be a drain on resources; taking more time for developers to fix and work on due to complexity, and limiting the ability to reuse or build upon the code. It can be error prone, expensive to maintain, and has a domino effect in providing a bad user experience for developers, system architects, DevOps, SREs and customers.  

Ultimately, the quality of code has an impact on the success of an organization.

The importance of code quality metrics

Code quality is an important priority, and so measuring and monitoring the quality of code is essential. As development teams have to deal with changes to existing on a frequent basis, they have to ensure that any additions, deletions, updates or reuse of code adhere to high quality standards and watch out for any degradation. The best way to do this is to track code quality metrics, as they empower teams with data that shows that the code is readable, maintainable, reliable and performing as it should. Code quality metrics provide an unbiased assessment of a codebase using real, measurable indicators of software quality.

Metrics enable teams to analyze the code’s health so that the development team knows where they need to make improvements. They can also provide benchmarks so that their performance can be measured against the high standards. This also sets a standard-bearer so that everyone in the engineering team knows exactly what code quality looks like - helping to improve the engineering excellence within the organization. 

8 Key code quality metrics

Code quality metrics help to inform you on whether the value of the codebase is good or bad. This assessment is made in relation to the standards and expectations set by the engineering team. Here are the top code quality metrics to track: 

1. Cyclomatic complexity

Cyclomatic complexity quantifies the complexity of a program by counting its decision points, thereby determining the number of linearly independent paths through the code. Lower cyclomatic complexity indicates simpler, more manageable code, which reduces the likelihood of errors and enhances maintainability. Essentially, it helps assess the code’s readability and the risk associated with changes. This is the key measure for code complexity, but there are others such as Halstead complexity, which evaluates program vocabulary, length, and cognitive load.

2. Average code review time

Average code review time is exactly what it sounds like - longer review times can impact the velocity of the team, morale about the process and can be detrimental for code health. Reviews that are too fast might lack thoroughness. By monitoring and benchmarking this metric, teams can make changes to their review process. This particular metric is indirectly about the code quality itself - and can actually be used as a developer productivity metric. 

3. Code churn 

Code churn measures how much code is changing within a specific time frame, for example if code is rewritten or deleted just after being written. It can identify patterns such as excessive changes that indicate volatility and uncertainty. If not dealt with, this can hinder and slow down the development process. By monitoring code churn, engineering teams can track the efficiency of the team’s workflow and the quality of contributions of developers.

4. Code coverage

Code coverage, otherwise known as test coverage, is typically quantified as the proportion of your code that has been tested automatically. It serves as a crucial marker of your software's robustness and reliability; a higher coverage suggests a greater likelihood of maintaining bug-free code. Code coverage motivates developers to write comprehensive tests and to use better design practices so that the code will pass these tests. Areas that have lower test coverage may be riskier to change.

5. Code duplication 

Code duplication is when the same code is used in more than one location within a software system. It can lead to several issues including maintenance overhead as each duplicate has to be updated individually when changes are required, and can also lead to inconsistencies and increased bug surface.

6. Code maintainability index 

The code maintainability index uses a scale of 0-100 to quantify how easy it is to maintain the code. It uses a number of other code metrics such as number of lines of code, the documentation, standardization in the coding, cyclomatic complexity and Halstead complexity to provide a score. Engineering teams can benefit from this metric as it can provide a good overview of the state of the codebase - including whether it has many defects and technical debt - which makes it easier for developers that are onboarding, as well as for existing developers that are joining a new project. The index can also reduce the costs of maintenance of the software.

7. Technical debt

Just as financial debt involves having to pay back interest over time, which can compound existing difficulties, technical debt can have a knock-on effect and cause damage in a number of ways if it isn’t resolved promptly. The metric is to compare and contrast the cost of choosing a quick fix for the short-term, rather than using a better approach that would have more of a long-term impact. The higher the technical debt, the more work that is required to improve the codebase - which in turn means less time that the team is able to add new features and functionality, which ultimately stifles innovation. 

8. Dependency graph complexity 

This maps the connections and relationships between components, modules or functions within software. The higher number of dependencies and connections can mean more complexity, which can make changes to code harder to facilitate. 

Improve code quality with an internal developer portal 

An internal developer portal can bring together all of the metrics from your code quality tools into one centralized place. The main benefit of the portal is being able to provide additional context to those metrics through a single source of truth. With a portal, you can:

• Unify code quality metrics with other quality metrics
  Utilize scorecards to integrate code quality metrics with other quality-related metrics, providing you with a comprehensive quality scorecard that ensures standards are maintained across all aspects.

• Ensure your services are leveraging quality tools
  You can create an initiative to ensure that all services are linked to a Sonar project, for instance.
  
  
• Get context with other metrics
  Find out if code quality is impacting your platform stability, engineering processes and team productivity by tracking DORA metrics, SPACE metrics and developer experience metrics in your portal. The portal brings together these software engineering intelligence metrics and standards-based metrics such as those for production readiness, incident management and AppSec, in one place.