Explain "Acyclic dependencies principle" and explain benefits coming from the principle

[K4liber]

https://en.wikipedia.org/wiki/Acyclic_dependencies_principle

[K4liber]

One can improve an architecture by explicite stating the dependencies between modules/packages (in Python for example, by fully typing the code) and remove all the cycles.

[K4liber]

I recently read about "Acyclic dependencies principle". I think that this principle is not necessary at all. I dont think we should focus to not have a cyclic dependencies between software components/modules/packages

The Acyclic Dependencies Principle (ADP) is a widely accepted guideline in software architecture that states the dependency graph of components, modules, or packages should not contain cycles—meaning that there should be no situation where two or more modules depend on each other, either directly or indirectly¹²³. While you may feel this principle is unnecessary, there are several compelling reasons why experienced software engineers and architects advocate for it.

Why the Acyclic Dependencies Principle Matters

• Improved Maintainability and Understandability
  Acyclic dependencies make it easier to understand, modify, and test individual modules. When cycles exist, changes in one module can ripple through the entire cycle, making the system harder to reason about and more error-prone²³⁴.
• Reduced Coupling and Increased Reusability
  Cyclic dependencies create tight coupling between modules, making it difficult to reuse or replace a single module without affecting others. This limits flexibility and can make future changes much more costly⁵⁶⁷.
• Easier Testing
  When modules are tightly coupled, it becomes challenging to test them in isolation. Acyclic dependencies allow for more straightforward unit and integration testing⁸⁹³.
• Simplified Build and Deployment
  Without cycles, the build order is clear, and modules can be built, deployed, and released independently. Cyclic dependencies often require modules to be released or upgraded together, which complicates deployment and versioning⁶⁴.
• Prevention of Unintended Side Effects
  Cycles increase the risk that a small change in one module will have unexpected effects elsewhere in the system, sometimes leading to subtle bugs or even system failures⁵⁷¹⁰.

What Happens When You Ignore the Principle?

• Tight Coupling
  Modules become so intertwined that it is difficult to change one without affecting others⁵⁷¹⁰.
• Increased Complexity
  The system becomes harder to understand and maintain, especially as it grows in size²³⁴.
• Build and Test Challenges
  Build times can increase, and testing becomes more complex and less reliable⁸⁷.
• Reduced Reusability
  Modules cannot be easily extracted or reused in other projects, as they are entangled with others⁴.

Counterarguments and Context

While the principle is strongly recommended for most software projects, there are some contexts—such as certain functional programming patterns or small, tightly integrated systems—where cyclic dependencies are less problematic or even natural⁵. However, in large, evolving, or modular systems, the risks and drawbacks of cyclic dependencies usually outweigh any perceived benefits.

Conclusion

The Acyclic Dependencies Principle is not an arbitrary rule, but a practical guideline that helps create robust, maintainable, and scalable software systems. While it may seem restrictive at first, the long-term benefits in terms of maintainability, testability, and reusability make it a cornerstone of good software architecture¹²³.

⁂

Footnotes

1. https://en.wikipedia.org/wiki/Acyclic_dependencies_principle ↩ ↩²

2. https://design-encyclopedia.com/?T=Acyclic+Dependencies+Principle ↩ ↩² ↩³ ↩⁴

3. https://khalilstemmler.com/wiki/acyclic-dependencies-principle/ ↩ ↩² ↩³ ↩⁴ ↩⁵

4. http://blog.schauderhaft.de/2014/11/09/five-reasons-why-you-should-keep-your-package-dependencies-cycle-free/ ↩ ↩² ↩³ ↩⁴

5. https://en.wikipedia.org/wiki/Circular_dependency ↩ ↩² ↩³ ↩⁴

6. https://wiki.sei.cmu.edu/confluence/display/java/DCL60-J.+Avoid+cyclic+dependencies+between+packages ↩ ↩²

7. https://bit.dev/reference/dependencies/avoid-cyclic-dependencies/ ↩ ↩² ↩³ ↩⁴

8. https://stackoverflow.com/questions/26804803/is-circular-dependency-good-or-bad ↩ ↩²

9. https://dev.to/d1d4c/solving-circular-dependencies-a-journey-to-better-architecture-4eo4 ↩

10. https://emenda.com/cyclical-dependencies-and-ensuring-you-dont-have-them/ ↩ ↩²

[K4liber]

Add a general info about "Software design priniciples":

"These principles, when applied together, help create software that is modular, maintainable, scalable, and adaptable to change"

[K4liber]

ADP goes under "component coupling principles"

https://medium.com/javarevisited/uncle-bobs-advice-on-stability-and-abstraction-b96ea8623e97

The solution for cyclic dependencies:

• DI (dependency inversion): "High level modules should not depend upon low-level modules. Both should depend upon abstractions."
• thinking about low - high level components