Clean Architecture, Robert Martin

No doubt that Robert C. Martin is one of the most influential author and software development theorist of our times. The already standard SOLID principles had been with us for decades, serving software discipline with full success. The Clean Series is a set of books full of advises, thoughts, ideas, rationales and principles with the same impact.

If you know his videos and lectures, probably this book will see familiar and many of the topics discussed repetitive. But the book has the value to reunite and review his software development discipline philosophy in a concise and complete harmonious set of essays. The main idea is to avoid dependency applying the Dependency Rule at all levels, classes and components.

The Dependency Inversion graph, where high-level functions calling middle-level functions through an interface that the middle-interface implements, is a medular software construction that should be applied as an obsessive pattern. It guarantees independence, reusable, clean architecture.

I started this book with high expectations as Clean Code was a wonderful book. Will Clear Architecture be like that? Unfortunately, no. This book is still worth reading for people interested in software design, I don’t believe the impact and role of this book will be similar to the earlier Clean Code book. There is not that much news and most of the book seems to talk about the architecture of relatively small systems.

The second part introduces three programming paradigms. I was surprised to see this in a book about architecture didn’t mind as I do enjoy reading about programming paradigms. The author claims that there are three and there will never be more, which came a bit as a surprise as I was aware of more than 3 paradigms (and so is the wikipedia page on programming paradigms).

The three paradigms covered in this book is structured, object-oriented, and functional. It describes these three from an interesting perspective, which is that each one adds a constraint. The third part is a summary of the SOLID principles which Robert Martin has covered many times in his earlier work.

They are described a little bit differently as before. I am not a fan of the way the Single-Responsibility Principle is explained in this book — “a module should be responsible for one, and only one, actor” and felt the example a bit strange. But all in all, the SOLID principles are useful principles to have in your toolbox.

Appendix A is still 50 pages of additional writing where the author summarizes his experience in working on different systems and what he has learned from which systems. Clean architecture was an interesting read.

I liked the clean architecture pattern that the author presents and his explanation of it. That makes the book worth reading. Other parts I likes less and often felt the description was a bit over simplified

Great reference material for Clean Architecture. If you’ve watched his CleanCoders series, then it’s a lot of the same material. That’s not a bad thing.

The amazing thing about this book is that the author converts what you can find in another books looking “complex concepts” in really “easy concepts”. Is amazing how the author simplify the problems and display examples to make clear everything. I was really impressed with the insight of this author.

Clean Architecture is basically one idea repeated over and over for 30 chapters. The idea is that the business logic should be self-contained. It should not depend on the database or sockets or frameworks or GUI. It is a really, really good idea, and it is not easy to actually follow.

However, the idea could have been explained in a lot less than 300 pages. At the end there is a 50-pages appendix where Robert Martin describes many of the projects he worked on, from the early 1970s to the 1990s. Many of the problems from those projects are interesting case studies that you can learn from – I quite enjoyed reading those stories.

This book introduces a set of important principles for building software right like SOLID. I quite enjoyed reading it, which is rare with technical books. I think it is very good for someone that has some idea of clean code, design patterns and software architecture principles already and wants to understand where these ideas come from and how they fit together.

Despite his reputation, this is the first book of Bob Martin’s that I have read. Looking back from the viewpoint of 2016, it gives an overview of all the trends and ideas in software development over the last few decades and suggests that good, clean architectural thinking overrides and can make use of all of them. Key takeaways for me where, an architecture of a system should resemble the system being built, know the boundaries in a system and when and how to enforce them, build with change in mind.

Excellent choice for developer seeking to level up in competence and professionalism. I have read the book 3 times. I have to admit that during my first read, I did not grasp every aspect of it. Many concepts where too abstract for my former knowledge.

It was like listening to somebody having clearly more depth of thought and experience than yourself, and whose advice seems sometimes enigmatic and arbitrary. It was still valuable read of course, but there were large chunks of it that gave me that feeling.

When I read that a second time 1.5 years later, and after a lot of “evolution” from my side, I had a lot of “aha!” moments. Problems that I was struggling with, dilemmas I was facing, it was all there. With the help of this book, I could even see things that I was doing wrong at the moment, and could prevent them before they become too harmful.

My third read was the best. A picture started arising in my mind. What was previously arbitrary restrictions and advice now made perfect sense. I am extremely grateful that I bought this and I would suggest it to every developer.

Really interesting. Includes a long introduction on the context in which programming came into existence, and sometimes illustrative pictures. Most of the content (from somewhere in the middle to the end) serves to phrase and rephrase the same idea, but from many different perspectives and within many different domains and fields. I highly recommend to read this book if you’re looking for a new, somewhat refreshing, complete and general perspective.