In this talk, we will discuss How a good module look like (Discussion on module boundaries - Reusable code). Properties of good reusable code. Principles that help get the module boundaries right (cohesion principles) Principles to manage dependencies between the modules (coupling principles). Tools that can be used to decouple the code base. (We will be using IntelliJ Idea DSM to visualise the code base dependencies and to break them). Techniques that can help to prevent future issues. We won't be covering all the principles or every aspect of the given principles due to time constrain. Main goal of the talk is to provide actionable points and to have a healthy discussion around the same.

1. Design principles to modularise
a monolith codebase
- Prashant Kalkar

2. Agenda
How modules can help?
Reusable module boundaries
Principles of Cohesion
Module dependencies (Coupling principles)
Breaking up Dependencies

3. How modules can help?

4. Big ball of Mud (Class coupling)
Reference: Neal Ford: "Building Evolutionary Architectures"

5. Module 1 Module 2
Module breaks dependencies (disallow)

6. Modules - What am I talking about
● Modules allowed by build tools like Maven, Gradle or others.
● In Repo, modules (multi-module project)

7. Opposing requirements for a Reusable code

8. Reusable module boundaries

10. Where are the module boundaries?

14. How changes affect clients
Change Option 1 Option 2 Option3
Changes In Switch or
Interface
Yes Yes Yes
Changes in Light
Implementation
Yes Yes Only Clients using
Light
Changes in Fan
Implementation
Yes Yes Only Clients using
Fan

15. Checkout Example

16. Need to support Card Payments

17. Payment as plugin/extension

18. Support more payments without module changes

19. ISP and OCP
ISP - “Make fine grained interfaces that are client specific.”
Interface consumer and Interfaces are named and packaged together.
OCP - “Software entities (classes, modules, functions, etc.) should be open for
extension but closed for modification.”
Abstraction modules allows to satisfy Opposing requirements for a Reusable
code.

20. Real life examples
JPA - Hibernate
JDBC - MySQL client, PostgreSQL clients etc.
Slf4j - Log4j, Logback etc.
Kubernetes - CNI, CRI, CSI, CPI etc

21. Principles of Cohesion

22. CCP - “Classes that change together are packaged together.”
“ When we make a change we want to be able to jump to a single clear point in
the system and make the change.”
- Refactoring: Improving the Design of Existing Code, Ch 03. Bad
Smells. Divergent Change
For, Layered architecture one change per layer.
The Common Closure Principle

23. How to apply Common Closure Principle

24. Module dependencies (Coupling principles)

25. Which module / class is more stable? A or B?

26. What about now?

27. Fan In, Fan Out
Instability = Fan Out / (Fan In + Fan Out)
Depend on things which are stable than you

28. Dependency cycles

29. Dependency cycles

30. Modularity
Dependency cycle prevent module creation
Maven modules will not work.
Java 9 modules will not work.

31. Dependency direction towards Instability

32. Ideal dependency graph
● Dependency flow downwards
● Depency direction flows toward stability
● No cycles.

33. Ideal dependency graph

34. Breaking up Dependencies

35. Example Application codebase
Orchestration framework which uses the DAG as inputs. Different type of nodes
are supported like REST API services, or message passing brokers (like Kafka
etc).

36. IntelliJ Idea DSM

37. Move classes

38. Move classes (Cont)

39. Dependency Inversion Principle (DIP)

40. Architectural Tests

41. References
Agile Software Development, Principles, Patterns, and Practices
Clean Architecture: A Craftsman's Guide to Software Structure and Design
Refactoring: Improving the Design of Existing Code
Building Evolutionary Architectures, 2nd Edition

42. Thank You!