What do you think?
Rate this book
Get Your Hands Dirty on Clean Architecture
Gain insight into how hexagonal architecture can help to keep the cost of development low over the complete lifetime of an application We would all like to build software architecture that yields adaptable and flexible software with low development costs. But, unreasonable deadlines and shortcuts make it very hard to create such an architecture. Get Your Hands Dirty on Clean Architecture starts with a discussion about the conventional layered architecture style and its disadvantages. It also talks about the advantages of the domain-centric architecture styles of Robert C. Martin's Clean Architecture and Alistair Cockburn's Hexagonal Architecture. Then, the book dives into hands-on chapters that show you how to manifest a hexagonal architecture in actual code. You'll learn in detail about different mapping strategies between the layers of a hexagonal architecture and see how to assemble the architecture elements into an application. The later chapters demonstrate how to enforce architecture boundaries. You'll also learn what shortcuts produce what types of technical debt and how, sometimes, it is a good idea to willingly take on those debts. After reading this book, you'll have all the knowledge you need to create applications using the hexagonal architecture style of web development. This book is for you if you care about the architecture of the software you are building. To get the most out of this book, you must have some experience with web development. The code examples in this book are in Java. If you are not a Java programmer but can read object-oriented code in other languages, you will be fine. In the few places where Java or framework specifics are needed, they are thoroughly explained.
108 pages, ebook
Published August 18, 2019
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 30 reviews
July 17, 2020
I have read just a few chapters of Uncle Bob Clean Architecture book and I thought it was too abstract.
I think this book has a good equilibrium between theory and practice although it could be more practical since it is supposed to be a "hands-on guide".
It is very short and condensed a lot of concepts in a few words so I think it worths the reading.
I think this book has a good equilibrium between theory and practice although it could be more practical since it is supposed to be a "hands-on guide".
It is very short and condensed a lot of concepts in a few words so I think it worths the reading.
March 10, 2020
A very good book. Interestingly, the original Clean Architecture book is rather weak, but this one fixes all its flaws: it's short, very clear, well structured, with good explanations and examples. I guess at times it advocates a bit too much overengineering, but still, lots and lots of valuable ideas here.
January 3, 2021
It's a well written book. It's obvious that Tom has done his best to bring the abstract concepts of clean architecture to the ground and show how they will look like when actually implemented and how practically useful they can be. And that's exactly where my problem begins. My issue actually is not so much with the book itself but rather with the over hyped concept of hexagonal architecture. In fact reading a book like this made it clear for me that giving up familiarity and simplicity of organising the code in layered architecture in favour of verbose ports and adapters alternatives is not really worth it. The retracted one star is because, in my opinion, this point has been overlooked meaning the "problems" with layered architecture and the solutions that clean architecture provides are overstated. Ironically this point wouldn't be so obvious if the book was written in a vague and abstract fashion like the other books out there.
March 8, 2023
Have you ever wondered how to read legacy code less, avoid changing the code you wrote in the past, write new code quickly, and architect it differently than ordinary layered or onion architectures?
Book fills the void and provides a clear glance at the hexagonal architecture, well known for the ports and adapters concept. The author describes how to externalise the implementation details to the edges of the architecture and make it possible to evolve your programs in parallel with multiple programmers.
Chapters are structured well, written understandably and accompanied by a GitHub repository with a simple but remarkable example of a payments app where business logic dependencies can be easily substituted and managed by bigger teams than usual. In the end, welcome to the author's blog available on reflectoring.io
Book fills the void and provides a clear glance at the hexagonal architecture, well known for the ports and adapters concept. The author describes how to externalise the implementation details to the edges of the architecture and make it possible to evolve your programs in parallel with multiple programmers.
Chapters are structured well, written understandably and accompanied by a GitHub repository with a simple but remarkable example of a payments app where business logic dependencies can be easily substituted and managed by bigger teams than usual. In the end, welcome to the author's blog available on reflectoring.io
Read
January 20, 2020The author has an excellent git repository hosted on Github that has the source code of the project through which this book tries to illustrate the idea behind hexagonal architecture. I found that going in detail through this Github repository has helped me to understand how to implement a Spring boot application through hexagonal architecture.
The book however was not that good. The code samples are not well organized and rather confusing. And the arguments about architecture decisions were good but not very deep. They felt like good blogs or articles but not as deep as I expect a book on architecture would go.
The book however was not that good. The code samples are not well organized and rather confusing. And the arguments about architecture decisions were good but not very deep. They felt like good blogs or articles but not as deep as I expect a book on architecture would go.
January 3, 2021
As developers, we organize our application code in classes and packages/modules.
There are several ways to compose the code. A popular approach is the "three-tiered" architecture where the logic is divided in presentation, business and data layers.
See link #1.
Alternative architectures are the "hexagonal" or "port-adapters" (see link #2) and R. Martin's Clean Architecture (link #3).
There are books which explain the architectures benefits and downsides. Among them, I suggest R. Martin's "Clean Architecture" book.
On the other hand, Tom Hombergs' book complements these theoretical books showing how to implement the architectures using significant examples in Java.
The author explains:
- how to organize code in packages
- how to interface the logic between different application layers
- how to pass and map data object through layers
All examples are clear and well documented.
I've personally found quite useful the explanation of the possible data mapping strategies.
I highly suggest Tom Hombergs' "Get your hands dirty on clean architecture" book.
Links:
https://en.wikipedia.org/wiki/Multiti...
https://en.wikipedia.org/wiki/Hexagon...
https://blog.cleancoder.com/uncle-bob...
There are several ways to compose the code. A popular approach is the "three-tiered" architecture where the logic is divided in presentation, business and data layers.
See link #1.
Alternative architectures are the "hexagonal" or "port-adapters" (see link #2) and R. Martin's Clean Architecture (link #3).
There are books which explain the architectures benefits and downsides. Among them, I suggest R. Martin's "Clean Architecture" book.
On the other hand, Tom Hombergs' book complements these theoretical books showing how to implement the architectures using significant examples in Java.
The author explains:
- how to organize code in packages
- how to interface the logic between different application layers
- how to pass and map data object through layers
All examples are clear and well documented.
I've personally found quite useful the explanation of the possible data mapping strategies.
I highly suggest Tom Hombergs' "Get your hands dirty on clean architecture" book.
Links:
https://en.wikipedia.org/wiki/Multiti...
https://en.wikipedia.org/wiki/Hexagon...
https://blog.cleancoder.com/uncle-bob...
March 21, 2022
Much too shallow for an architecture book.
The only thing I liked was that it provided a nice practical overview for the Hexagonal Architecture approach (the overall design, the separation of concerns, the usage of dedicated models, etc.). But this could’ve also been a blog post.
The other aspects are presented very lightly and in a subjective manner.
I also found some of the “advice” as not being very practical (e.g. the usage of long constructors instead of input builders, the great focus on the whole Spring framework usage, the writing of the tests with a “dynamic” expected value instead of an explicit one, etc.).
The only thing I liked was that it provided a nice practical overview for the Hexagonal Architecture approach (the overall design, the separation of concerns, the usage of dedicated models, etc.). But this could’ve also been a blog post.
The other aspects are presented very lightly and in a subjective manner.
I also found some of the “advice” as not being very practical (e.g. the usage of long constructors instead of input builders, the great focus on the whole Spring framework usage, the writing of the tests with a “dynamic” expected value instead of an explicit one, etc.).
This entire review has been hidden because of spoilers.
November 22, 2019
Really enjoyed this. There are so many books on the theory of software architecture and so few on the practice. This was nice and detailed, practical and (other books on software architecture take note) with code examples! This book covers hexagonal architecture, which isn't hexagonal at all as it turns out, aka Uncle Bob's clean architecture, in some depth.
November 7, 2019
A quick read, with good focused examples and lots of pros and cons described. A very useful info-dump if you are having trouble keeping a layered architecture clean.
December 10, 2022
This book is an introductory text on hexagonal architecture. I found it to be a very enjoyable read and one that really resonated with me as it directly addresses many of my pain points dealing with an existing codebase, such as the difficulty to test items in isolation, or to figure out the different code paths in it.
The author does an excellent job at keeping it concise and juicy, conveying the right amount of information so that every bit of the book is interesting and useful, without becoming overwhelming. It also contains enough UML and code samples to illustrate the points being made and help everything click together - a welcome contrast to other books, such as Uncle Bob's "Clean Architecture", which feel really abstract and disconnected in comparison.
The only caveat that I would point out is that this book is not meant to be a bible on the topic of hexagonal architecture - as I mentioned above, it's an introductory text. Therefore, if you are knowledgeable in the topic and want to dive into deeper nuances, it may be too shallow for you. However, for me, as a newcomer to this architectural style, it was absolutely on point.
The author does an excellent job at keeping it concise and juicy, conveying the right amount of information so that every bit of the book is interesting and useful, without becoming overwhelming. It also contains enough UML and code samples to illustrate the points being made and help everything click together - a welcome contrast to other books, such as Uncle Bob's "Clean Architecture", which feel really abstract and disconnected in comparison.
The only caveat that I would point out is that this book is not meant to be a bible on the topic of hexagonal architecture - as I mentioned above, it's an introductory text. Therefore, if you are knowledgeable in the topic and want to dive into deeper nuances, it may be too shallow for you. However, for me, as a newcomer to this architectural style, it was absolutely on point.
December 18, 2022
This book explains the main challenges and trade offs of hexagonal architecture in only 100 pages, which is really nice and useful for many people I think.
It's good material to learn that architecture with your team if you're used to layered architectures only. My advice is to read it collectively little by little, practicing what is described inside in mob programming.
There is some Java related content, but really not that much.
The chapter about tests is maybe the one a bit controversial, as it presents 5 test sets, with 2 of them being communication-based tests, testing that the next layer's functions have been called with the correct arguments.
If I refer to the definition given in Vladimir Khorikov's Unit Testing book, the author's vision is close to the London school of testing.
It's good material to learn that architecture with your team if you're used to layered architectures only. My advice is to read it collectively little by little, practicing what is described inside in mob programming.
There is some Java related content, but really not that much.
The chapter about tests is maybe the one a bit controversial, as it presents 5 test sets, with 2 of them being communication-based tests, testing that the next layer's functions have been called with the correct arguments.
If I refer to the definition given in Vladimir Khorikov's Unit Testing book, the author's vision is close to the London school of testing.
June 12, 2021
Much better than Martin's book because it's actually usable. The book should be the basis of the "Software architecture 101" course.
There's a lot of bullshit on the interplay between DI frameworks like Spring and application architecture. Most of the bullshit lives in legacy proprietary code, but some part of it goes to the Internet in form of incompetent posts (see top answers on Spring on stackowerflow.com, or popular blogs on it). It's sad to see such incompetence, but this book is a diamond in the rough. It's very straight and explains how to use the tool properly.
The most enjoyable chapter for me was a chapter about mapping between layers.
There's a lot of bullshit on the interplay between DI frameworks like Spring and application architecture. Most of the bullshit lives in legacy proprietary code, but some part of it goes to the Internet in form of incompetent posts (see top answers on Spring on stackowerflow.com, or popular blogs on it). It's sad to see such incompetence, but this book is a diamond in the rough. It's very straight and explains how to use the tool properly.
The most enjoyable chapter for me was a chapter about mapping between layers.
August 2, 2021
Using layers, often with packages reflecting those layers (controllers, daos, services) is the default for many projects.
This short but well written book will show you with very concrete examples how to structure your application differently, using hexagonal architecture, putting your domain logic in the centre.
Hexagonal architecture might not be the right fit for every team and project but even if you can't or don't want to use it this book will have valuable suggestions on how to model or structure applications.
This short but well written book will show you with very concrete examples how to structure your application differently, using hexagonal architecture, putting your domain logic in the centre.
Hexagonal architecture might not be the right fit for every team and project but even if you can't or don't want to use it this book will have valuable suggestions on how to model or structure applications.
March 6, 2023
From my perspective this is a most valuable book in my career as a Software Engineer and a Tech Lead. The practical recommendations of how to implement a Clean Architecture by Robert Martin in a Hexagonal aka Ports and Adapters approach is worth reading. Also author provide compromises and benefits how each approach can help to keep architecture clean or otherwise provide redundant complexity during development. So developer must make a right decision of which approach they should use in a concrete situation.
September 22, 2020
A perfect technical book in every aspect. Tom is able to explain a complicated topic like hexagonal architecture in terms that any experienced developer can understand. He provides a clear opinionated approach how to implement this arhitectual style in a spring application. The most important part of each chapter are his arguments how a decision makes your software better.
I recommend it to every developer and arhitect that cares about beautiful and maintainable software.
I recommend it to every developer and arhitect that cares about beautiful and maintainable software.
May 21, 2021
The perfect companion to Clean Architecture. This book gets down to the details of how one could implement a clean architecture without being too constraining on which methodology to use (e.g DDD).
The text is easy to pickup and the book is overall very pedagogical.
Clean Architecture by Robert C. Martin is not strictly a prerequisite but I think it would be a mistake not to read both.
The text is easy to pickup and the book is overall very pedagogical.
Clean Architecture by Robert C. Martin is not strictly a prerequisite but I think it would be a mistake not to read both.
October 9, 2021
Great introduction to Clean (Hexagonal) Architecture. Short enough to read in a single sitting, with enough detail and examples to get me thinking and wanting to learn more.
Especially liked he chapters about mappings between boundaries and taking shortcuts consciously.
Especially liked he chapters about mappings between boundaries and taking shortcuts consciously.
November 8, 2022
One of the simplest and easiest books yet full of information, I like how the author approached the idea of hexagonal architecture from code first till the deployment part! the book is really insightful and good for almost all levels SWE.
May 21, 2023
Tom does a much better job explaining Clean Architecture than Robert C Martin did in Clean Architecture.
May 3, 2020
Excellent read, great and clear introduction to Hexagonal Architecture, covering all the key concepts and more.
August 6, 2020
Precise and to the point.
August 20, 2020
Very nice book! Awesome...
September 8, 2020
Amazing book
September 18, 2020
Perfect. Concise. Quick to read and a great reference.
The code examples are great to land all the ideas and concepts from the Clean Architecture, Bob Martin’s book.
The code examples are great to land all the ideas and concepts from the Clean Architecture, Bob Martin’s book.
October 23, 2020
A good intro to hexagonal architecture.
December 17, 2021
Great book! Very insightful
March 10, 2022
Awesome book on hexagonal architecture!, it uses java through the book but the concepts and the examples can be applied in any language where you can program with OOP.
August 17, 2022
Wow, what a great book! Short and to the point.
February 19, 2023
I really enjoyed the book and definitely learned something about hexagonal architecture. I would love to read longer version with more code examples.
August 24, 2020
Amazing book for someone like me with mostly frontend experience. I read the book and got up and running with a production microservice written in Java in a matter of days. The hexagonal architecture is one of the most "clean" and readable approaches to system design I've encountered so far.
Displaying 1 - 30 of 30 reviews