Understanding project measures and metrics

The technical debt is the sum of the maintainability issue remediation costs. An issue remediation cost is the effort (in minutes) evaluated to fix the issue. It is taken over from the effort assigned to the rule that raised the issue.

An 8-hour day is assumed when the technical debt is shown in days.

The technical debt ratio is the ratio between the cost to develop the software and the technical debt (the cost to fix it). It is calculated based on the following formula:

sqale_debt_ratio = technical debt /(cost to develop one line of code * number of lines of code)

Where the cost to develop one line of code is predefined in the database (by default, 30 minutes)

Example:

• Technical debt: 122,563
• Number of lines of code: 63,987
• Cost to develop one line of code: 30 minutes
• Technical debt ratio: 6.4%

The default Maintainability rating scale (sqale_rating) is:

• A ≤ 5%
• B ≥ 5% to <10%
• C ≥ 10% to <20%
• D ≥ 20% to < 50%
• E ≥ 50%

Non-significant comment lines (empty comment lines, comment lines containing only special characters, etc.) do not increase the number of comment lines.

The following piece of code contains 9 comment lines:

/**                                            +0 => empty comment line
 *                                             +0 => empty comment line
 * This is my documentation                    +1 => significant comment
 * although I don't                            +1 => significant comment
 * have much                                   +1 => significant comment
 * to say                                      +1 => significant comment
 *                                             +0 => empty comment line
 ***************************                   +0 => non-significant comment
 *                                             +0 => empty comment line
 * blabla...                                   +1 => significant comment
 */                                            +0 => empty comment line

/**                                            +0 => empty comment line
 * public String foo() {                       +1 => commented-out code
 *   System.out.println(message);              +1 => commented-out code
 *   return message;                           +1 => commented-out code
 * }                                           +1 => commented-out code
 */                                            +0 => empty comment line

In addition:

• For COBOL: Generated lines of code and pre-processing instructions (SKIP1, SKIP2, SKIP3, COPY, EJECT, REPLACE) are not counted as lines of code.
• For Java and Dart: File headers are not counted as comment lines (because they usually define the license).

The ABAP analyzer calculates the cyclomatic complexity at the function level. It increments the cyclomatic complexity by one each time it detects one of the following keywords: 

• AND
• CATCH
• DO
• ELSEIF
• IF
• LOOP
• LOOPAT
• OR
• PROVIDE
• SELECT…ENDSELECT
• TRY
• WHEN
• WHILE

The C/C++/Objective-C analyzer calculates the cyclomatic complexity at function and coroutine levels. It increments the cyclomatic complexity by one each time it detects: 

• A control statement such as: if, while, do while, for
• A switch statement keyword such as: case, default
• The && and || operators
• The ? ternary operator 
• A lambda expression definition

The C# analyzer calculates the cyclomatic complexity at method and property levels. It increments the cyclomatic complexity by one each time it detects:

• one of these function declarations: method, constructor, destructor, property, accessor, operator, or local function declaration.
• A conditional expression
• A conditional access
• A switch case or switch expression arm
• An and/or pattern
• One of these statements: do, for, foreach, if, while
• One of these expressions: ??, ??=, ||, or && 

The COBOL analyzer calculates the cyclomatic complexity at paragraph, section, and program levels. It increments the cyclomatic complexity by one each time it detects one of these commands (except when they are used in a copybook): 

• ALSO
• ALTER
• AND
• DEPENDING
• END_OF_PAGE
• ENTRY
• EOP
• EXCEPTION
• EXEC CICS HANDLE
• EXEC CICS LINK
• EXEC CICS XCTL
• EXEC CICS RETURN
• EXIT
• GOBACK
• IF
• INVALID
• OR
• OVERFLOW
• SIZE
• STOP
• TIMES
• UNTIL
• USE
• VARYING
• WHEN

The Dart analyzer calculates the cyclomatic complexity for:

• top-level functions
• top-level function expressions (lambdas)
• methods 
• accessors (getters and setters)
• constructors

It increments the complexity by one for each of the structures listed above. It doesn't increment the complexity for nested function declarations or expressions.

In addition, the count is incremented by one for each: 

• short-circuit binary expression or logical patterns (&&, ||, ??)
• if-null assignments (??=)
• conditional expressions (?:)
• null-aware operators (?[, ?., ?.., ...?)
• propagating cascades (a?..b..c)
• if statement or collection
• loop (for, while, do, and for collection)

case or pattern in a switch statement or expression

The Java analyzer calculates the cyclomatic complexity at the method level. It increments the Cyclomatic complexity by one each time it detects one of these keywords: 

• if
• for
• while
• case
• &&
• ||
• ?
• ->

The JS/TS analyzer calculates the cyclomatic complexity at the function level. The PHP analyzer calculates the cyclomatic complexity at the function and class levels. Both analyzers increment the cyclomatic complexity by one each time they detect:

• A function (i.e non-abstract and non-anonymous constructors, functions, procedures or methods)
• An if keyword
• A short-circuit (AKA lazy) logical conjunction (&&)
• A short-circuit (AKA lazy) logical disjunction (||)
• A ternary conditional expression
• A loop
• A case clause of a switch statement
• A throw or a catch statement
• A goto statement (only for PHP)

The PL/I analyzer increments the cyclomatic complexity by one each time it detects one of the following keywords: 

• PROC
• PROCEDURE
• GOTO
• GO TO
• DO
• IF
• WHEN
• |
• !
• |=
• !=
• &
• &=
• A DO statement with conditions (Type 1 DO statements are ignored)

The PL/SQL analyzer calculates the cyclomatic complexity at the function and procedure level. It increments the cyclomatic complexity by one each time it detects:

• The main PL/SQL anonymous block (not inner ones)
• One of the following statements: 
  • CREATE PROCEDURE 
  • CREATE TRIGGER 
  • basic LOOP 
  • WHEN clause (the WHEN of simple CASE statement and searched CASE statement)
  • cursor FOR LOOP
  • CONTINUE / EXIT WHEN clause (The WHEN part of the CONTINUE and EXIT statements)
  • exception handler (every individual WHEN)
  • EXIT 
  • FORLOOP
  • FORALL
  • IF
  • ELSIF
  • RAISE
  • WHILELOOP
• One of the following expressions:
  • AND expression (AND reserved word used within PL/SQL expressions)
  • OR expression (OR reserved word used within PL/SQL expressions), 
  • WHEN clause expression (the WHEN of simple CASE expression and searched CASE expression)

The VB.NET analyzer calculates the cyclomatic complexity at function, procedure, and property levels. It increments the cyclomatic complexity by one each time it detects:

• a method or constructor declaration (Sub, Function), 
• AndAlso
• Case
• Do
• End
• Error
• Exit
• For
• ForEach
• GoTo
• If
• Loop
• On Error
• OrElse
• Resume
• Stop
• Throw
• Try
• While