Jump to ratings and reviews
Rate this book

Get Your Hands Dirty on Clean Architecture

Rate this book
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

Loading interface...
Loading interface...

About the author

Tom Hombergs

2 books23 followers

Ratings & Reviews

What do you think?
Rate this book

Friends & Following

Create a free account to discover what your friends think of this book!

Community Reviews

5 stars
115 (56%)
4 stars
76 (37%)
3 stars
9 (4%)
2 stars
2 (<1%)
1 star
0 (0%)
Displaying 1 - 30 of 30 reviews
Profile Image for Regis Hattori.
118 reviews8 followers
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.

Profile Image for Jevgenij.
419 reviews6 followers
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
Profile Image for Ahmed Abouzied.
9 reviews2 followers
January 20, 2020
The 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.
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.

Profile Image for Ionut Penciuc.
8 reviews1 follower
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.).
This entire review has been hidden because of spoilers.
Profile Image for Antony.
148 reviews
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.
Profile Image for Laust.
8 reviews
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.
6 reviews
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.
Profile Image for Roman Mkrtchian.
11 reviews
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.
Profile Image for Sergey Machulskis.
65 reviews4 followers
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.
Author 2 books3 followers
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.
Profile Image for Vasya Rudas.
11 reviews
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.
11 reviews1 follower
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.
2 reviews
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.
Profile Image for Vladimir Ananiev.
20 reviews2 followers
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.
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.
3 reviews1 follower
May 3, 2020
Excellent read, great and clear introduction to Hexagonal Architecture, covering all the key concepts and more.
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.
Profile Image for Sebastian Godoy.
37 reviews2 followers
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.
10 reviews
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.
Profile Image for Hatem.
15 reviews1 follower
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

Can't find what you're looking for?

Get help and learn more about the design.