Clean Architecture - by Robert C. Martin

ISBN-13: 978-0134494166

"Clean Architecture" by Robert C. Martin offers an essential guide to software structure and design. The book lays out the foundational principles of crafting maintainable and flexible code, advocating for the separation of concerns and the enforcement of modular boundaries. Its practical approach demystifies the science of software design, providing readers with applicable strategies for constructing robust systems.

MY NOTES

A robust architecture allows the system to adapt to changes in technology without massive restructuring.

Following the SOLID principles is key to creating systems that are easy to understand, maintain, and extend over time.

Dependencies should be directed outward from core business rules to infrastructure and frameworks, not the other way around.

Good software architecture is not about heavy frameworks or overengineering; it's about essentialism and simplicity.

By applying the principles of Clean Architecture, developers can avoid common pitfalls that lead to rigid, fragile, and immobile software.

The architecture is about intent, and it should scream about the system's use cases.

Testable architectures ensure that the unit tests are decoupled from UI, database, and other external elements.

Architectural boundaries should be clear and enforced through tests that can run fast and frequently.

Investing in a clean architecture pays dividends in the long term by reducing the cost of new features and adjustments.

It's not about big upfront designs but about evolving the system in a way that preserves the ability to make changes easily.

The goal of architecture is to minimize the human resources required to build and maintain the required system.

Good architecture is not about beautiful drawings; it's about making software easier to understand, develop, and maintain.

The Dependency Rule: Source code dependencies must point only inward, toward higher-level policies.

Software architecture is about the important stuff, whatever that is.

Architects must be developers. They cannot afford to be mere spectators.

The best architectures are the ones where the system's use cases are evident in the structure of the software.

An essential characteristic of a good software architecture is that it's easy to change.

The SOLID principles are the foundation for building software that is easy to maintain and extend over time.

Decoupling the system into components allows us to develop and deploy parts of the system independently.

One of the signs of a good architecture is that the data does not drive the architecture; the architecture guides the data.

Every software architect's ultimate goal should be to eliminate himself. The system should be so well designed that it can evolve without the original architect's direct intervention.

Clean architecture does not depend on the existence of some library of feature-laden software.

The screaming architecture principle: The structure of the software should reflect the business domain.

Don't marry your framework. Architectures that are heavily coupled to frameworks are harder to maintain and evolve.

Boundaries: Draw them carefully to decouple the system into manageable, interchangeable components.

When choosing technologies, remember: The technology is not the architecture.

Architectural patterns like MVC, MVP, or MVVM are tools, not goals. They are a means to an end, not an end in themselves.

Testing is not about finding bugs. Good architecture makes the system easy to test.

Software architecture is a balance between flexibility, maintainability, efficiency, and scalability.

At its core, clean architecture is about giving developers the power to create sustainable systems.