Static Code Analysis Vocabulary
Learn static code analysis vocabulary: linter findings, SonarQube code smell density, security hotspots, technical debt ratio, code smell categories — the language of automated code quality tooling.
0 / 45 completed
1 / 45
The CI pipeline report says: 'The linter flagged 23 issues in the new code.' What does a linter do?
A linter (e.g., ESLint, pylint, Checkstyle) performs static analysis on source code — analysing it without running it — to identify style violations, suspicious code patterns, potential bugs, and deviations from defined coding standards. It enforces consistency across a team and catches common mistakes early in the development cycle.
2 / 45
SonarQube reports: '0.5% code smell density in the analysed code.' What is 'code smell density'?
Code smell density is a ratio metric: the number of code smells (design or style issues that indicate potential maintainability problems) divided by the total lines of code analysed. A lower density indicates cleaner, more maintainable code. SonarQube uses this to summarise the overall code smell burden of a project relative to its size.
3 / 45
The security scan reports: 'The security hotspot requires review.' What is a 'security hotspot' in SonarQube?
A security hotspot in SonarQube is a code pattern that is security-sensitive but not necessarily a confirmed vulnerability. Examples include: usage of cryptographic functions, SQL string construction, or file path operations. Unlike a vulnerability (which SonarQube considers a confirmed issue), a hotspot requires a human reviewer to assess whether the specific usage is actually risky in context.
4 / 45
The quality report shows: 'Technical debt ratio: 3.2%.' What does the technical debt ratio represent?
Technical debt ratio (in SonarQube's SQALE methodology) is the ratio of the estimated remediation cost (time to fix all issues) to the estimated development cost of the entire codebase. A ratio of 3.2% means fixing all the identified issues would cost approximately 3.2% of the time it took to write the code. SonarQube uses this to assign a maintainability rating (A through E).
5 / 45
The code reviewer comments: 'This is a classic God Class code smell.' What is a God Class?
A God Class (also called a God Object) is a code smell where a single class has grown to centralise too much of the application's knowledge and logic. It violates the Single Responsibility Principle. God Classes are difficult to test, maintain, and understand. Other common code smell categories include: long method (a method that is too long), feature envy (a method that uses data from another class more than its own), and data clumps (groups of data items that always appear together).
6 / 45
Sarah: "Hey team, I've just submitted a PR with some new API integration. The build failed and the CI report says 'High Severity Static Analysis Violation – Duplicate Code Detected.' What does this violation mean?"Static analysis violations, like 'Duplicate Code Detected,' are triggered when tools identify redundant sections of code. This isn't necessarily a bug, but it often signals a design issue – perhaps the same logic was duplicated for efficiency or to avoid breaking existing functionality. The key is that the tool highlights this repetition as a potential area for refactoring and improved maintainability, not just a simple warning.
7 / 45
The question highlights John's confusion about the terminology. 'Maintainability violations' in the context of static analysis refers to metrics like cyclomatic complexity (the number of independent paths through a method) or line length that indicate potential problems with the code's structure and ease of understanding. It's not a subjective term but rather a measurement of code quality, often used to identify areas needing refactoring for improved long-term maintainability. Misconceptions might be that it's purely subjective or related to security.
8 / 45
'High cyclomatic complexity' is a key metric in static analysis that measures the number of independent paths through a function or method. A high value indicates a complex control flow, which often makes testing more challenging and increases the risk of missed edge cases. It's not about readability or security vulnerabilities directly, though those are related concerns – it specifically highlights the need for increased test coverage to account for all possible execution routes. The option describing whitespace is also a common misunderstanding about static analysis.
9 / 45
PR Description:
"Fix: Added new user authentication flow. Ran static analysis and got a warning about 'Excessive Method Length' in the `AuthService` class. It's over 100 lines – should I shorten it?"The correct answer highlights the core meaning of 'Excessive Method Length' – it's a signal that a method has grown too large and complex. This often leads to reduced maintainability and makes testing more challenging. The other options misinterpret the warning; it's not about performance or simply needing to shorten code for readability, but about the inherent difficulty in managing a long, monolithic method. Static analysis tools flag this as a potential code smell.
10 / 45
The term 'long method' refers to a function or method within a codebase that has become excessively lengthy and performs multiple tasks. This violates best practices for code design, making it harder to understand, test, debug, and modify. The static analysis tool flags this as a 'code smell' because such methods often indicate poor abstraction and can lead to increased technical debt. Option A is incorrect because 'long method' isn't directly related to library usage; options C and D are more specific concepts of complexity that might *cause* the long method, but aren't the definition itself.
11 / 45
Sarah: "Hey team, I've just submitted a PR with some new API integration. The build failed and the CI report says 'High Severity Static Analysis Violation – Duplicate Code Detected.' What does this violation mean?"Static analysis violations, like 'Duplicate Code Detected,' are triggered when tools identify redundant sections of code. This isn't necessarily a bug, but it often signals a design issue – perhaps the same logic was duplicated for efficiency or to avoid breaking existing functionality. The key is that the tool highlights this repetition as a potential area for refactoring and improved maintainability, not just a simple warning.
12 / 45
The question highlights John's confusion about the terminology. 'Maintainability violations' in the context of static analysis refers to metrics like cyclomatic complexity (the number of independent paths through a method) or line length that indicate potential problems with the code's structure and ease of understanding. It's not a subjective term but rather a measurement of code quality, often used to identify areas needing refactoring for improved long-term maintainability. Misconceptions might be that it's purely subjective or related to security.
13 / 45
'High cyclomatic complexity' is a key metric in static analysis that measures the number of independent paths through a function or method. A high value indicates a complex control flow, which often makes testing more challenging and increases the risk of missed edge cases. It's not about readability or security vulnerabilities directly, though those are related concerns – it specifically highlights the need for increased test coverage to account for all possible execution routes. The option describing whitespace is also a common misunderstanding about static analysis.
14 / 45
PR Description:
"Fix: Added new user authentication flow. Ran static analysis and got a warning about 'Excessive Method Length' in the `AuthService` class. It's over 100 lines – should I shorten it?"The correct answer highlights the core meaning of 'Excessive Method Length' – it's a signal that a method has grown too large and complex. This often leads to reduced maintainability and makes testing more challenging. The other options misinterpret the warning; it's not about performance or simply needing to shorten code for readability, but about the inherent difficulty in managing a long, monolithic method. Static analysis tools flag this as a potential code smell.
15 / 45
The term 'long method' refers to a function or method within a codebase that has become excessively lengthy and performs multiple tasks. This violates best practices for code design, making it harder to understand, test, debug, and modify. The static analysis tool flags this as a 'code smell' because such methods often indicate poor abstraction and can lead to increased technical debt. Option A is incorrect because 'long method' isn't directly related to library usage; options C and D are more specific concepts of complexity that might *cause* the long method, but aren't the definition itself.
16 / 45
Sarah: "Hey team, I've just submitted a PR with some new API integration. The build failed and the CI report says 'High Severity Static Analysis Violation – Duplicate Code Detected.' What does this violation mean?"Static analysis violations, like 'Duplicate Code Detected,' are triggered when tools identify redundant sections of code. This isn't necessarily a bug, but it often signals a design issue – perhaps the same logic was duplicated for efficiency or to avoid breaking existing functionality. The key is that the tool highlights this repetition as a potential area for refactoring and improved maintainability, not just a simple warning.
17 / 45
The question highlights John's confusion about the terminology. 'Maintainability violations' in the context of static analysis refers to metrics like cyclomatic complexity (the number of independent paths through a method) or line length that indicate potential problems with the code's structure and ease of understanding. It's not a subjective term but rather a measurement of code quality, often used to identify areas needing refactoring for improved long-term maintainability. Misconceptions might be that it's purely subjective or related to security.
18 / 45
'High cyclomatic complexity' is a key metric in static analysis that measures the number of independent paths through a function or method. A high value indicates a complex control flow, which often makes testing more challenging and increases the risk of missed edge cases. It's not about readability or security vulnerabilities directly, though those are related concerns – it specifically highlights the need for increased test coverage to account for all possible execution routes. The option describing whitespace is also a common misunderstanding about static analysis.
19 / 45
PR Description:
"Fix: Added new user authentication flow. Ran static analysis and got a warning about 'Excessive Method Length' in the `AuthService` class. It's over 100 lines – should I shorten it?"The correct answer highlights the core meaning of 'Excessive Method Length' – it's a signal that a method has grown too large and complex. This often leads to reduced maintainability and makes testing more challenging. The other options misinterpret the warning; it's not about performance or simply needing to shorten code for readability, but about the inherent difficulty in managing a long, monolithic method. Static analysis tools flag this as a potential code smell.
20 / 45
The term 'long method' refers to a function or method within a codebase that has become excessively lengthy and performs multiple tasks. This violates best practices for code design, making it harder to understand, test, debug, and modify. The static analysis tool flags this as a 'code smell' because such methods often indicate poor abstraction and can lead to increased technical debt. Option A is incorrect because 'long method' isn't directly related to library usage; options C and D are more specific concepts of complexity that might *cause* the long method, but aren't the definition itself.
21 / 45
Sarah: "Hey team, I've just submitted a PR with some new API integration. The build failed and the CI report says 'High Severity Static Analysis Violation – Duplicate Code Detected.' What does this violation mean?"Static analysis violations, like 'Duplicate Code Detected,' are triggered when tools identify redundant sections of code. This isn't necessarily a bug, but it often signals a design issue – perhaps the same logic was duplicated for efficiency or to avoid breaking existing functionality. The key is that the tool highlights this repetition as a potential area for refactoring and improved maintainability, not just a simple warning.
22 / 45
The question highlights John's confusion about the terminology. 'Maintainability violations' in the context of static analysis refers to metrics like cyclomatic complexity (the number of independent paths through a method) or line length that indicate potential problems with the code's structure and ease of understanding. It's not a subjective term but rather a measurement of code quality, often used to identify areas needing refactoring for improved long-term maintainability. Misconceptions might be that it's purely subjective or related to security.
23 / 45
'High cyclomatic complexity' is a key metric in static analysis that measures the number of independent paths through a function or method. A high value indicates a complex control flow, which often makes testing more challenging and increases the risk of missed edge cases. It's not about readability or security vulnerabilities directly, though those are related concerns – it specifically highlights the need for increased test coverage to account for all possible execution routes. The option describing whitespace is also a common misunderstanding about static analysis.
24 / 45
PR Description:
"Fix: Added new user authentication flow. Ran static analysis and got a warning about 'Excessive Method Length' in the `AuthService` class. It's over 100 lines – should I shorten it?"The correct answer highlights the core meaning of 'Excessive Method Length' – it's a signal that a method has grown too large and complex. This often leads to reduced maintainability and makes testing more challenging. The other options misinterpret the warning; it's not about performance or simply needing to shorten code for readability, but about the inherent difficulty in managing a long, monolithic method. Static analysis tools flag this as a potential code smell.
25 / 45
The term 'long method' refers to a function or method within a codebase that has become excessively lengthy and performs multiple tasks. This violates best practices for code design, making it harder to understand, test, debug, and modify. The static analysis tool flags this as a 'code smell' because such methods often indicate poor abstraction and can lead to increased technical debt. Option A is incorrect because 'long method' isn't directly related to library usage; options C and D are more specific concepts of complexity that might *cause* the long method, but aren't the definition itself.
26 / 45
Sarah: "Hey team, I've just submitted a PR with some new API integration. The build failed and the CI report says 'High Severity Static Analysis Violation – Duplicate Code Detected.' What does this violation mean?"Static analysis violations, like 'Duplicate Code Detected,' are triggered when tools identify redundant sections of code. This isn't necessarily a bug, but it often signals a design issue – perhaps the same logic was duplicated for efficiency or to avoid breaking existing functionality. The key is that the tool highlights this repetition as a potential area for refactoring and improved maintainability, not just a simple warning.
27 / 45
The question highlights John's confusion about the terminology. 'Maintainability violations' in the context of static analysis refers to metrics like cyclomatic complexity (the number of independent paths through a method) or line length that indicate potential problems with the code's structure and ease of understanding. It's not a subjective term but rather a measurement of code quality, often used to identify areas needing refactoring for improved long-term maintainability. Misconceptions might be that it's purely subjective or related to security.
28 / 45
'High cyclomatic complexity' is a key metric in static analysis that measures the number of independent paths through a function or method. A high value indicates a complex control flow, which often makes testing more challenging and increases the risk of missed edge cases. It's not about readability or security vulnerabilities directly, though those are related concerns – it specifically highlights the need for increased test coverage to account for all possible execution routes. The option describing whitespace is also a common misunderstanding about static analysis.
29 / 45
PR Description:
"Fix: Added new user authentication flow. Ran static analysis and got a warning about 'Excessive Method Length' in the `AuthService` class. It's over 100 lines – should I shorten it?"The correct answer highlights the core meaning of 'Excessive Method Length' – it's a signal that a method has grown too large and complex. This often leads to reduced maintainability and makes testing more challenging. The other options misinterpret the warning; it's not about performance or simply needing to shorten code for readability, but about the inherent difficulty in managing a long, monolithic method. Static analysis tools flag this as a potential code smell.
30 / 45
The term 'long method' refers to a function or method within a codebase that has become excessively lengthy and performs multiple tasks. This violates best practices for code design, making it harder to understand, test, debug, and modify. The static analysis tool flags this as a 'code smell' because such methods often indicate poor abstraction and can lead to increased technical debt. Option A is incorrect because 'long method' isn't directly related to library usage; options C and D are more specific concepts of complexity that might *cause* the long method, but aren't the definition itself.
31 / 45
Sarah: "Hey team, I've just submitted a PR with some new API integration. The build failed and the CI report says 'High Severity Static Analysis Violation – Duplicate Code Detected.' What does this violation mean?"Static analysis violations, like 'Duplicate Code Detected,' are triggered when tools identify redundant sections of code. This isn't necessarily a bug, but it often signals a design issue – perhaps the same logic was duplicated for efficiency or to avoid breaking existing functionality. The key is that the tool highlights this repetition as a potential area for refactoring and improved maintainability, not just a simple warning.
32 / 45
The question highlights John's confusion about the terminology. 'Maintainability violations' in the context of static analysis refers to metrics like cyclomatic complexity (the number of independent paths through a method) or line length that indicate potential problems with the code's structure and ease of understanding. It's not a subjective term but rather a measurement of code quality, often used to identify areas needing refactoring for improved long-term maintainability. Misconceptions might be that it's purely subjective or related to security.
33 / 45
'High cyclomatic complexity' is a key metric in static analysis that measures the number of independent paths through a function or method. A high value indicates a complex control flow, which often makes testing more challenging and increases the risk of missed edge cases. It's not about readability or security vulnerabilities directly, though those are related concerns – it specifically highlights the need for increased test coverage to account for all possible execution routes. The option describing whitespace is also a common misunderstanding about static analysis.
34 / 45
PR Description:
"Fix: Added new user authentication flow. Ran static analysis and got a warning about 'Excessive Method Length' in the `AuthService` class. It's over 100 lines – should I shorten it?"The correct answer highlights the core meaning of 'Excessive Method Length' – it's a signal that a method has grown too large and complex. This often leads to reduced maintainability and makes testing more challenging. The other options misinterpret the warning; it's not about performance or simply needing to shorten code for readability, but about the inherent difficulty in managing a long, monolithic method. Static analysis tools flag this as a potential code smell.
35 / 45
The term 'long method' refers to a function or method within a codebase that has become excessively lengthy and performs multiple tasks. This violates best practices for code design, making it harder to understand, test, debug, and modify. The static analysis tool flags this as a 'code smell' because such methods often indicate poor abstraction and can lead to increased technical debt. Option A is incorrect because 'long method' isn't directly related to library usage; options C and D are more specific concepts of complexity that might *cause* the long method, but aren't the definition itself.
36 / 45
Sarah: "Hey team, I've just submitted a PR with some new API integration. The build failed and the CI report says 'High Severity Static Analysis Violation – Duplicate Code Detected.' What does this violation mean?"Static analysis violations, like 'Duplicate Code Detected,' are triggered when tools identify redundant sections of code. This isn't necessarily a bug, but it often signals a design issue – perhaps the same logic was duplicated for efficiency or to avoid breaking existing functionality. The key is that the tool highlights this repetition as a potential area for refactoring and improved maintainability, not just a simple warning.
37 / 45
The question highlights John's confusion about the terminology. 'Maintainability violations' in the context of static analysis refers to metrics like cyclomatic complexity (the number of independent paths through a method) or line length that indicate potential problems with the code's structure and ease of understanding. It's not a subjective term but rather a measurement of code quality, often used to identify areas needing refactoring for improved long-term maintainability. Misconceptions might be that it's purely subjective or related to security.
38 / 45
'High cyclomatic complexity' is a key metric in static analysis that measures the number of independent paths through a function or method. A high value indicates a complex control flow, which often makes testing more challenging and increases the risk of missed edge cases. It's not about readability or security vulnerabilities directly, though those are related concerns – it specifically highlights the need for increased test coverage to account for all possible execution routes. The option describing whitespace is also a common misunderstanding about static analysis.
39 / 45
PR Description:
"Fix: Added new user authentication flow. Ran static analysis and got a warning about 'Excessive Method Length' in the `AuthService` class. It's over 100 lines – should I shorten it?"The correct answer highlights the core meaning of 'Excessive Method Length' – it's a signal that a method has grown too large and complex. This often leads to reduced maintainability and makes testing more challenging. The other options misinterpret the warning; it's not about performance or simply needing to shorten code for readability, but about the inherent difficulty in managing a long, monolithic method. Static analysis tools flag this as a potential code smell.
40 / 45
The term 'long method' refers to a function or method within a codebase that has become excessively lengthy and performs multiple tasks. This violates best practices for code design, making it harder to understand, test, debug, and modify. The static analysis tool flags this as a 'code smell' because such methods often indicate poor abstraction and can lead to increased technical debt. Option A is incorrect because 'long method' isn't directly related to library usage; options C and D are more specific concepts of complexity that might *cause* the long method, but aren't the definition itself.
41 / 45
Sarah: "Hey team, I've just submitted a PR with some new API integration. The build failed and the CI report says 'High Severity Static Analysis Violation – Duplicate Code Detected.' What does this violation mean?"Static analysis violations, like 'Duplicate Code Detected,' are triggered when tools identify redundant sections of code. This isn't necessarily a bug, but it often signals a design issue – perhaps the same logic was duplicated for efficiency or to avoid breaking existing functionality. The key is that the tool highlights this repetition as a potential area for refactoring and improved maintainability, not just a simple warning.
42 / 45
The question highlights John's confusion about the terminology. 'Maintainability violations' in the context of static analysis refers to metrics like cyclomatic complexity (the number of independent paths through a method) or line length that indicate potential problems with the code's structure and ease of understanding. It's not a subjective term but rather a measurement of code quality, often used to identify areas needing refactoring for improved long-term maintainability. Misconceptions might be that it's purely subjective or related to security.
43 / 45
'High cyclomatic complexity' is a key metric in static analysis that measures the number of independent paths through a function or method. A high value indicates a complex control flow, which often makes testing more challenging and increases the risk of missed edge cases. It's not about readability or security vulnerabilities directly, though those are related concerns – it specifically highlights the need for increased test coverage to account for all possible execution routes. The option describing whitespace is also a common misunderstanding about static analysis.
44 / 45
PR Description:
"Fix: Added new user authentication flow. Ran static analysis and got a warning about 'Excessive Method Length' in the `AuthService` class. It's over 100 lines – should I shorten it?"The correct answer highlights the core meaning of 'Excessive Method Length' – it's a signal that a method has grown too large and complex. This often leads to reduced maintainability and makes testing more challenging. The other options misinterpret the warning; it's not about performance or simply needing to shorten code for readability, but about the inherent difficulty in managing a long, monolithic method. Static analysis tools flag this as a potential code smell.
45 / 45
The term 'long method' refers to a function or method within a codebase that has become excessively lengthy and performs multiple tasks. This violates best practices for code design, making it harder to understand, test, debug, and modify. The static analysis tool flags this as a 'code smell' because such methods often indicate poor abstraction and can lead to increased technical debt. Option A is incorrect because 'long method' isn't directly related to library usage; options C and D are more specific concepts of complexity that might *cause* the long method, but aren't the definition itself.
Frequently Asked Questions
What does the "Static Code Analysis Vocabulary" exercise practise?
Learn static code analysis vocabulary: linter findings, SonarQube code smell density, security hotspots, technical debt ratio, code smell categories — the language of automated code quality tooling.
How many questions are in this exercise?
This exercise has 45 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Intermediate. 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 "Static Code Analysis 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.