|17 Sept. 2017
In the book “Clean Architecture,” Uncle Bob shows you how to make the right decisions for your software projects right from the beginning, even before you start designing or coding. He unveils the rules and practices that will guide you in constructing and planning software.
The same Uncle Bob (also known as Robert Martin) who brought you “Clean Code” and “Clean Coder,” both admired by programmers and developers of all experience levels, and recommended to me by senior PHP website developers.
If you’re here because you aspire to become a solution designer or software engineer in your career, then I also recommend checking out, “How to Become an Outstanding Solution Architect” course on Udemy. It’s an excellent course to learn all the hard and soft skills needed to take your software design abilities to the next level.
Clean Architecture Book Review
Apart from Uncle Bob’s writing skills and cartoons at the start of each chapter, here are several things I liked about this publication. As Uncle Bob states, “It doesn’t take a significant amount of knowledge and skill to get a program working“.
Microservice design architecture is better suited for cloud-native development and deployments due to its small size and distributed nature. The cartoons at the beginning of each design principle will help you remember when to apply those concepts in the real world.
The book is filled with direct, practical solutions for the real challenges you’ll encounter—the ones that will either make or break your projects.The best part of the book is still Part 3, where he explains the Design Principles, the SOLID design principles. If you already understand them, it’s a good refresher, but if you’re not familiar, it’s perhaps the best resource to learn and comprehend those fundamental design principles.
This programming book covers the essential components of an enterprise application, such as a database and the web. It also includes case studies that demonstrate how you can apply the principles you’ve learned in this book to real-world situations.
Clean Architecture Reviews
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.
What will you learn from Clean Architecture?
In “Clean Architecture,” Uncle Bob discusses Design and Architecture. In the very first chapter, he explains the difference between Design and Architecture and why it’s important for software. He then goes on to explain the value that software provides to its users. It’s been a while since I last read an Uncle Bob classic, and somehow I wasn’t aware of this book.
It came as a surprise when a colleague mentioned it, and I didn’t realise that I should buy this book and read it. I just cursed myself for not knowing about this book earlier; it’s still new, but given my love for reading his books, it’s just a missed opportunity for me.
The introduction is very good and provides an excellent overview of design and architecture even for inexperienced developers. Even experienced programmers can learn a lot from his perspective. The Programming Paradigm is the section where the real action begins.
Part 1 – Introduction
Part 2 – Programming Paradigm
Part 3 – Design Principles
Part 4 – Component Principles
Part 5 – Architecture
Part 6 – Details
Since many developers are only familiar with Object-Oriented Programming, this will come as a surprise to them. You will learn about both structured and functional programming, alongside OOP.
The fourth part is where you will learn about the factors that drive good software design and layout, such as high communication and low coupling.There are case studies and numerous real-world examples that can help you learn the art of selecting the right software design for your product.
In the past, I have read several books (“Clean Code” and “The Clean Coder”) and many articles by Uncle Bob, but as always, I found this one outstanding and well-written. One of the best things about Uncle Bob is his ability to simplify complex concepts, and his explanations are truly fascinating.
You won’t get bored while reading his book, unlike many technical books, even the good ones. Another thing that always engages me in Uncle Bob’s books is the cartoons at the beginning of each chapter they’re fantastic. They set the tone for what’s coming and encourage you to read the chapter.
In Martin’s “Clean Architecture” book he doesn’t just present solutions. Drawing on over half a century of experience in various software environments, Martin guides you on which choices to make and why they’re crucial to your success. As you’d expect from Uncle Bob, this book is filled with straightforward, practical solutions for the actual challenges you’ll encounter – the ones that can either make or break your projects.
The fifth part is about the architecture itself. In this section, you’ll learn about microservices and services, the boundaries between different application parts, components, and business rules.
Overall, this is an excellent book for anyone looking to grasp the fundamentals of software design and architecture and how they impact the overall delivery and performance of products.The book is filled with straightforward, no-nonsense solutions for the real challenges you’ll face—the ones that can either make or break your projects.
In the book “Clean Architecture,” Uncle Bob shows you how to ensure your software projects are on the right track from your initial decisions, even before you begin designing or coding. He reveals the rules and techniques that will guide you as you plan and construct software.
You won’t lose interest while reading his book, which is often the case with many technical books, even the good ones. Another aspect that consistently captivates me in Uncle Bob’s book is the cartoons at the start of each chapter – they’re simply fantastic. They set the tone for what’s ahead and motivate you to read the chapter.