Advanced
Code Quality
#cyclomatic-complexity
#code-review
#refactoring
Cyclomatic Complexity Vocabulary
5 exercises — master the language engineers use in code reviews to discuss complexity scores, thresholds, and refactoring strategies.
0 / 25 completed
1 / 25
A tech lead comments on a pull request: "This function has a complexity score of 15 — it exceeds our threshold of 10. Please refactor before we merge." What does this comment communicate, and what is the engineer expected to do?
"Complexity score" in code review context nearly always refers to cyclomatic complexity — the number of linearly independent paths through a unit of code.
Why "exceeds threshold" is the critical phrase:
Most teams set a quality gate — a hard limit that blocks merging — when complexity exceeds 10 (the widely cited McCabe recommendation). "Exceeds threshold" signals that the build quality gate has failed or will fail.
Common refactoring patterns to reduce complexity:
• Extract method — move a nested conditional block into a well-named private function; reduces decision points in the original
• Replace nested conditional with guard clauses — early returns flatten nesting and remove else branches
• Replace conditional with polymorphism — eliminate switch/if-else chains via strategy or command pattern
• Decompose conditional — extract complex boolean expressions into named predicate functions
How to talk about this in a code review:
• "The cyclomatic complexity exceeds our agreed threshold of 10 — this needs to be reduced before merge."
• "I'd suggest extracting the inner loop logic into a separate method to bring the complexity score down."
• "Can you add a refactoring task to the PR to address the complexity? It's blocking the quality gate."
Key vocabulary:
• Complexity score — informal term for cyclomatic complexity measurement
• Exceeds threshold — the measured value is above the agreed-upon maximum; action required
• Quality gate — an automated check that blocks merge/deploy when a metric exceeds a threshold
• Refactoring — restructuring code without changing external behaviour, with the goal of improving a quality metric
Why "exceeds threshold" is the critical phrase:
Most teams set a quality gate — a hard limit that blocks merging — when complexity exceeds 10 (the widely cited McCabe recommendation). "Exceeds threshold" signals that the build quality gate has failed or will fail.
Common refactoring patterns to reduce complexity:
• Extract method — move a nested conditional block into a well-named private function; reduces decision points in the original
• Replace nested conditional with guard clauses — early returns flatten nesting and remove else branches
• Replace conditional with polymorphism — eliminate switch/if-else chains via strategy or command pattern
• Decompose conditional — extract complex boolean expressions into named predicate functions
How to talk about this in a code review:
• "The cyclomatic complexity exceeds our agreed threshold of 10 — this needs to be reduced before merge."
• "I'd suggest extracting the inner loop logic into a separate method to bring the complexity score down."
• "Can you add a refactoring task to the PR to address the complexity? It's blocking the quality gate."
Key vocabulary:
• Complexity score — informal term for cyclomatic complexity measurement
• Exceeds threshold — the measured value is above the agreed-upon maximum; action required
• Quality gate — an automated check that blocks merge/deploy when a metric exceeds a threshold
• Refactoring — restructuring code without changing external behaviour, with the goal of improving a quality metric
2 / 25
In a code review, a senior engineer writes: "I'd like to see this refactored to reduce complexity. Consider using guard clauses to flatten the nesting." What is a guard clause, and how does it reduce cyclomatic complexity?
Guard clauses are one of the most effective and widely recommended techniques for reducing cyclomatic complexity while simultaneously improving readability.
Before guard clauses (complexity = 4):
Code review language for this pattern:
• "Replace the nested if-else with guard clauses to reduce nesting depth."
• "Early returns at the top of the function will make the happy path obvious."
• "This reads like an arrow anti-pattern — guard clauses will flatten this considerably."
Key vocabulary:
• Guard clause — an early-return statement handling a precondition, edge case, or error at the top of a function
• Flatten nesting — restructure code to reduce the depth of nested blocks
• Happy path — the main execution flow when all conditions are met and no errors occur
• Arrow anti-pattern — deeply nested if statements forming an arrow shape; a code smell
Before guard clauses (complexity = 4):
function process(order) {
if (order !== null) {
if (order.isValid()) {
if (order.hasItems()) {
return ship(order); // happy path buried 3 levels deep
}
}
}
return null;
}
After guard clauses (complexity = 4, but readability hugely improved):function process(order) {
if (order === null) return null; // guard
if (!order.isValid()) return null; // guard
if (!order.hasItems()) return null; // guard
return ship(order); // happy path at top level
}
Impact on complexity: Guard clauses alone don't always reduce cyclomatic complexity (same decision count), but combined with extracting logic into helper functions, they enable further simplification. The flatten-nesting effect often reduces cognitive complexity significantly.Code review language for this pattern:
• "Replace the nested if-else with guard clauses to reduce nesting depth."
• "Early returns at the top of the function will make the happy path obvious."
• "This reads like an arrow anti-pattern — guard clauses will flatten this considerably."
Key vocabulary:
• Guard clause — an early-return statement handling a precondition, edge case, or error at the top of a function
• Flatten nesting — restructure code to reduce the depth of nested blocks
• Happy path — the main execution flow when all conditions are met and no errors occur
• Arrow anti-pattern — deeply nested if statements forming an arrow shape; a code smell
3 / 25
During a sprint retrospective, the engineering manager says: "Our SonarQube report shows the average cyclomatic complexity across the codebase has risen from 8 to 14 over the last quarter. This is a maintainability concern we need to address." What is the manager communicating, and what is the appropriate team response?
When average complexity rises significantly over a period, it signals that technical debt is accumulating — often because delivery pressure is incentivising shortcuts over code quality.
How to interpret trending complexity data:
• A single snapshot (complexity = 14) has limited meaning without context
• A trend (8 → 14 over one quarter = +75%) is a clear signal that practices need to change
• At complexity 14, functions statistically require 14 test cases for full branch coverage — unrealistic in practice, meaning untested paths accumulate
Appropriate team responses in order of priority:
① Automate the gate: configure SonarQube/CI to block merges when complexity exceeds the threshold
② Identify hotspots: the 20% of files driving 80% of the complexity increase
③ Schedule refactoring stories: treat technical debt reduction as sprint work, not optional cleanup
④ Retrospective root cause: discuss whether estimation pressure is encouraging complexity shortcuts
Language for raising this in meetings:
• "Our complexity trend is heading in the wrong direction — we need to address the root cause, not just the symptoms."
• "Can we allocate 20% of next sprint to refactoring the top complexity hotspots?"
• "We should add a complexity quality gate to prevent further degradation while we clean up the existing debt."
Key vocabulary:
• Maintainability concern — a quality issue that makes code progressively harder to change safely over time
• Trending metric — a measurement tracked over time to identify directional change
• Technical debt accumulation — the gradual build-up of suboptimal code decisions requiring future remediation
• Quality gate — an automated threshold that blocks progression through the delivery pipeline
How to interpret trending complexity data:
• A single snapshot (complexity = 14) has limited meaning without context
• A trend (8 → 14 over one quarter = +75%) is a clear signal that practices need to change
• At complexity 14, functions statistically require 14 test cases for full branch coverage — unrealistic in practice, meaning untested paths accumulate
Appropriate team responses in order of priority:
① Automate the gate: configure SonarQube/CI to block merges when complexity exceeds the threshold
② Identify hotspots: the 20% of files driving 80% of the complexity increase
③ Schedule refactoring stories: treat technical debt reduction as sprint work, not optional cleanup
④ Retrospective root cause: discuss whether estimation pressure is encouraging complexity shortcuts
Language for raising this in meetings:
• "Our complexity trend is heading in the wrong direction — we need to address the root cause, not just the symptoms."
• "Can we allocate 20% of next sprint to refactoring the top complexity hotspots?"
• "We should add a complexity quality gate to prevent further degradation while we clean up the existing debt."
Key vocabulary:
• Maintainability concern — a quality issue that makes code progressively harder to change safely over time
• Trending metric — a measurement tracked over time to identify directional change
• Technical debt accumulation — the gradual build-up of suboptimal code decisions requiring future remediation
• Quality gate — an automated threshold that blocks progression through the delivery pipeline
4 / 25
A code reviewer leaves the comment: "This switch statement with 18 cases is the primary driver of complexity here. I'd recommend the strategy pattern to address this." What does "driver of complexity" mean, and why would the strategy pattern help?
"Driver of complexity" identifies the specific code construct most responsible for a high complexity score — in this case, an 18-case switch statement contributing 18 decision points.
Why switch statements drive cyclomatic complexity:
Each case in a switch adds one independent execution path:
• The dispatch function drops from complexity 18+ to complexity 1
• Each strategy class has complexity 1–3 (focused, testable)
• New cases are added by creating new classes, not modifying existing switch branches (Open/Closed Principle)
Code review language for complexity discussions:
• "This is the primary driver of complexity in the module — let's prioritise refactoring this specific construct."
• "The strategy pattern would move each case into its own testable class and reduce the complexity of this function to 1."
• "Extracting the handler map is a relatively low-risk refactoring that gives us maximum complexity reduction."
Key vocabulary:
• Driver of complexity — the specific code construct contributing the most to a high complexity score
• Strategy pattern — a design pattern that replaces conditional dispatch with a map of interchangeable handler objects
• Decision point — any branch in the control flow; each adds 1 to cyclomatic complexity
• Open/Closed Principle — code should be open for extension but closed for modification
Why switch statements drive cyclomatic complexity:
Each case in a switch adds one independent execution path:
switch(type) { // +1 for switch
case 'A': ...; break; // +1
case 'B': ...; break; // +1
// × 18 cases = cyclomatic complexity contribution of 18
}
Strategy pattern refactoring:const handlers = {
'A': new HandlerA(), // complexity = 1 each
'B': new HandlerB(),
};
handlers[type].execute(data); // switch is now a map lookup
Benefits of this refactoring for complexity:• The dispatch function drops from complexity 18+ to complexity 1
• Each strategy class has complexity 1–3 (focused, testable)
• New cases are added by creating new classes, not modifying existing switch branches (Open/Closed Principle)
Code review language for complexity discussions:
• "This is the primary driver of complexity in the module — let's prioritise refactoring this specific construct."
• "The strategy pattern would move each case into its own testable class and reduce the complexity of this function to 1."
• "Extracting the handler map is a relatively low-risk refactoring that gives us maximum complexity reduction."
Key vocabulary:
• Driver of complexity — the specific code construct contributing the most to a high complexity score
• Strategy pattern — a design pattern that replaces conditional dispatch with a map of interchangeable handler objects
• Decision point — any branch in the control flow; each adds 1 to cyclomatic complexity
• Open/Closed Principle — code should be open for extension but closed for modification
5 / 25
A junior developer receives this comment on their PR: "The PR reduces cyclomatic complexity from 22 to 7 in the payment module — excellent refactoring. The code is now well within the acceptable range and will be significantly easier to maintain and test." Which of the following best explains why a reduction from 22 to 7 is considered significant?
Moving a function from complexity 22 to 7 represents a qualitative shift between risk bands, not just a numerical improvement.
Practical impact of the reduction:
• Test coverage: minimum test cases to achieve full branch coverage reduced by 68% (22 → 7)
• Defect density: empirical research shows high-complexity functions have 3–5× higher defect density; crossing from band 21–50 to 1–10 removes the function from elevated-risk monitoring
• Code review speed: future PRs touching this function will be faster and safer to review
• Onboarding: new team members can understand and safely modify the function without extensive context
Language for acknowledging good refactoring:
• "Excellent refactoring — the complexity reduction will pay dividends in future test coverage."
• "Moving from 22 to 7 takes this out of the high-risk category entirely — well done."
• "This is exactly the kind of proactive technical debt reduction that makes future features safer to deliver."
Key vocabulary:
• Acceptable range — complexity values that meet the team's agreed quality standards (typically 1–10)
• Risk band — a named category of complexity scores associated with a level of defect and maintenance risk
• Well within the acceptable range — a score that comfortably meets the threshold, not just barely passing
| Score | Risk band | Min test cases | Recommended action |
|---|---|---|---|
| 22 (before) | High risk (21–50) | 22 | Refactoring required |
| 7 (after) | Low risk (1–10) | 7 | No action needed |
Practical impact of the reduction:
• Test coverage: minimum test cases to achieve full branch coverage reduced by 68% (22 → 7)
• Defect density: empirical research shows high-complexity functions have 3–5× higher defect density; crossing from band 21–50 to 1–10 removes the function from elevated-risk monitoring
• Code review speed: future PRs touching this function will be faster and safer to review
• Onboarding: new team members can understand and safely modify the function without extensive context
Language for acknowledging good refactoring:
• "Excellent refactoring — the complexity reduction will pay dividends in future test coverage."
• "Moving from 22 to 7 takes this out of the high-risk category entirely — well done."
• "This is exactly the kind of proactive technical debt reduction that makes future features safer to deliver."
Key vocabulary:
• Acceptable range — complexity values that meet the team's agreed quality standards (typically 1–10)
• Risk band — a named category of complexity scores associated with a level of defect and maintenance risk
• Well within the acceptable range — a score that comfortably meets the threshold, not just barely passing
6 / 25
David's comment focuses on the concept of 'unnecessary branches,' which in this context refers to multiple independent decision points within the code. High cyclomatic complexity arises when a function has more paths of execution than simply the input parameters. This translates directly into increased testing requirements – each branch needs to be thoroughly verified – and a greater risk that a bug could exist in one of those less-traveled paths. Option A is incorrect as lines of code aren't directly related to cyclomatic complexity, option C addresses formatting not complexity, and option D relates to variable usage rather than branching logic.
7 / 25
Alex is referring to cyclomatic complexity as a way to quantify the potential for errors and the need for thorough testing. A higher score indicates more possible execution paths, meaning there are more scenarios that *could* fail during tests. It's not simply about lines of code; it's about the branching logic within the handler function itself. Option A is too literal; options C and D misinterpret the core concept.
8 / 25
Daniel, a senior developer, sends this message in a Slack channel after reviewing a new feature: "I'm concerned about the cyclomatic complexity of this function. It's currently at 10, and that's pushing us towards our target of 6 for critical path functions. We need to ensure we're not creating overly complex logic here." What is Daniel primarily highlighting when he mentions a 'target of 6'? Consider the implications of exceeding this threshold.Daniel is focusing on the practical implications of cyclomatic complexity. A 'target of 6' isn't a technical specification but rather a guideline for code quality – specifically, it represents a threshold beyond which the risk of bugs and difficulties in testing and maintaining the code significantly increases. Higher complexity makes it harder to cover all possible execution paths with tests, leading to gaps in test coverage and potential errors.
The other options misinterpret the purpose of this target; it's not about efficiency or test requirements directly, but about maintainability and reducing the likelihood of defects.
The other options misinterpret the purpose of this target; it's not about efficiency or test requirements directly, but about maintainability and reducing the likelihood of defects.
9 / 25
During a standup update, a developer says: 'I've been working on the user profile service. The `update_address` function now has a cyclomatic complexity of 8. I'm worried about this, as our team guidelines recommend keeping complex functions below 5.' What does the developer *specifically* mean by referring to the 'guidelines recommending keeping complex functions below 5'? Consider the potential consequences if this guideline isn't followed.
The developer is referring to the impact of cyclomatic complexity on maintainability. A higher score indicates more decision points within the function, making it harder to test thoroughly and understand the logic. Exceeding a guideline like 5 increases the risk of bugs, makes refactoring difficult, and negatively impacts overall code quality – essentially, it's about reducing the cognitive load for future developers.
10 / 25
Team Lead: "Hey team, I've been reviewing the new order processing service. The `validate_order` function has a cyclomatic complexity of 18 – that's significantly higher than our acceptable range of 10 for core business logic. It suggests potential issues with error handling and control flow that could lead to bugs and difficulties in future maintenance. Can someone take a look at refactoring it?"This scenario highlights a realistic code review situation. The key takeaway is that cyclomatic complexity isn't just about numbers; it directly relates to the potential for errors and maintenance difficulties. Ignoring the score would be unwise, as it flags a genuine concern about the function's design. Focusing solely on performance misses the core issue of increased complexity, which impacts testability and long-term maintainability.
11 / 25
David's comment focuses on the concept of 'unnecessary branches,' which in this context refers to multiple independent decision points within the code. High cyclomatic complexity arises when a function has more paths of execution than simply the input parameters. This translates directly into increased testing requirements – each branch needs to be thoroughly verified – and a greater risk that a bug could exist in one of those less-traveled paths. Option A is incorrect as lines of code aren't directly related to cyclomatic complexity, option C addresses formatting not complexity, and option D relates to variable usage rather than branching logic.
12 / 25
Alex is referring to cyclomatic complexity as a way to quantify the potential for errors and the need for thorough testing. A higher score indicates more possible execution paths, meaning there are more scenarios that *could* fail during tests. It's not simply about lines of code; it's about the branching logic within the handler function itself. Option A is too literal; options C and D misinterpret the core concept.
13 / 25
Daniel, a senior developer, sends this message in a Slack channel after reviewing a new feature: "I'm concerned about the cyclomatic complexity of this function. It's currently at 10, and that's pushing us towards our target of 6 for critical path functions. We need to ensure we're not creating overly complex logic here." What is Daniel primarily highlighting when he mentions a 'target of 6'? Consider the implications of exceeding this threshold.Daniel is focusing on the practical implications of cyclomatic complexity. A 'target of 6' isn't a technical specification but rather a guideline for code quality – specifically, it represents a threshold beyond which the risk of bugs and difficulties in testing and maintaining the code significantly increases. Higher complexity makes it harder to cover all possible execution paths with tests, leading to gaps in test coverage and potential errors.
The other options misinterpret the purpose of this target; it's not about efficiency or test requirements directly, but about maintainability and reducing the likelihood of defects.
The other options misinterpret the purpose of this target; it's not about efficiency or test requirements directly, but about maintainability and reducing the likelihood of defects.
14 / 25
During a standup update, a developer says: 'I've been working on the user profile service. The `update_address` function now has a cyclomatic complexity of 8. I'm worried about this, as our team guidelines recommend keeping complex functions below 5.' What does the developer *specifically* mean by referring to the 'guidelines recommending keeping complex functions below 5'? Consider the potential consequences if this guideline isn't followed.
The developer is referring to the impact of cyclomatic complexity on maintainability. A higher score indicates more decision points within the function, making it harder to test thoroughly and understand the logic. Exceeding a guideline like 5 increases the risk of bugs, makes refactoring difficult, and negatively impacts overall code quality – essentially, it's about reducing the cognitive load for future developers.
15 / 25
Team Lead: "Hey team, I've been reviewing the new order processing service. The `validate_order` function has a cyclomatic complexity of 18 – that's significantly higher than our acceptable range of 10 for core business logic. It suggests potential issues with error handling and control flow that could lead to bugs and difficulties in future maintenance. Can someone take a look at refactoring it?"This scenario highlights a realistic code review situation. The key takeaway is that cyclomatic complexity isn't just about numbers; it directly relates to the potential for errors and maintenance difficulties. Ignoring the score would be unwise, as it flags a genuine concern about the function's design. Focusing solely on performance misses the core issue of increased complexity, which impacts testability and long-term maintainability.
16 / 25
David's comment focuses on the concept of 'unnecessary branches,' which in this context refers to multiple independent decision points within the code. High cyclomatic complexity arises when a function has more paths of execution than simply the input parameters. This translates directly into increased testing requirements – each branch needs to be thoroughly verified – and a greater risk that a bug could exist in one of those less-traveled paths. Option A is incorrect as lines of code aren't directly related to cyclomatic complexity, option C addresses formatting not complexity, and option D relates to variable usage rather than branching logic.
17 / 25
Alex is referring to cyclomatic complexity as a way to quantify the potential for errors and the need for thorough testing. A higher score indicates more possible execution paths, meaning there are more scenarios that *could* fail during tests. It's not simply about lines of code; it's about the branching logic within the handler function itself. Option A is too literal; options C and D misinterpret the core concept.
18 / 25
Daniel, a senior developer, sends this message in a Slack channel after reviewing a new feature: "I'm concerned about the cyclomatic complexity of this function. It's currently at 10, and that's pushing us towards our target of 6 for critical path functions. We need to ensure we're not creating overly complex logic here." What is Daniel primarily highlighting when he mentions a 'target of 6'? Consider the implications of exceeding this threshold.Daniel is focusing on the practical implications of cyclomatic complexity. A 'target of 6' isn't a technical specification but rather a guideline for code quality – specifically, it represents a threshold beyond which the risk of bugs and difficulties in testing and maintaining the code significantly increases. Higher complexity makes it harder to cover all possible execution paths with tests, leading to gaps in test coverage and potential errors.
The other options misinterpret the purpose of this target; it's not about efficiency or test requirements directly, but about maintainability and reducing the likelihood of defects.
The other options misinterpret the purpose of this target; it's not about efficiency or test requirements directly, but about maintainability and reducing the likelihood of defects.
19 / 25
During a standup update, a developer says: 'I've been working on the user profile service. The `update_address` function now has a cyclomatic complexity of 8. I'm worried about this, as our team guidelines recommend keeping complex functions below 5.' What does the developer *specifically* mean by referring to the 'guidelines recommending keeping complex functions below 5'? Consider the potential consequences if this guideline isn't followed.
The developer is referring to the impact of cyclomatic complexity on maintainability. A higher score indicates more decision points within the function, making it harder to test thoroughly and understand the logic. Exceeding a guideline like 5 increases the risk of bugs, makes refactoring difficult, and negatively impacts overall code quality – essentially, it's about reducing the cognitive load for future developers.
20 / 25
Team Lead: "Hey team, I've been reviewing the new order processing service. The `validate_order` function has a cyclomatic complexity of 18 – that's significantly higher than our acceptable range of 10 for core business logic. It suggests potential issues with error handling and control flow that could lead to bugs and difficulties in future maintenance. Can someone take a look at refactoring it?"This scenario highlights a realistic code review situation. The key takeaway is that cyclomatic complexity isn't just about numbers; it directly relates to the potential for errors and maintenance difficulties. Ignoring the score would be unwise, as it flags a genuine concern about the function's design. Focusing solely on performance misses the core issue of increased complexity, which impacts testability and long-term maintainability.
21 / 25
David's comment focuses on the concept of 'unnecessary branches,' which in this context refers to multiple independent decision points within the code. High cyclomatic complexity arises when a function has more paths of execution than simply the input parameters. This translates directly into increased testing requirements – each branch needs to be thoroughly verified – and a greater risk that a bug could exist in one of those less-traveled paths. Option A is incorrect as lines of code aren't directly related to cyclomatic complexity, option C addresses formatting not complexity, and option D relates to variable usage rather than branching logic.
22 / 25
Alex is referring to cyclomatic complexity as a way to quantify the potential for errors and the need for thorough testing. A higher score indicates more possible execution paths, meaning there are more scenarios that *could* fail during tests. It's not simply about lines of code; it's about the branching logic within the handler function itself. Option A is too literal; options C and D misinterpret the core concept.
23 / 25
Daniel, a senior developer, sends this message in a Slack channel after reviewing a new feature: "I'm concerned about the cyclomatic complexity of this function. It's currently at 10, and that's pushing us towards our target of 6 for critical path functions. We need to ensure we're not creating overly complex logic here." What is Daniel primarily highlighting when he mentions a 'target of 6'? Consider the implications of exceeding this threshold.Daniel is focusing on the practical implications of cyclomatic complexity. A 'target of 6' isn't a technical specification but rather a guideline for code quality – specifically, it represents a threshold beyond which the risk of bugs and difficulties in testing and maintaining the code significantly increases. Higher complexity makes it harder to cover all possible execution paths with tests, leading to gaps in test coverage and potential errors.
The other options misinterpret the purpose of this target; it's not about efficiency or test requirements directly, but about maintainability and reducing the likelihood of defects.
The other options misinterpret the purpose of this target; it's not about efficiency or test requirements directly, but about maintainability and reducing the likelihood of defects.
24 / 25
During a standup update, a developer says: 'I've been working on the user profile service. The `update_address` function now has a cyclomatic complexity of 8. I'm worried about this, as our team guidelines recommend keeping complex functions below 5.' What does the developer *specifically* mean by referring to the 'guidelines recommending keeping complex functions below 5'? Consider the potential consequences if this guideline isn't followed.
The developer is referring to the impact of cyclomatic complexity on maintainability. A higher score indicates more decision points within the function, making it harder to test thoroughly and understand the logic. Exceeding a guideline like 5 increases the risk of bugs, makes refactoring difficult, and negatively impacts overall code quality – essentially, it's about reducing the cognitive load for future developers.
25 / 25
Team Lead: "Hey team, I've been reviewing the new order processing service. The `validate_order` function has a cyclomatic complexity of 18 – that's significantly higher than our acceptable range of 10 for core business logic. It suggests potential issues with error handling and control flow that could lead to bugs and difficulties in future maintenance. Can someone take a look at refactoring it?"This scenario highlights a realistic code review situation. The key takeaway is that cyclomatic complexity isn't just about numbers; it directly relates to the potential for errors and maintenance difficulties. Ignoring the score would be unwise, as it flags a genuine concern about the function's design. Focusing solely on performance misses the core issue of increased complexity, which impacts testability and long-term maintainability.
Frequently Asked Questions
What does the "Cyclomatic Complexity Vocabulary" exercise practise?
Practice English vocabulary for discussing cyclomatic complexity in code reviews: complexity scores, thresholds, refactoring language, and review comments. 5 exercises.
How many questions are in this exercise?
This exercise has 25 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Advanced. If the vocabulary feels difficult, browse the Code Quality & Metrics category page for an easier module to start with.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free with no account, sign-up, or paywall.
Do I get feedback if I answer incorrectly?
Yes — whichever option you choose, right or wrong, you'll immediately see an explanation clarifying the correct term and why the other options don't fit.
Can I retry this exercise?
Yes — once you finish all the questions, a "Try again" button on the results screen resets the exercise so you can practise as many times as you like.
Do I need an account to track my progress?
No account is required. Your progress bar and score for this session are tracked in the browser as you go, but nothing is saved once you leave the page.
Is "Cyclomatic Complexity Vocabulary" part of a larger series?
Yes — it's one exercise in the Code Quality & Metrics category on CoderSlingo. See the category page for the full list of related exercises on similar terminology.
Can I link directly to this exercise?
Yes — this exercise has its own permanent URL, so you can bookmark it or share the link directly with a colleague or study partner.
Where can I find more exercises like this one?
See the Code Quality & Metrics category page for related exercises, or browse the main Exercises hub for other IT English topics.