Hot Best Seller

Clean Architecture

Availability: Ready to download

Building upon the success of best-sellers The Clean Coder and Clean Code, legendary software craftsman Robert C. "Uncle Bob" Martin shows how to bring greater professionalism and discipline to application architecture and design. As with his other books, Martin's Clean Architecture doesn't merely present multiple choices and options, and say "use your best judgment": it tel Building upon the success of best-sellers The Clean Coder and Clean Code, legendary software craftsman Robert C. "Uncle Bob" Martin shows how to bring greater professionalism and discipline to application architecture and design. As with his other books, Martin's Clean Architecture doesn't merely present multiple choices and options, and say "use your best judgment": it tells you what choices to make, and why those choices are critical to your success. Martin offers direct, no-nonsense answers to key architecture and design questions like: What are the best high level structures for different kinds of applications, including web, database, thick-client, console, and embedded apps? What are the core principles of software architecture? What is the role of the architect, and what is he/she really trying to achieve? What are the core principles of software design? How do designs and architectures go wrong, and what can you do about it? What are the disciplines and practices of professional architects and designers? Clean Architecture is essential reading for every software architect, systems analyst, system designer, and software manager -- and for any programmer who aspires to these roles or is impacted by their work.

*advertisement

Compare

Building upon the success of best-sellers The Clean Coder and Clean Code, legendary software craftsman Robert C. "Uncle Bob" Martin shows how to bring greater professionalism and discipline to application architecture and design. As with his other books, Martin's Clean Architecture doesn't merely present multiple choices and options, and say "use your best judgment": it tel Building upon the success of best-sellers The Clean Coder and Clean Code, legendary software craftsman Robert C. "Uncle Bob" Martin shows how to bring greater professionalism and discipline to application architecture and design. As with his other books, Martin's Clean Architecture doesn't merely present multiple choices and options, and say "use your best judgment": it tells you what choices to make, and why those choices are critical to your success. Martin offers direct, no-nonsense answers to key architecture and design questions like: What are the best high level structures for different kinds of applications, including web, database, thick-client, console, and embedded apps? What are the core principles of software architecture? What is the role of the architect, and what is he/she really trying to achieve? What are the core principles of software design? How do designs and architectures go wrong, and what can you do about it? What are the disciplines and practices of professional architects and designers? Clean Architecture is essential reading for every software architect, systems analyst, system designer, and software manager -- and for any programmer who aspires to these roles or is impacted by their work.

30 review for Clean Architecture

  1. 4 out of 5

    Rod Hilton

    I really liked this book but also was a bit disappointed by it. I'm a huge fan of Robert Martin's work, I've read his previous books and I love Clean Code and The Clean Coder. Based on the title and artwork I had kind of assumed that this was just the next step of the Clean Trilogy, this time focusing on architectural concerns. It is kind of that, but it's mostly not quite that. Really, this book is a lot of background information to understand the "meat" of the book, and the meat of the book is I really liked this book but also was a bit disappointed by it. I'm a huge fan of Robert Martin's work, I've read his previous books and I love Clean Code and The Clean Coder. Based on the title and artwork I had kind of assumed that this was just the next step of the Clean Trilogy, this time focusing on architectural concerns. It is kind of that, but it's mostly not quite that. Really, this book is a lot of background information to understand the "meat" of the book, and the meat of the book is Martin presenting his Clean Architecture pattern, which he proposed in 2012 and has been presenting and training a lot on: https://8thlight.com/blog/uncle-bob/2... In that way, this book feels much more specific than Clean Code or The Clean Coder. While those two books are general advice for software professionals, this comes off more as an extended design pattern book that only covers one singular pattern. It's presented as The Only Right Way, and while I personally agree with Martin's perspective and his loathing for framework-heavy architectures, it was a bit disappointing that the book was mostly a very deep dive on a blog post from five years ago. The "buildup" stuff is actually more interesting. It's about applying SOLID principles to architecture and I really enjoyed this section of the book, I felt like I finally grokked dependency inversion at a component level, and there's a lot to apply to architectural problems I face. That section of the book feels very general, though like most of Martin's work it's yet another rehash of SOLID and talking about FitNesse, two things he's gotten a stunning amount of mileage out of to a point where you kind of wonder if he's ever done anything else (he has, but boy does he return to these wells a lot). In a way this is two shorter books smashed together. One is Clean Architecture, a book about building clean architecture using SOLID principles (and a few new ones). The other is a book about the Clean Architecture Pattern, a particular way to architect systems that shares a lot with Allistair Cockburn's Hexagonal Architecture pattern. These two concepts use the exact same name to, I think, intentionally get readers to conflate the two concepts as one and come away feeling like Martin's proposal is the only possible way to architect a system in a way that is clean. But one of these things is "clean architecture" and the other is "Clean Architecture", and it's often hard to see what is what. This is by design, I think. In any case, the book is really good and I got a lot of out of it, though it wasn't what I was expecting really. The first half (or so) of the book feels like 80% rehash of stuff I've seen from Martin before, with 20% extremely good and useful new stuff. Then the second half of the book is a completely different topic presented as the same topic, which I enjoyed but I can see a lot of readers being turned off by. I still would recommend the book and I think it's worth reading for anyone who feels like "architecture" is part of their job.

  2. 5 out of 5

    Carlos Buenosvinos

    First of all, I’m a big fan of Robert C. Martin’s work. I think cleancoders.com (I have purchased all videos from Clean Code, Clean Coders and Clean Coders Applied series) is a great learning resource and I have read all others books (Clean Code, Clean Coders and Agile Software Development Principles, Patterns and Practices). About this book, I may had too high expectations about this book. I’m disappointed. 85% of the book is reviewing the SOLID principles and how to apply them to components (it First of all, I’m a big fan of Robert C. Martin’s work. I think cleancoders.com (I have purchased all videos from Clean Code, Clean Coders and Clean Coders Applied series) is a great learning resource and I have read all others books (Clean Code, Clean Coders and Agile Software Development Principles, Patterns and Practices). About this book, I may had too high expectations about this book. I’m disappointed. 85% of the book is reviewing the SOLID principles and how to apply them to components (it’s already explain in his videos and in more detail IMHO). The other 15% of the book is about his presentation “Architecture, the Lost Years” where he talks about Boundary-Interactor-Entity architecture. This architecture is similar to Hexagonal Architecture (Ports and Adapters), Onion, etc. In the whole book, you will see no more than 50 lines of code. The concepts of B-I-E architecture are roughly explained. There is almost no references to messaging or events. Microservices or Service Oriented Architecture are mentioned, but explanations are not satisfying. Greg Young appears in the Thank You page but no CQRS or Event Sourcing is mentioned. Mr. Martin, I love your work, but this book is not as the same level as the rest. Thanks!

  3. 4 out of 5

    Eduards Sizovs

    This is the first book of Uncle Bob that I didn't like – it's shallow, impractical, and full of stories from forgotten 90's. A significant part of the book (explanation of SOLID principles) has been copied (with few alternations) from "Agile PPP" book, which is, in my opinion, a much more thorough book. To understand modularity patterns mentioned in this book, I suggest taking alternative path – reading "Java Application Architecture" by Kirk Knoernschild. In addition to modularity and SOLID, the This is the first book of Uncle Bob that I didn't like – it's shallow, impractical, and full of stories from forgotten 90's. A significant part of the book (explanation of SOLID principles) has been copied (with few alternations) from "Agile PPP" book, which is, in my opinion, a much more thorough book. To understand modularity patterns mentioned in this book, I suggest taking alternative path – reading "Java Application Architecture" by Kirk Knoernschild. In addition to modularity and SOLID, the book tries to explain Hexagonal Architecture (a-ka Clean Architecture). Just Google it to grasp the idea and then read "Java Application Architecture". The ideas mentioned in the book has practical application and are beneficial in some contexts. The problem is that the context is not set, and drawbacks were not properly examined. The book also lacks practical examples (the case study takes only 2 pages). There a chapter that I like, though – it's a chapter written by Simon Brown (on packaging). In order to understand the idea, you can read Simon's blog post "An architecturally-evident coding style". Also, Simon wrote a great book – "Software Architecture for Developers".

  4. 5 out of 5

    Thiago Ramos

    this is really an excelent book about creating good, reusable and disconnected from infrastructure details code. If clean code was all about the code, this is about how you structure the code to make it more reusable, framewoderk independent and solid. If you think MVC and Rails or Django or Phoenix is the way to go for a web project, think again with this book. Great software does not rely on any framework. It just uses the framework when it needs.

  5. 5 out of 5

    Mohamed Elsherif

    Overall a good book, you will learn few things from it, or at least it will be a good refresher, although it is not bringing any new ideas, worth reading if you like uncle Bob.

  6. 5 out of 5

    Tomasz

    Interesting, but too long with too many not needed and off-topic anecdotes. Still worth your time, but not as insightful as previous titles from "Clean X" series.

  7. 4 out of 5

    Pavel Gatilov

    Clean Guide for an Architect The book covers different sides of the Software Architect role. The conflicting collaboration of business and technology. The crucial architect's focus topics. The architecture principles derived from the famous SOLID principles and proven by decades. Some of the common architecture mistakes. All topics of the book have bright and laconic descriptions. The are also many colorful and didactic examples to the ideas, often taken from the author's experience. And besides, Clean Guide for an Architect The book covers different sides of the Software Architect role. The conflicting collaboration of business and technology. The crucial architect's focus topics. The architecture principles derived from the famous SOLID principles and proven by decades. Some of the common architecture mistakes. All topics of the book have bright and laconic descriptions. The are also many colorful and didactic examples to the ideas, often taken from the author's experience. And besides, there is a whole appendix chapter full of autobiographical stories. I find this book great at presenting the essence of the Architect role and the core principles one should follow.

  8. 4 out of 5

    Sebastian Gebski

    Some key remarks I have: 1. Even if it may look (at some point) deceptively simple, ... it isn't. In fact, the most valuable lessons will be truly comprehensible (& clear) only for people with certain level of experience. 2. This book doesn't try to cover anything in particular in the end-to-end way, it's more about certain aspects of software architecture Uncle Bob finds most important (e.g. SOLID principles, boundaries, proper approach to composition, etc.). Needless to say - these are unive Some key remarks I have: 1. Even if it may look (at some point) deceptively simple, ... it isn't. In fact, the most valuable lessons will be truly comprehensible (& clear) only for people with certain level of experience. 2. This book doesn't try to cover anything in particular in the end-to-end way, it's more about certain aspects of software architecture Uncle Bob finds most important (e.g. SOLID principles, boundaries, proper approach to composition, etc.). Needless to say - these are universal & technology-agnostic (which is good), but they are most applicable to typical OO languages & platforms. 3. Appendix (that takes ~20%-25% of the book) is quite personal, quite impressive, but ... not really entertaining or educative. But well, it's Uncle Bob, so such things can be forgiven ;) Is it a good, valuable book for an aspiring or even experienced architect? I think so - I like its focus on principles instead of patterns & I personally think this is something we truly need to be reminded about.

  9. 5 out of 5

    Dima

    Such a sad and useless book. Let me save you time and money by summarizing the entire book in one deceitful sentence: "Use interfaces to hide implementation details." Done. Now you can go spend your $30 on something better. Like beer. Of course the best part of it all is that now there is an army of bro-coders out there thinking that they know what's up, so every single code package they check in has a useless interface per every "implementation" class. Here is a life pro-tip: if you ever stumble Such a sad and useless book. Let me save you time and money by summarizing the entire book in one deceitful sentence: "Use interfaces to hide implementation details." Done. Now you can go spend your $30 on something better. Like beer. Of course the best part of it all is that now there is an army of bro-coders out there thinking that they know what's up, so every single code package they check in has a useless interface per every "implementation" class. Here is a life pro-tip: if you ever stumble upon two files, one of them being an interface named, say, OrderService and another an implementation of that interface ending with -Impl, like OrderServiceImpl, please do everyone a favor and just merge the two. The sole fact that someone had to add -Impl to the class name means that there will never be a second implementation, so the interface they defined is useless and needs to be obliterated into the void. It's just garbage code that clutters the project structure. Maybe, just maybe, if we all follow that rule then the common sense will eventually prevail. Until then, God help us all.

  10. 5 out of 5

    Sergey Teplyakov

    The book isn't bad, but not very practical. All the principles described in the book make sense once you understand them and saw issues in practice. But what if you unfamiliar with them? What if you want to understand them? In this case, the book wouldn't help: the chapter dedicated to design/architecture principles are very short without any practical examples. Lack of examples is the main problem though. It is hard to provide good samples for a design/architecture book but without them, it is ha The book isn't bad, but not very practical. All the principles described in the book make sense once you understand them and saw issues in practice. But what if you unfamiliar with them? What if you want to understand them? In this case, the book wouldn't help: the chapter dedicated to design/architecture principles are very short without any practical examples. Lack of examples is the main problem though. It is hard to provide good samples for a design/architecture book but without them, it is hard to generalize the knowledge to your projects. The author provides a few examples with a very high-level description, but they're not very useful. It is an ok read, but only if you know everything and just want to remind yourself about design/architecture principles. But if you want to learn stuff, I don't think that the book will give you an actionable guidance for you.

  11. 4 out of 5

    Maris Krivtezs

    Many of the reviewers who rated it low misunderstood the book. I see in the reviews that they expected microservice, CQRS and other "architecture" descriptions. But this book is about something different. This is about the "clean" architecture. Yes he uses SOLID to describe architecture components, but from the different angle than talking about the code. The book also is a good read just because of the style and story. Uncle Bob always is a good storyteller. Just read and enjoy the book. Do not e Many of the reviewers who rated it low misunderstood the book. I see in the reviews that they expected microservice, CQRS and other "architecture" descriptions. But this book is about something different. This is about the "clean" architecture. Yes he uses SOLID to describe architecture components, but from the different angle than talking about the code. The book also is a good read just because of the style and story. Uncle Bob always is a good storyteller. Just read and enjoy the book. Do not expect it to describe some new architecture style. Read it as a novel.

  12. 5 out of 5

    Rodrigo Burgos

    Is a great book, I demystified some thoughts I had about software architecture - Be aware of how to architect your unit test. - How to apply SOLID principles in a web service architecture - A monolithic architect is not bad if you know the advantage and disadvantage - Use framework but not married your business logic to them

  13. 5 out of 5

    Patkós Csaba

    Interesting and very well written. If you are familiar with the SOLID principles, this book will be an easy read. Not 5 stars because it contains too little information in my opinion. I don't mean that it is a short book, not at all. However it doesn't really revolutionize your perspective on design and architecture if you are already applying SOLID in you application. In many places I had the distinct feeling that the author was talking in generic terms and just filling in the pages with non-esse Interesting and very well written. If you are familiar with the SOLID principles, this book will be an easy read. Not 5 stars because it contains too little information in my opinion. I don't mean that it is a short book, not at all. However it doesn't really revolutionize your perspective on design and architecture if you are already applying SOLID in you application. In many places I had the distinct feeling that the author was talking in generic terms and just filling in the pages with non-essential information.

  14. 5 out of 5

    Osvaldo Santana

    Amazing Book. The preface/first chapters worth the reading of this book. But I believe it could be a little bit repetitive for the readers of Uncle Bob’s previous books because he uses the SOLID principles as a tool for architecting the software the same way he proposes that principles to model software components.

  15. 5 out of 5

    Michał Kostrzewa

    Really enjoyed it, it was surprisingly easy to read. Explained all the rules and principles well. I was thinking about our production code all the time while reading it. Chapter about decoupling tests via a Test API really needs some examples. Especially because of already existing controversy about fragility of TDD etc.

  16. 4 out of 5

    Robson Castilho

    Mixed feelings about this book. On one side, it explains what software architecture is about, filled with valuable design principles (at class level and at component level). On the other side, it's a very short book, basically with a fast compilation of everything he said before. Even when he touches fresh subjects, like distributed systems (SOA/Microservices), the chapters are a little bit shallow. I've missed more code samples to clarify some concepts. Don't get me wrong: it's a very good book, Mixed feelings about this book. On one side, it explains what software architecture is about, filled with valuable design principles (at class level and at component level). On the other side, it's a very short book, basically with a fast compilation of everything he said before. Even when he touches fresh subjects, like distributed systems (SOA/Microservices), the chapters are a little bit shallow. I've missed more code samples to clarify some concepts. Don't get me wrong: it's a very good book, but read it as something like "the foundation of software architecture" (read the table of contents before so that you do not get disappointed). ps.: I'd like to see Uncle Bob writing about other - and more specific - things, such as DDD, CQRS, Event Sourcing, some cloud services and patterns, etc.

  17. 5 out of 5

    Toni Tassani

    A review of programming paradigms and SOLID, adding very little more and simplifying the concept of architecture to only software architecture/design. Chapter 34, authored by Simon Brown, is very good.

  18. 5 out of 5

    Elena

    i quit my job because of this book, 4 stars

  19. 4 out of 5

    Nick Jamil

    I think if a software engineer reads only two books in their career... first of all, shame on them :)... but second of all, those books should be 1) Clean Code, and 2) Clean Architecture.

  20. 5 out of 5

    Luboš

    If you read the book Clean Code or you just like the style of Uncle Bob writing, Clear Architecture is a right sequel for you.

  21. 4 out of 5

    Nikolay

    With one word – reasonable. There wouldn't be many people who would benefit much from it. Beginners would need a lot more context and examples, while more experienced developers wouldn't learn much new. Mixing principles with a more specific suggested architecture doesn't help either. Clean Architecture is useful to start a conversation, provoke questions, or give ideas how to explain patterns one understands on a subconscious level.

  22. 4 out of 5

    Felipe

    It's an OK book. Not a total waste of your time but it's just Uncle Bob trying to milk the SOLID cow a bit more.

  23. 5 out of 5

    Unpollito

    I'm very disappointed with this book. I had very high expectations of it after having read Uncle Bob's excellent "Clean Code" and "The Clean Coder", but after reading this, I can only feel that my money's only purpose was to help the author set up a second gold-coated swimming pool at their mansion - there was little to learn here. I would divide the book in two halves. The first of these hardly bears any relevance at all - it's mostly anecdotes and stuff that (in my opinion) doesn't really need I'm very disappointed with this book. I had very high expectations of it after having read Uncle Bob's excellent "Clean Code" and "The Clean Coder", but after reading this, I can only feel that my money's only purpose was to help the author set up a second gold-coated swimming pool at their mansion - there was little to learn here. I would divide the book in two halves. The first of these hardly bears any relevance at all - it's mostly anecdotes and stuff that (in my opinion) doesn't really need to be in a book about architecture, particularly so if you already have any knowledge of design patterns. (Seriously, why bother explaining structured, object-oriented and functional programming?) The second half is where you'd expect the meaty content to be, but at the end of the day most of it can't be summarized in a simple sentence: don't do coupling. Don't do coupling in your database, don't do coupling in your services, don't do coupling in your web frontend... and a chapter for every single place where you want to avoid coupling. To be fair, there is a couple of gems and useful pieces of information scattered across the book, but even in these cases, many of them were underexplained. Too much attention is paid to unimportant topics and too little to the points I found the most relevant. It is rather sad that the only chapter that I found useful from start to end is called "The Missing Chapter". Perhaps the name is indicative of the fact of how difficult it is to fit a single useful chapter into an otherwise mostly pointless book.

  24. 4 out of 5

    Wojtek Erbetowski

    This book was exactly what I expected it to be. I have attended several talks by Uncle Bob and read his 'Clean Code' a long time ago. I wasn't surprised by the contents, as his stand on the architecture (as it seems to me) is consistent and stable. Some of his war stories are hard to overvalue. The most important part I have read there is about SRP and how to understand it differently than it's commonly understood. I recommend the book to most software engineers, to both learn, and get a topic to d This book was exactly what I expected it to be. I have attended several talks by Uncle Bob and read his 'Clean Code' a long time ago. I wasn't surprised by the contents, as his stand on the architecture (as it seems to me) is consistent and stable. Some of his war stories are hard to overvalue. The most important part I have read there is about SRP and how to understand it differently than it's commonly understood. I recommend the book to most software engineers, to both learn, and get a topic to discuss during tech events.

  25. 4 out of 5

    Mike Moore

    I was excited to read a book by Uncle Bob that would bring the clarity and insight from Clean Code to the discipline of architecture. To say that this is not the book I had hoped for is an understatement. First the bad: this is not a book about architecture. Even if you accept a fairly constrained view of what that can mean (e.g. Architecture of a single language software application), it covers a tiny fraction of the domain. This is unsurprising once you realize how skimpy the book actually is. I was excited to read a book by Uncle Bob that would bring the clarity and insight from Clean Code to the discipline of architecture. To say that this is not the book I had hoped for is an understatement. First the bad: this is not a book about architecture. Even if you accept a fairly constrained view of what that can mean (e.g. Architecture of a single language software application), it covers a tiny fraction of the domain. This is unsurprising once you realize how skimpy the book actually is. With 2-3 pages per chapter dedicated to whitespace and chapter headings, another 2-3 pages for each section, 6 sections, 34 chapters, well under 300 pages... there may be 150 pages or so of actual content. A lot of that content is anecdotes, historical asides, and other fluff / color. Most of it is interesting, some of it is stuff that every programmer should know (and probably already does before picking up this book). More disturbing than the books lack of heft is the growing realization that Martin might not have a clear idea what architecture means. When he made the bold assertion early on that "Architecture is Design", I was more intrigued than alarmed. But by the time he claimed that all architecture must be conceived and realized from the bottom up it was impossible to see what he was saying as a coherent and unorthodox vision of architecture, rather than ideas on a related subject that he was wrongly conflating with a topic he doesn't really understand. The related subject of his ideas is dependency management, a crucial discipline for software designers, coders, and architects. Martin has a lot to say about this that is worth reading. There are the makings of an excellent 80 page article that could be titled "Dependency Management in Software Applications" in this book. If that article had been published I would recommend it wholeheartedly. Even in its current form I can recommend this book, but with the caveat that it's not what it pretends to be.

  26. 4 out of 5

    Nemantro

    This classical book doesn't need any introduction. I was eager to read since I was a student, but I'm happy I did it only recently because it is clearly written for an experienced audience. Uncle Bob gives us many advices on software architecture, some are precious, some are familiar. The three first parts are about coding per se, with many well known topics ( S.O.L.I.D principals, and object oriented for instance). They are rather short and are not better than other books addressing the same topi This classical book doesn't need any introduction. I was eager to read since I was a student, but I'm happy I did it only recently because it is clearly written for an experienced audience. Uncle Bob gives us many advices on software architecture, some are precious, some are familiar. The three first parts are about coding per se, with many well known topics ( S.O.L.I.D principals, and object oriented for instance). They are rather short and are not better than other books addressing the same topics, even if uncle Bob was one of the first to introduce them to the public. Part 4 is about components, it was the part that I found the less interesting to read. It's quite hard to understand every subtilty with so few concrete examples. Part 5 is, for me, the proper of this book, and it helped to have a clearer view on the role of the architect and how to take decision (or not) while trying to create something from scratch. The chapters 'Boundaries', 'Business rules' and 'Screaming architecture' are enjoyable and informative. Part 6 gets even better : it reminds me of 'The Pragmatic Programmer' and contain a real wisdom lacking from the minds of so many programmers, especially those attracted by the "fashionable new shiny things" in technology without any deep thinking. I didn't like though the case study and think it needed more attention and more details from the author. I don't consider this book are a must as a whole, but many chapter are worth reading. Nevertheless, it is still a great classical book to read, written by a guy who has seen it all in the software world, and whose advices come for the field experience. Quotes : --- As an example, this short paragraph where he talks about the micro services mania : "Services that simply separate application behaviors are little more than expensive function calls, and are not necessarily architecturally significant" --- And here, uncle bob warns us of the blind use of frameworks "The relationship between you and the framework author is extraordinarily asymmetric. You must make a huge commitment to the framework, but the framework author makes no commitment to you whatsoever"

  27. 4 out of 5

    Ana Todor

    This review has been hidden because it contains spoilers. To view it, click here. I loved Clean Code and I thought Clean Architecture is only the next level in becoming a better software programmer and all round full stack developer. But the book feels a lot less practical and also very shallow. It is a mix of anecdotes from the 90s, some thoughts around SOLID principles and evangelism around 'The Clean Architecture' pattern that Robert Martin himself proposed in one of his blog posts: https://blog.cleancoder.com/uncle-bob... It is a lot more one-sided and shamefully self prom I loved Clean Code and I thought Clean Architecture is only the next level in becoming a better software programmer and all round full stack developer. But the book feels a lot less practical and also very shallow. It is a mix of anecdotes from the 90s, some thoughts around SOLID principles and evangelism around 'The Clean Architecture' pattern that Robert Martin himself proposed in one of his blog posts: https://blog.cleancoder.com/uncle-bob... It is a lot more one-sided and shamefully self promoting than his other books and also seems to be focusing a lot on compiled languages in these exciting times when Python and Javascript are basically ruling the ecosystem. It does have some good pointers, which I will mention below, in case you want to skip the book altogether but still feel like you've touched on it: - respect the SOLID principles. I won't go into details because they are literally all over the internet - software systems have two main components: policy and details. Delay decisions related to details for as long as possible - UI is a detail - the database is a detail - the web is a detail - frameworks are details - separate core policy from details by enforcing software boundaries. Partial boundaries are sometimes better than full boundaries, since full boundaries are expensive to implement. A good architect identifies the sweet spot when boundaries should be fully implemented by continuously weighing risks and costs. - no matter how noble the design intentions, implementation strategy also matters. Finds way to enforce the chosen architectural styles in your team, using automatic verification if necessary

  28. 5 out of 5

    Igor Celik

    The book starts from the premise that design and architecture are the same, thus every decision you take from lower to the highest levels are a continuum of architectural decisions. The book introduces you to the principles by which all of the these architectural decision should be taken - from classes(SOLID) to components(CCP,SDP,REP) and then to higher level architecture (layers). It explains which elements of the software are architecture and which are mere details. This book is not about specif The book starts from the premise that design and architecture are the same, thus every decision you take from lower to the highest levels are a continuum of architectural decisions. The book introduces you to the principles by which all of the these architectural decision should be taken - from classes(SOLID) to components(CCP,SDP,REP) and then to higher level architecture (layers). It explains which elements of the software are architecture and which are mere details. This book is not about specific architectural patterns although it does mention and briefly explains the idea behind some - like Event sourcing, Microservices, CQRS but rather is about guidelines/metrics/principals to help take a decisions which will lead towards a clean architecture, be it for the enterprise or for mid sized project. For me this book was a page turner and kept Uncle Bob spirit/personality. If you already watched Uncle Bob excellent Clean Code series on CleanCoders, than a portion of this books content will sound very familiar, this book presents in more concise way the SOLID Principles and the Component design from the series and connects some dots in his autobiography, and if like me, you wanted some written guide at hand to which you can refer to, then this book is also a perfect source.

  29. 4 out of 5

    Ruslan Bes

    It's surprising that the whole book is by and large describing only one principle over and over. You would think it ought to be boring but it's not. I would formulate that principle as "Define architectural boundaries and hide details behind them". It sounds simple but really using this principle requires a lot of experience and patience and willpower to say "no" to shortcuts and many other things. Even more interesting is that many developers after some time come to this principle after realizing It's surprising that the whole book is by and large describing only one principle over and over. You would think it ought to be boring but it's not. I would formulate that principle as "Define architectural boundaries and hide details behind them". It sounds simple but really using this principle requires a lot of experience and patience and willpower to say "no" to shortcuts and many other things. Even more interesting is that many developers after some time come to this principle after realizing what was wrong with code they have written a year ago. Okay but if it's so simple and experience-based, then why read this book? Well, for me it was to finally realize the mistakes I made in my former projects and to confirm the ideas I came to. That's why I think it's worth reading for an experienced Software Engineer. It's even more important to read it if you had no real production experience and were not spoiled by writing dirty hacks to meet strict deadlines. I'm certain it will help you to enjoy building big software projects and not being scared of them. One more reason to read this book is its Appendix A with real-life stories from the author. I won't spoil it for you but it's quite fun to read. All in all a must read for a Software Engineer

  30. 4 out of 5

    Szymon

    I have to say after 'Clean Code' and 'Clean Coder' (which both stay on the top of my favourite-technical-books list) I am a bit disappointed with 'Clean Architecture'. Reviewing SOLID principles was clear and easy to follow but not sure if really needed. The 'back in my days' stories are fine from time to time but in 'Clean Architecture' (especially after reading the other two books first) this stuff just gets in the way. I enjoyed the deep explanation of the boundaries and the overall idea of ho I have to say after 'Clean Code' and 'Clean Coder' (which both stay on the top of my favourite-technical-books list) I am a bit disappointed with 'Clean Architecture'. Reviewing SOLID principles was clear and easy to follow but not sure if really needed. The 'back in my days' stories are fine from time to time but in 'Clean Architecture' (especially after reading the other two books first) this stuff just gets in the way. I enjoyed the deep explanation of the boundaries and the overall idea of how the logic should be separated from the details, which really puts things into perspective (web is a detail, the database is a detail). "Don't rely on the framework" part obviously got me as I'm working with Rails every day. Maybe I just had too high expectations from that book but I really think it's not on the same level as the other two. I was also hoping the book released not that long ago might contain some insights about coding with having the available cloud solutions in mind - not a chance though.

Add a review

Your email address will not be published. Required fields are marked *

Loading...
We use cookies to give you the best online experience. By using our website you agree to our use of cookies in accordance with our cookie policy.