Skip to content

Engineering quality metrics

Estimated time to read: 10 minutes

Here's a comparison table. The table lists the Metrics, their category, and a brief description, indicating whether they are positive, negative, or neutral.

Code Quality Pattern

Metric Category Description
Design Patterns Code Quality Pattern Positive: Reusable solutions to common problems in software design.
Architectural Patterns Code Quality Pattern Positive: Larger-scale solutions for structuring an application.
Code Patterns Code Quality Pattern Positive: Focused on the implementation of code (SOLID, DRY, KISS).

Code Quality Metric

Metrics Category Description
Code Complexity Code Quality Metric Measures the complexity of code (Cyclomatic Complexity, Halstead Complexity, Maintainability Index).
Code Coverage Code Quality Metric Measures the percentage of code lines or branches executed during testing.
Code Churn Code Quality Metric Measures the frequency of code changes.
Code Duplication Code Quality Metric Measures code duplication across a codebase.
Code Smells Code Quality Metric Patterns in the code that suggest poor design or implementation choices.
Static Analysis Code Quality Metric Automated analysis of code for potential bugs, vulnerabilities, and maintainability issues.
Test Metrics Code Quality Metric Metrics focused on the quality of the test suite.
Defect Density Code Quality Metric Measures the number of defects per thousand lines of code (KLOC).
MTTF/MTBF Code Quality Metric Measures the average time between system failures (reliability indicator).
Code Maintainability Code Quality Metric Measures how easy it is to maintain your code, influenced by factors such as readability, modularity, and documentation.
Code Performance Code Quality Metric Measures how efficiently your code runs.
Code Security Code Quality Metric Measures how secure your code is, influenced by factors such as input validation, authentication, and encryption.
Code Style Code Quality Metric Measures how well your code follows established coding conventions and standards.
Code Testability Code Quality Metric Measures how easy it is to test your code, influenced by factors such as modularity, dependency injection, and mocking.
Code Usability Code Quality Metric Measures how easy it is for users to use your code, influenced by factors such as API design, error handling, and documentation.
Function Point Analysis Code Quality Metric Measures the size and complexity of a software system by counting the number of functions it provides.
Lines of Code & Comment Ratio Code Quality Metric Measures the size of a software system by counting the number of lines of code and the ratio of comments to code lines.
Coupling & Cohesion Code Quality Metric Measures the interdependence between software modules (coupling) and the relatedness of elements within a module (cohesion).
Code Review Metrics Code Quality Metric Metrics that track the effectiveness of the code review process.
Deployment Frequency & Lead Time Code Quality Metric Measures the number of deployments made within a specific time frame and the time it takes from committing code to deploying it in production.
Incident Rate & Time to Recovery Code Quality Metric Measures the number of incidents or production issues within a specific time frame and the time it takes to resolve an incident.

Team Dynamics

Metric Category Description
Domain Champion Team Dynamics Positive: Expert team members in specific domains.(SME)
Hoarding the Code Team Dynamics Negative: Prevents collaboration and creates bottlenecks.
Unusually High Churn Team Dynamics Negative: May indicate instability or inadequate code review processes.
Bullseye Commits Team Dynamics Negative: Large commits that can be difficult to review and may introduce bugs.
Heroing Team Dynamics Negative: Excessive workload taken by an individual, reducing collaboration.
Over Helping Team Dynamics Negative: Can slow down progress and create dependencies between team members.
Clean As You Go Team Dynamics Positive: Continuous refactoring and improvement of code for better maintainability.
In the Zone Team Dynamics Neutral: Deep focus, but requires balancing with effective communication and collaboration.
Bit Twiddling Team Dynamics Negative: Micro-optimizations that can make code less readable and maintainable.
The Busy Body Team Dynamics Negative: Disruptive interference with other team members' work.

Project Management

Metric Category Description
Scope Creep Project Management Negative: Expansion of project scope beyond original goals, leading to delays and increased complexity.
Flaky Product Ownership Project Management Negative: Inconsistent or unclear product ownership leading to confusion and misaligned priorities.
Just One More Thing Project Management Negative: Adding features or tasks at the last minute, disrupting schedules and increasing defect risk.
Rubber Stamping Project Management Negative: Approving code reviews or decisions without thorough consideration, leading to poor-quality code.
Knowledge Silos Project Management Negative: Concentration of knowledge within a small group, creating bottlenecks and reducing team understanding.
Self-Merging PRs Project Management Negative: Merging one's own pull requests without review, leading to decreased code quality and less knowledge sharing.
Long-Running PRs Project Management Negative: Pull requests that indicate poor planning, lack of collaboration, or scope creep. May result in merge conflicts or outdated code.
High Bus Factor Project Management Negative: Risk associated with losing key team members. Indicates heavy dependence on a small number of individuals.
Sprint Retrospectives Project Management Positive: Meetings for the team to reflect on their work, identify areas for improvement, and celebrate successes.

These table includes categorised into Code Quality Patterns, Code Quality Metrics, Team Dynamics, and Project Management. These Metrics can help you assess and improve the quality of your code, team collaboration, and project management practices. Be sure to focus on addressing the negative aspects and reinforcing the positive ones to create a more efficient and effective software development environment.

Find below some techniques to measure or assess the metrics mentioned in the comparison table:

Patterns

  1. Design Patterns, Architectural Patterns, and Code Patterns:
    • Manual code reviews
    • Refactoring sessions
    • Training and education on best practices

Code Quality Metrics

  1. Code Complexity:

    • Tools like McCabe's Cyclomatic Complexity, Halstead Complexity, and Maintainability Index
    • Integrated development environment (IDE) plugins and linters
    • Cyclomatic Complexity (M): M = E - N + 2P (E: number of edges, N: number of nodes, P: number of connected components)
    • Halstead Complexity: Various formulas based on the number of unique operators (n1) and operands (n2), and the total number of operators (N1) and operands (N2).
    • Maintainability Index: Formula for Maintainability Index: MI = 171 - 5.2 * log2(Halstead Volume) - 0.23 * Cyclomatic Complexity - 16.2 * log2(Lines of Code)
    • Halstead Volume: Formula for Halstead Volume: HV = N * log2(n), where N is the total number of operators (N1) and operands (N2) in the code (N = N1 + N2), and n is the sum of unique operators (n1) and operands (n2) in the code (n = n1 + n2).

  2. Code test Coverage:

    • Test coverage tools depending on the language you use, for example JaCoCo (Java), Coverage.py (Python), Istanbul (JavaScript), or SimpleCov (Ruby)
    • Line Coverage: (Lines Executed / Total Lines) * 100
    • Branch Coverage: (Branches Executed / Total Branches) * 100

  3. Code Churn:

    • Version control system (e.g., Git) logs and analytics
    • Project management tools with integrated repository tracking
    • Churn Rate: (Lines of Code Added + Lines of Code Deleted) / Total Lines of Code

  4. Code Duplication:

    • Code analysis tools like SonarQube, PMD, or Code Climate
    • Duplication Rate: (Duplicated Lines of Code / Total Lines of Code) * 100

  5. Code Smells:

    • Code reviews
    • Static analysis tools like SonarQube, Pylint, or FindBugs
    • Duplication Rate: (Duplicated Lines of Code / Total Lines of Code) * 100

  6. Static Analysis:

    • Static analysis tools like SonarQube, Pylint, ESLint, or FindBugs
    • No specific formula, but can be tracked using the number of issues or warnings generated by static analysis tools.

  7. Test Metrics:

    • Test reports generated by testing frameworks (e.g., JUnit, pytest)
    • Continuous integration (CI) tools and dashboards
    • Test Success Rate: (Number of Passed Tests / Total Number of Tests) * 100
    • Test Failure Rate: (Number of Failed Tests / Total Number of Tests) * 100

  8. Defect Density:

    • Issue tracking systems
    • Version control system logs
    • Lines of code (LOC) measurement tools
    • Defect Density: (Number of Defects / Thousand Lines of Code)

  9. MTTF/MTBF:

    • Monitoring and logging systems
    • Incident management tools
    • MTTF (Mean Time To Failure): Total Uptime / Number of Failures
    • MTBF (Mean Time Between Failures): (Total Uptime + Total Downtime) / Number of Failures

  10. Code Maintainability:

    • Code review tools
    • Static analysis tools like SonarQube
    • Code readability and modularity checks during code reviews
    • Maintainability Index: 171 - 5.2 * log2(Halstead Volume) - 0.23 * Cyclomatic Complexity - 16.2 * log2(Lines of Code)

  11. Code Performance:

    • Profiling tools like JProfiler and YourKit
    • Performance testing using load testing tools like JMeter or Gatling
    • There is no specific formula, but it can be measured using response time, throughput, or resource utilisation.

  12. Code Security:

    • Code review tools
    • Static analysis tools like SonarQube or OWASP Dependency Check
    • Security testing using tools like OWASP ZAP or Burp Suite
    • No specific formula, but it can be tracked using the number of security vulnerabilities or issues found by static analysis tools and security testing.

  13. Code Style:

    • Linters and code style checkers like Checkstyle, ESLint, or Pylint
    • Code review tools
    • No specific formula, but it can be tracked using the number of style issues or warnings generated by code style tools.

  14. Code Testability:

    • Code reviews focusing on testability aspects
    • Mocking frameworks like Mockito or EasyMock
    • Dependency injection frameworks like Spring or Guice
    • No specific formula, but it can be assessed based on factors like code modularity, dependency injection, and mocking.

  15. Code Usability:

    • User testing tools like UserTesting or UsabilityHub
    • API documentation review and feedback
    • No specific formula, but it can be assessed through user testing, API documentation review, and feedback

  16. Function Point Analysis (FPA):

    • There is no specific formula for FPA. Instead, FPA is based on counting the number of functional elements in the software, including external inputs, external outputs, external inquiries, internal logical files, and external interface files. These elements are then weighted according to their complexity to calculate the Unadjusted Function Point count (UFP). The UFP can be further adjusted using the Value Adjustment Factor (VAF) to obtain the Adjusted Function Point (AFP): AFP = UFP * VAF.

  17. Lines of Code (LOC) and Comment Ratio:

    • LOC: The number of lines of code in the source code.
    • Comment Ratio: (Number of Comment Lines / Total Lines of Code) * 100

  18. Coupling and Cohesion:

    • Coupling: Measures the degree of interdependence between modules. There is no specific formula, but it can be assessed using metrics like efferent coupling (Ce) and afferent coupling (Ca). Ce is the number of modules a module depends on, and Ca is the number of modules that depend on a module.
    • Cohesion: Measures the relatedness of elements within a module. There is no specific formula, but it can be assessed using metrics like Lack of Cohesion in Methods (LCOM). LCOM is based on the difference between the number of shared instance variables and the number of unshared instance variables in a class.

  19. Code Review Metrics:

    • Code Review Rate: (Number of Code Reviews Conducted / Total Number of Commits) * 100
    • Issues Identified Rate: (Number of Issues Identified / Total Number of Code Reviews) * 100
    • Average Time Spent on Code Reviews: Total Time Spent on Code Reviews / Number of Code Reviews

  20. Deployment Frequency and Lead Time:

    • Deployment Frequency: Number of Deployments / Time Frame (e.g., per week, per month)
    • Lead Time: (Total Time from Code Commit to Production Deployment) / Number of Deployments

  21. Incident Rate and Time to Recovery:

    • Incident Rate: Number of Incidents / Time Frame (e.g., per week, per month)
    • Time to Recovery: (Total Time Spent on Incident Resolution) / Number of Incidents

Please note that some metrics don't have specific formulas but are assessed qualitatively or through the use of tools that analyze the codebase. The formulas provided are not the only way to measure these metrics, as various tools and methods may use different approaches to estimation.

Team Dynamics and Project Management

  1. Domain Champion, Hoarding the Code, Heroing, Over Helping, Clean As You Go, In the Zone, Bit Twiddling, and The Busy Body:

    • Regular team meetings and one-on-ones
    • Anonymous feedback mechanisms
    • Retrospectives and post-mortems

  2. Unusually High Churn and Bullseye Commits:

    • Version control system logs and analytics
    • Code review tools (e.g., GitHub, GitLab, or Bitbucket pull requests)

  3. Scope Creep, Flaky Product Ownership, Just One More Thing, Rubber Stamping, Knowledge Silos, Self-Merging PRs, Long-Running PRs, and High Bus Factor:

    • Project management tools (e.g., Jira, Trello, or Asana)
    • Code review tools (e.g., GitHub, GitLab, or Bitbucket pull requests)
    • Cross-functional team collaboration
    • Regular communication and status updates
    • Documentation and knowledge-sharing platforms (e.g., Confluence, GitHub Wiki, or Notion)

  4. Sprint Retrospectives:

    • Scheduled sprint retrospective meetings
    • Retrospective facilitation techniques (e.g., Start-Stop-Continue, Mad-Sad-Glad, or Sailboat)

By using a combination of these techniques, tools, and practices, you can effectively measure and assess the metrics in the comparison table. Remember to continuously monitor and improve your software development process to ensure that your team remains efficient, effective, and aligned with best practices.