For every technical debt issue we identify during our 10-point inspection, we estimate a rough time it would take to resolve the problem. We refer to this as remediation time. It’s never perfect, but when viewed as an aggregate we find it’s a useful way to compare technical debt projects.
For files, we assign a letter rating from A to F based on the total remediation time of all of the technical debt issues that are identified. If an issue is classified as “Wontfix” or “Invalid” using our issue statuses, it will not count against the rating.
For repository-level metrics, it’s a bit more sophisticated. Over the years, we’ve found that our old GPAs tend to correlate very strongly with the size of a repository. In other words, large projects almost always score worse than small projects, reducing the value of the metric.
To make the repository-level maintainability rating more relevant, we compute a technical debt ratio, which is the total estimated remediation time divided by a very high level total estimated implementation time, based on repository size. Lower technical debt ratios are better.
The 10 checks outlined below are enabled by default in Code Climate. These checks will run on any file written in one of our Supported Languages for Maintainability.
The maintainability checks listed below each ship with a default threshold. These thresholds can be adjusted using a
.codeclimate.json, as shown in our docs on Default Checks.
Argument count (
argument-count) - Methods or functions defined with a high number of arguments
Complex logic (
complex-logic) - Boolean logic that may be hard to understand
File length (
file-lines) - Excessive lines of code within a single file
Identical blocks of code (
identical-code) - Duplicate code which is syntactically identical (but may be formatted differently)
Method complexity (
method-complexity) - Functions or methods that may be hard to understand (Cognitive Complexity)
Method count (
method-count)- Classes defined with a high number of functions or methods
method-lines) - Excessive lines of code within a single function or method
Nested control flow (
nested-control-flow) - Deeply nested control structures like if or case
Return statements (
return-statements) - Functions or methods with a high number of return statements
Similar blocks of code (
similar-code) - Duplicate code which is not identical but shares the same structure (e.g. variable names may differ)
Updated about a year ago