Measuring Code Quality: Qualitative and Quantitative
Tags: codequality, codereview, programming, staticcodeanalysis
Published: 2021-06-07 13:34:35

Code Quality defines that the code is good, which means code is of high quality, and code is bad, which means code is of low quality. The quality can be subjective, so different teams may use different definitions based on the context. Code can be considered good quality if it is clear, simple, well tested, bug-free, refactored, documented, and performant. Keeping good code quality is also crucial for developing safety-critical systems.

![https://64.media.tumblr.com/67b2df9cdb3674a35592ac2d9993b417/tumblr_pqs72clJNM1xwpovyo1_1280.jpg](https://64.media.tumblr.com/67b2df9cdb3674a35592ac2d9993b417/tumblr_pqs72clJNM1xwpovyo1_1280.jpg)

But how can I measure that the code I have written is of good quality? To measure Code Quality, there are two types of metrics: Qualitative and Quantitative. Let's discuss both kinds of metrics in detail below.

### Qualitative Code Quality Metrics

**Extensibility**

Extensibility is one of the facets of Software Development. You can improve the extensibility of your code over time by practicing concepts like separation of concerns and loose coupling. One can add new features to the code or modify the existing functionality without affecting the entire system. 

Implementing design principles like [SOLID](https://en.wikipedia.org/wiki/SOLID) can help in making your code more extensible.

**Maintainability**

Maintainable code is a code that is easy to modify or extend. Maintainability is a characteristic of well-written code that is easy to read, code that can be examined easily to find a particular component relating to a given change request, code that is easy to alter without the risk of breaking dependant modules.

Many principles, approaches, and techniques can help you develop maintainable software, and most of them are relevant to writing good software:

- Ensure that the software is well-designed. Qualities of a good design in the context of maintenance are: as simple as possible, easy to understand, easy to make changes, easy to test, and easy to operate (i.e., easy to deploy and monitor for problems)
- Refactor code
- Write better documentation to help developers understand the code
- Automated build to make the code easy to compile
- Use automated testing to make it easy to validate changes

**Readability and Code Formatting**
Using proper indentation and formatting in the code makes the code more readable, according to the standard particular to that programming language in which you've written the code. Doing this makes the code structure more visible and consistent.

Some of the tips that can improve the readability of your code are:

- Documentation and commenting the code
- Use consistent indentation style throughout the code
- Use consistent naming schemes like camelCase, PascalCase, snake_case, etc.
- Reducing the level of nesting improves code readability

**Clarity**
If you look at the code and cannot understand what that code does, then that code is ambiguous, and this is an example of poor clarity. The code should be unambiguous and clear enough to be understood by other developers without spending much time.

Follow the tips below to improve the clarity of the code:

- Use straightforward logic and flow-of-control
- Use blank lines to separate your code into logical sections

**Testability**
Well-tested code is likely to be of higher quality because testing pays more attention to the code's inner workings. You can measure the testability based on the number of test cases you require to find potential faults in the system.

Some of the principles you can follow to increase code testability are:

- Adhere to the SOLID principles
- Write the [unit tests](https://deepsource.io/glossary/unit-testing/) first
- Use Inversion of Control / Dependency Injection
- Extract all non-testable code into wrapper-classes

**Most of the metrics can be measured by running a [static code analysis tool](http://deepsource.io).**

### Quantitative Code Quality Metrics

**Halstead Complexity Measures**
You can understand code quality by measuring the Halstead complexity, including program vocabulary, program length, Calculated program length, Volume, Difficulty, and Effort. This is estimated to assess the computational complexity of the code. The complex the code, the harder it is to maintain, and the lower is its quality. 

Go through this [wiki](https://en.wikipedia.org/wiki/Halstead_complexity_measures) to learn more on how to measure Halstead Complexity.

**Cyclomatic Complexity**
Complexity metrics can help in measuring quality. Cyclomatic complexity measures the number of linearly independent paths through a program's source code.

Read [this](https://en.wikipedia.org/wiki/Cyclomatic_complexity) to know how to calculate Cyclomatic Complexity.

**Weighted Micro Function Points**
Weighted Micro Function Points (WMFP) is a modern software sizing algorithm that is a successor to solid ancestor scientific methods. It produces more accurate results compared to traditional software sizing methodologies. It requires less configuration as most of the estimation is based on automatic measurements of an existing source code.

Read [this](https://en.wikipedia.org/wiki/Weighted_Micro_Function_Points) to know how to calculate Weighted Micro Function Points.