from DevMotion Meetup on 2016-03-14 In our everyday work as developers, we are confronted with various software metrics. What do these numbers mean, how are they calculated? Do these metrics enable us to make better software? In this talk we investigate the use of software metrics in general and also take a detailed look at several frequently used code quality metrics. We will learn about the meaning and usefulness of metrics such as lines of code, cyclomatic complexity, duplication, package entanglement and unit test coverage.

1. Code Quality Metrics Demystified
@JeroenResoort @jdriven_nl

2. What are metrics?

3. Why use metrics?

4. Why use metrics?
To measure software quality

5. What is software quality?

6. Why use metrics?
To measure and improve software maintainability attributes:
● Analysability
● Changeability
● Stability
● Testability

7. How to collect metrics?

8. How to use / collect metrics?
IDE
CheckStyle
SonarQube

9. How to collect metrics?
docker run -d --name sonarqube -p 9000:9000 -p 9092:9092 sonarqube
mvn sonar:sonar

10. Volume

11. Volume
Files / Classes
Lines
Lines of code
LoC per file
LoC per method

12. Volume
public int sum(int a, int b) {
return a + b;
}

13. Volume
public int sumToo( int a
, int b )
{
int result = a + b;
return result;
}

14. Volume
public List<Integer> calculate(List<Integer> numbers) {
return numbers.stream().map(i -> i * i).filter(i -> i % 2 ==
0).collect(Collectors.toList());
}

15. Volume
public List<Integer> calculateFormatted(List<Integer> numbers) {
return numbers.stream().
map(i -> i * i).
filter(i -> i % 2 == 0).
collect(Collectors.toList());
}

16. Volume
import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;

17. Volume
import java.util.*;

18. Cyclomatic Complexity

19. Cyclomatic Complexity
McCabe, 1976
Control flow graph
Linearly independent paths

20. Cyclomatic Complexity

21. Cyclomatic Complexity
The complexity M is defined as
M = E − N + 2P,
where
E = the number of edges of the graph.
N = the number of nodes of the graph.
P = the number of connected components.

22. Cyclomatic Complexity
Alternative formula
M = E − N + P
After connecting exit point to entry point

23. Cyclomatic Complexity

24. Cyclomatic Complexity
public int sum(int a, int b) {
return a + b;
}

25. Cyclomatic Complexity
public int sum(int[] amounts) {
int result = 0;
for (int i = 0; i < amounts.length; i++) {
result += amounts[i];
}
return result;
}

26. Cyclomatic Complexity
public boolean checkWithdrawal(Account account, int amount)
{
boolean result = false;
if (account.getBalance() >= amount) {
result = true;
}
if (account.isLocked()) {
result = false;
}
return result;
}

27. Cyclomatic Complexity
public boolean checkWithdrawal(Account acc, int amount) {
if (!acc.isLocked() && acc.getBalance() >= amount) {
return true;
}
return false;
}

28. Cyclomatic Complexity
Complexity per class
Complexity per method

29. Fan in / Fan out

30. Fan in / Fan out
Fan in: number of classes referencing you
Fan out: number classes you are referencing

31. Package Entanglement

32. Package Entanglement

33. Duplication

34. Duplication
How to check?
Per line vs multiple lines?
Exact match or not?

35. Unit Test coverage

36. Unit Test coverage
Bad examples

37. Unit Test coverage
Are your unit tests actually testing the right things?
Mutation tests!

38. Conclusion
A lot of metrics available
Understand what they mean
Don’t use metrics as KPIs!

39. Questions?

40. Code Quailty Metrics Demystified
@JeroenResoort @jdriven_nl