[SURVEY RESULTS] The 2024 edition of State of Software Modernization market report is published!
GET IT here

Streamlining the Code: Pros and Cons of Cyclomatic Complexity

Last updated on
November 29, 2023



Streamlining the Code: Pros and Cons of Cyclomatic Complexity


High cyclomatic complexity can be a sign of a technical debt that can slow down your development process and lead to bugs and outages. In this article, we'll show you how to measure, analyze, and reduce cyclomatic complexity effectively.

What is cyclomatic complexity?

Cyclomatic complexity definition

Cyclomatic complexity is a software quality metric that measures the complexity of a program. It helps us understand how hard the code is to test and maintain.

To calculate it, we count the number of independent paths through the code. Every decision point in the code increases the cyclomatic complexity by one. High cyclomatic complexity may mean that the code has complex logic or isn't modular enough.

By keeping cyclomatic complexity in check, you can improve the maintainability and reliability of your software. However, it can also pose some risks, like ignoring user experience, over-engineering, and having a false sense of security - more on that later.

Benefits of measuring and reducing cyclomatic complexity

Benefits of reducing cyclomatic complexity

<span class="colorbox1" fs-test-element="box1"><p>Note: Sole measuring, without taking action, won’t give you any of those benefits.</p></span>

Improved code quality

Measuring cyclomatic complexity helps you to identify overly complex logic or insufficient modularity in your code. By addressing these issues, you can improve the overall quality of our code.

Better maintainability

Lower cyclomatic complexity makes it easier to read and understand the code, which in turn makes it easier to maintain and update. By measuring cyclomatic complexity regularly, you can ensure that your code remains easy to maintain and update.

Reduced defects

High cyclomatic complexity can lead to more defects in the code. By measuring it regularly, you can identify potential issues early and prevent them from becoming defects.

Enhanced testing

Measuring cyclomatic complexity helps you identify the number of independent paths through the code. This, in turn, helps us write more effective tests that cover all possible paths through the code.

Improved productivity

By measuring cyclomatic complexity, we can identify areas of our code that need improvement. This can help us focus our efforts and increase our productivity.

High cyclomatic complexity - consequences

Code is hard to understand

Code with high cyclomatic complexity is more complex and harder to understand, which can make it more difficult to identify and fix defects. Developers may not fully understand all the possible paths through the code, or they may miss certain conditions or edge cases that could lead to defects.

Code is difficult to test

Code with high cyclomatic complexity can also be more difficult to test, as there are more paths that need to be tested and more conditions that need to be covered. This can result in gaps in test coverage, where certain conditions or paths are not tested, which can increase the risk of defects.

There may be other hidden issues

High cyclomatic complexity can be an indicator of other issues, such as excessive nesting or overly complex conditional logic, which can also contribute to a higher risk of defects. Code with these issues can be more error-prone and harder to understand, which can lead to defects and bugs.

<span class="colorbox1" fs-test-element="box1"><p>Read also: Prioritizing technical debt can be hard. See how a development team coped with tech debt by identifying areas for improvement that support business, not just clean the code.</p></span>

How to calculate cyclomatic complexity?

There are tools that can calculate cyclomatic complexity for you, e.g. SonarQube or IDE plugins for code metrics.

Want to calculate it by yourself either way?

To calculate cyclomatic complexity, you need to identify the different paths that can be taken through a block of code.

You can do this by constructing a Control Flow Graph, which represents the different paths that can be taken through the code. Then, you count the number of regions in the graph to determine the cyclomatic complexity.

A region is defined as an area bounded by decision points, where a decision point is a statement that can lead to multiple paths. For example, an "if" statement or a "switch" statement can be a decision point.

Let's look at an example. Consider the following code:

if (a > b) {


} else {



We can construct a Control Flow Graph as follows:


   | a>b |





| doSomething|





| doSomethingElse|


The graph has two regions, one for each branch of the "if" statement. Therefore, the cyclomatic complexity of this code is 2.

How to reduce cyclomatic complexity?

Tips on how to reduce cyclomatic complexity

Refactor long methods

Long methods with multiple nested loops and conditional statements are more difficult to read and understand. Break up long methods into smaller, more focused methods that are easier to comprehend and maintain.

Refactor the code

Refactor the code to simplify it and reduce the number of decision points. For example, you can extract complex logic into separate methods or functions, which can reduce the number of decision points and make the code easier to read and understand.

<span class="colorbox1" fs-test-element="box1"><p>Read also: 10 most common technical debt examples, each one with explanation, spotting tips, and the guidance on how to avoid & how to solve this problem if it already exists.</p></span>

Use conditional statements rather than nested loops 

Instead of nesting loops, use conditional statements to control the flow of the program. For example, you can use an if statement to break out of a loop when a condition is met instead of using a nested loop.

Reduce the number of parameters

If a method or function has too many parameters, it can increase the cyclomatic complexity. Reduce the number of parameters by grouping related variables into objects or structs.

Eliminate dead code

Dead code, such as unused variables or unreachable statements, can increase the cyclomatic complexity. You can eliminate dead code to simplify the it and reduce the cyclomatic complexity.

Write simpler code

Write simpler code by avoiding unnecessary complexity and keeping it as simple as possible. For example, use descriptive variable names and avoid complex expressions.

Risks connected to measuring cyclomatic complexity

Limitations of cyclomatic complexity

Neglecting code quality

Focusing solely on cyclomatic complexity can lead to neglecting other important factors related to code quality, such as consistency, clarity, and readability. As a result, the code may become difficult to maintain and update, even if its cyclomatic complexity is low.


A high cyclomatic complexity may not necessarily mean that there is a problem with the code. Focusing solely on cyclomatic complexity, you may end up over-engineering the code to reduce the complexity, which can result in wasted time and effort.

Ignoring user experience

Cyclomatic complexity doesn't measure the user experience of the software. If you focus solely on reducing cyclomatic complexity, you may overlook usability issues that can negatively impact the user experience.

False sense of security

A low cyclomatic complexity doesn't necessarily mean that the code is easy to maintain and update. If you base your decisions solely on cyclomatic complexity results, you may have a false sense of security and overlook potential issues that can arise during maintenance and updates.

Limited applicability

Cyclomatic complexity may not be applicable to certain types of code, such as machine learning algorithms or embedded systems. Beware of overlooking other metrics and factors that are more relevant to these types of systems.


Measuring cyclomatic complexity requires knowledge of software engineering and metrics. If not properly understood, the results can be misinterpreted, leading to incorrect conclusions.

False positives

High cyclomatic complexity can indicate potential issues with code quality, but it doesn't necessarily mean that there is a problem. It's important to consider other factors, such as the context in which the code is used, before taking any action.

Cyclomatic complexity alternatives

Alternatives to cyclomatic complexity

There are several alternatives to cyclomatic complexity that can be used to evaluate code complexity and identify potential issues:

Halstead Metrics

This metric is based on the number of unique operators and operands in a piece of code and can be used to estimate the difficulty of understanding and maintaining the code. Halstead Metrics can provide a more comprehensive view of code complexity than cyclomatic complexity, as it takes into account both the control flow and the vocabulary of the code.

Maintainability Index

Maintainability Index takes into account various factors such as cyclomatic complexity, code duplication, and code size, to provide an overall measure of code maintainability. It can be a useful alternative to cyclomatic complexity when looking for a more holistic measure of code complexity and maintainability.

Lines of Code

This metric simply measures the number of lines of code in a piece of software. While not as sophisticated as other metrics, it can be a useful indicator of code complexity and maintainability. In general, the more lines of code there are, the more complex and difficult to maintain the code is likely to be.

Which one to choose

  • Choose Halstead Metrics when looking for a more comprehensive view of code complexity, especially when dealing with code that has a lot of repetitive or similar code.
  • Choose Maintainability Index when looking for a more holistic measure of code complexity and maintainability. It can be especially useful when dealing with large codebases or when trying to identify areas of the code that may require refactoring.
  • Choose Lines of Code when dealing with relatively simple code or when looking for a quick and simple way to estimate code complexity. It can also be useful when comparing the complexity of different codebases or projects.

In general, a combination of metrics is likely to provide the most accurate and comprehensive view of code complexity and maintainability.


By understanding the relationship between cyclomatic complexity and software quality, teams can make more informed decisions about their codebase and improve the maintainability and scalability of their applications.

The key to success is to choose the right set of metrics tailored to your product goals. Find your perfect set by exploring other software quality metrics in this handbook.

Frequently Asked Questions

No items found.

Our promise

Every year, Brainhub helps 750,000+ founders, leaders and software engineers make smart tech decisions. We earn that trust by openly sharing our insights based on practical software engineering experience.


Tomasz Grażyński
Head of Quality Assurance

Software Quality Assurance Engineer with 15 years of professional experience. Responsible for the whole QA line at Brainhub.

Olga Gierszal
IT Outsourcing Market Analyst & Software Engineering Editor

Software development enthusiast with 6 years of professional experience in the tech industry. Experienced in outsourcing and nearshoring market analysis. Our expert in presenting tech, business, and digital topics in an accessible way.

Read next

No items found...

Get smarter in engineering and leadership in less than 60 seconds.

Join 300+ founders and engineering leaders, and get a weekly newsletter that takes our CEO 5-6 hours to prepare.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.