The document discusses the challenges of building simple systems in technology projects, highlighting the distinction between essential and accidental complexity. It emphasizes principles like KISS (Keep It Simple, Stupid) and YAGNI (You Aren't Gonna Need It) to avoid unnecessary complexity and advocates for an evolutionary architecture approach to system design. The conclusion suggests that focusing on key requirements and practicing disciplined design can help mitigate complexity and enhance project success.

1. Essential
Complexity in
Systems
Architecture
Mark Mishaev

2. 66% of technology
projects fail

3. The #1 Cause of IT Failure

4. Agenda
Complexity defined
Why Building Simple Systems is Hard?
Practical Advice
Conclusion

5. Mark Mishaev,
Core Engineering Group Lead, SAST, Checkmarx
@mark_mishaev

6. What is Complexity?
Complexity is generally used to
characterize something with many parts
where those parts interact with each
other in multiple ways

7. There is no silver
bullet

8. Essential Complexity
Essential complexity, according to Brooks, is anything that's caused
directly by the problem that you're trying to solve.
Whereas accidental complexity is anything that's related to details
of the implementation.

9. Accidental
Complexity
We’re not so good at our jobs

10. “That’s been one of my mantras—focus and simplicity.
Simple can be harder than complex: You have to work hard
to get your thinking clean to make it simple. But it’s worth
it in the end, because once you get there, you can move
mountains.”
—Steve Jobs

11. “Simplicity is a great virtue
but it requires hard work to
achieve it and education to
appreciate it. And to make
matters worse: complexity
sells better.”
— Edsger W. Dijkstra.

12. Developers are drawn to complexity like
moths to a flame often with the same result

13. Why is simple
design so hard?

14. To design a simple
system requires deep
technological insight and
a strong character.

15. Common
Reasons for
Accidental
Complexity

16. Reason #1 – Violating
KISS
“The KISS principle states that most
systems work best if they are kept simple
rather than made complex; therefore
simplicity should be a key goal in design
and unnecessary complexity should be
avoided.”

17. Reason #2 – Violating
YAGNI
It's a statement that some capability we
presume our software needs in the future
should not be built now because "you
aren't gonna need it"

18. Reason #3 – Premature
Optimization
Premature optimization is spending a lot
of time on something that you may not
actually need. “Premature optimization is
the root of all evil” is a famous saying
among software developers. Its source is
credited to Donald Knuth.

19. Reason #4 – Violating
Occam’s Razor
The Simplest Solution is Almost Always
The Best Solution

20. Complex Designs
• When the simplicity principles above
are not observed, the resulting software
systems may have complexity in the
form of:
• Unneeded features
• Over-engineering

21. The Power of Focus

22. Always ask “Why”?
• Why do we need it?
• Why it’s important?
• Why now?
• Why do we care?

23. Find what the software has
to do and say “no” to the
things that fall outside of it

24. Simplification
of a Design

25. “You know you have
achieved perfection in
design, not when you have
nothing more to add, but
when you have nothing
more to take away.”
— Antoine de Saint-Exupery

26. Evolutionary
Architectures
• The heart of doing evolutionary architecture
is to make small changes, and put in
feedback loops that allow everyone to learn
from how the system is developing
• Approach to system design that anticipates
change and evolution

27. Main Characteristics
• Modularity (helps to prevent Big ball of
mud)
• Organized Around Business Capabilities
(DDD to the rescue)
• Experimentation (A/B Testing, canary
releases, etc.)

28. Conclusion

29. In conclusion, we saw that building simple systems is hard.
Good starting point of doing it is to have a discipline and a strong technical knowledge.
We saw that it's often coming from our tendency to put too much focus on the future and
potential use-cases.
Obviously, it's easier said than done because we’re building systems that are inherently complex,
but if we're focusing on what is important, don't optimize early and put in practice evolutionary
design approach, we have better chances to reduce accidental complexity and build more simple
systems on time.

30. Thank you!