The document discusses different types of complexity in software systems, including code complexity, cognitive complexity, and code entropy. It provides examples of measuring complexity using various metrics and tools. The key takeaways are to start simply and make sure systems work, keep complexity in check, help others understand the big picture, and keep change and release entropy low to avoid issues. Managing complexity is important as systems evolve over time.

1. Code Complexity
& Entropy
Audrius Kovalenko | @slicklash

2. Customer-Friendly System
https://thedailywtf.com/articles/The_Customer-Friendly_System

3. Levels of complexity

4. Which one is your system?
quick
hacks
spaghettiduplicates
and globals
layered
architecture
separation composition

5. dumb dumbunder-engineering over-engineeringsimple complex
Which one is your system?

6. dumb dumbunder-engineering over-engineeringsimple complex
Which one is your system?
How easy is it to change a single element?
How does the change propagate?

7. dumb dumbunder-engineering over-engineeringsimple complex
Which one is your system?
How easy is it to change a single element?
How does the change propagate?

8. Where does complexity
come from?

9. System growth is organic
“Everything is a system.
Everything is part of a larger system.
The universe is infinitely systematized.
All systems are infinitely complex.”

10. “A complex system that works has evolved from
a simple system that worked.
System growth is organic

11. “A complex system that works has evolved from
a simple system that worked.
A complex system designed from scratch
never works and cannot be patched up to work.”
Gall’s law, 1975
System growth is organic

12. solution initially looks like
an attractive road with
flowers...
Emergent design is difficult

13. https://martinfowler.com/bliki/AntiPattern.html
solution initially looks like
an attractive road with
flowers...
... but further on leads you
into the maze of monsters
Emergent design is difficult

14. “Any piece of software reflects the
organizational structure that produced it.”
Conway's law, 1967
Imposed things are
difficult to escape

15. “Any piece of software reflects the
organizational structure that produced it.”
Conway's law, 1967
Imposed things are
difficult to escape
“companies” and “guilds”

16. QUALITY
TIME COST
expensive late
bad
quality
scope
change
Project management triangle

17. Planning fallacy
Brooks’s law, 1975
Parkinson's law, 1955
Hofstadter's law, 1979

18. Near-optimal solutions

19. Types of complexity

20. Essential complexity
Part of the problem
Cannot be reduced

21. Accidental complexity
Outside of the problem
Can be reduced

22. Cyclomatic complexity
const getWords = number => {
switch (number) {
case 1: // +1
return 'one';
case 2: // +1
return 'a couple';
case 3: // +1
return 'a few';
default: // +1
return 'lots';
}
};
complexity = 4
count of linearly
independent paths

23. Cyclomatic complexity
const getWords = number => {
switch (number) {
case 1: // +1
return 'one';
case 2: // +1
return 'a couple';
case 3: // +1
return 'a few';
default: // +1
return 'lots';
}
};
const sumOfPrimes = max => {
let total = 0;
OUT: for (let i = 1; i <= max; ++i) { // +1
for (let j = 2; j < i; ++j) { // +1
if (i % j == 0) { // +1
continue OUT;
}
}
total += i;
}
return total; // +1
};
complexity = 4 complexity = 4

24. Cognitive complexity
const getWords = number => {
switch (number) { // +1
case 1:
return 'one';
case 2:
return 'a couple';
case 3:
return 'a few';
default:
return 'lots';
}
};
const sumOfPrimes = max => {
let total = 0;
OUT: for (let i = 1; i <= max; ++i) { // +1
for (let j = 2; j < i; ++j) { // +2
if (i % j == 0) { // +3
continue OUT; // +1
}
}
total += i;
}
return total;
};
complexity = 1 complexity = 7
White Paper

25. Cognitive complexity
const shouldNotDisable = false;

26. Demo
measuring complexity
https://www.sonarqube.org

27. How do we cope with
complexity?

28. Gestalt psychology
from German: Gestalt "shape, form"

29. Gestalt psychology
“The whole is something else than the sum
of its parts.”
Kurt Koffka, 1935

30. Gestalt psychology
“Big picture”
#include <limits.h>
#define _ void
#include <time.h>
#define _ volatile
#include <string.h>
#define you main
_ you (){_ are_my_poetry;
_ you_make_me_smile;
_ and_sometimes_cry;}

31. Ready?
Working memory capacity

32. Working memory capacity

33. Working memory capacity

34. “The number of objects an
average person can hold in
working memory is about seven.”
Miller's law, 1956
7±2
Working memory capacity

35. How big are your changes?

36. Code entropy

37. Code entropy

38. Demo
measuring entropy
git-files-changed-per-day.sh
plot-entropy.py
% cd ~/code/app-market/communities/communities-blog-app
% git-files-changed-per-day.sh > /tmp/stats
% plot-entropy.py /tmp/stats

39. High entropy + frequent releases = bad combination
2.0.0-beta.0..1..2..3..4..5..6..7..8..9..10..11..12..13..14..15..16..17..
2.0.0-rc.0..1..2..3..4..5..6..7..
8.0.0-beta.0..1..2..3..4..5..6..7..8..9..10..11..12..13..14..
8.0.0-rc.0..1..2..3..4..
Code entropy

40. Code entropy
The more parts of the system you need to modify
the harder it is to implement that change.

41. Symptom of leaky abstractions and
tightly coupled dependencies
The more parts of the system you need to modify
the harder it is to implement that change.
Code entropy

42. Takeaways
Be pessimistic when planning
Start with simple and make sure it works
Keep complexity in OK zone
Help others to understand the big picture
Keep change and release entropy low

43. “Simplicity and elegance are unpopular
because they require hard work and discipline
to achieve and education to be appreciated.”
E. W. Dijkstra

44. THE END
https://youtu.be/nORRgU8sGdE