Implementing Domain-Driven Design

Must-read position for everyone who want to learn DDD from practical use cases. It also emphasize non-technical aspects of DDD which are also really important. Examples are written in Java, but it is no problem to understand it without knowledge of Java. There is also very useful index, it contains all important concepts with pages where they're explained (really useful when you need to find some information after reading the entire book). I would also recommend to read Domain-Driven Design Distilled (also by Vernon) before to have some basic background.

Lives up to the hype. Fantastic resource for helping you write a backend that's manageable, easy(er) to reason about, testable, extensible, and maintainable.

DDD is definitely not getting the amount of attention it deserves. If you're new to DDD and thinking of reading a book that will introduce you DDD concepts, this is the right choice. It takes out the best from Evan's classic "Domain Driven Design" and mixes in some modern concepts and advices for pragmatic DDD or overall architecture. This book explains DDD concepts on well-chosen domain problem - agile and SCRUM. Reader (who is very likely to have at least some experience with SCRUM) is going to feel comfortable with most of the examples that this book provides. Another huge plus is that author stays pragmatic. Author knows that DDD touches lot of 'theoretical' concepts, so he often mentions real-world situations and advises how to compromise certain situations - how can be DDD fully or not-so-fully utilised within your business. If you're afraid of 'too many abstractions' then don't be - peek into table of contents and you will see that author explains DDD on very real and quite recent technologies/buzzwords like REST, CQCS, Hexagonal Architecture etc. Author also assumes that reader is rather new to the whole DDD thing and patiently explains things you were 'afraid to ask', like "What's the difference between DAO and Repository?", "Is it OK to put fine-grained queries to DAO and return Value Objects?" etc. On the other hand - what's not so great about this book is its verbosity. I don't mind repeating important concepts (redundancy can be useful as we know it from Head First books for example), but I often felt like reading a novel. If I wanted to read a novel, I would buy a novel. Technical books should be brief and precise. I had the feeling that it was happening too often that author went too deep into the problem and I simply got bored way too many times. I think the useful content of this book would comfortably fit into 60% of its length. Last, but not least, I'd like to exalt the book structure and formatting which was really good. Even Kindle versions gets properly formatted source code, which (unfortunately) still isn't standard.

This book is a much easier read than the seminal book Domain-Driven Design by Evans. The book is organized around the same concepts but the important ideas are presented up front and center. The domain examples are more down to earth and easier to follow. I find the topic of DDD invaluable for any one taking the step to software engineering of complex systems. The language and concepts presented are a 'must-learn' for all developers. This book should probably be read first before Evans book. You will enjoy the style and organization presented by the author.

Most of the reviewers have it covered here. I just wanted to add that readers will get insight not just to strategic and tactical techniques in DDD, but also a taste of system architectures such as hexagonal and cqrs/event sourcing. Rinat did a great job in the appendix. I hope this book will help to move DDD back into common practice where it belongs. My thought is with the advent of simpler persistent stores (like NoSQL, EventStore, cloud etc) developers can afford to spend more time in the domain and drop things like relational databases and ORMs when they are not needed.

I have trouble balancing my appreciation for the conceptual material in this book with my dislike of the presentation and language. There's enough good material in the book for me to convince myself I needed to plow through it to the end; the writing was such that I had to force myself to do it. I'd really like to read a copy of this that had had the benefit of a good editor. It was verbose, and tended to belabor points that I thought had been pretty clearly conveyed in a few pages, so it took a while to get through it. It's a fairly thorough overview of the DDD space, and I think it filled in some things I didn't get from Evans earlier book. I do question some of the breezy assertions that it was almost always best to opt for the purety of the model over implementation concerns, particularly around doing implementations on top of RDBMS persistence. I think it was worth the read, but in comparison to other technical books I've read (and I read a lot of them), it was a lot more work to get through the prose than I think it needed to be.

This book offers a great paradigm shift in how you design your services. The most important take away for is to think harder about your design approach. It's been very useful while creating new enterprise applications and understanding existing ones. I highly recommend it.

Although this is an important topic, the explanations are confusing. The author seems to be a fan of Martin Fowler as I am too--and I wish he had written as well as Martin Fowler has in his books on Analysis Patterns and Refactoring. Although the example worked through the book is a good one, there is too much chaff devoted to it. Nevertheless, there is a lot of important information here. It's too bad that it puts such a burden on the reader to glean the good stuff from the chaff.

Excelente Libro

Per iniziare è doverosa una premessa: il libro * NON * si chiama BEGINNING Domain Driven Design, INTRODUCING Domain Driven Design, UNDERSTANDING Domain Driven Design o simili. Questo libro è IMPLEMENTING Domain Driven Design. Contrariamente a quanto riportato nella descrizione dei contenuti, questo libro non è assolutamente adatto a chi si avvicina per la prima volta al mondo DDD o è un principiante. Per affrontare e comprendere gli argomenti trattati occorre conoscere approfonditamente i seguenti concetti (metto tra parentesi quelli che secondo me possono essere delle pubblicazioni adatte a colmare eventuali lacune) - I principali design pattern, i principi SOLID ecc. (Head First Design Pattern) - In cosa consiste il DDD, i principi di base, la nomenclatura, le architetture (Domain Driven Design di Eric Evans - l'inventore del DDD) - Le principali architetture enterprise: CQRS, Event Sourcing ecc. (Microsoft .NET: Architecting Applications for the Enterprise - SECOND EDITION) Se siete dei principianti o non conoscete uno o più degli argomenti sopra descritti, STATE LONTANI DA QUESTO LIBRO: vi causerà un'enorme confusione dovuta a spiegazioni poco comprensibili scritte con stile prolisso, con una montagna di concetti dati per scontati e in un inglese non proprio basico. Se invece siete programmatori o architetti con esperienza nel settore, qui troverete delle preziosissime informazioni su COME gestire progetti complessi usando le tecniche e le architetture DDD, evitando gli errori più comuni e scegliendo la strada più adatta per ogni situazione. La terminologia e i concetti descritti sono riportati con estremo rigore, dipanando ogni possibile dubbio sugli argomenti trattati. Se quindi siete già ferrati sull'universo DDD, questo libro si dimostrerà preziosissimo e completerà al 100% la vostra conoscenza sull'argomento. In caso contrario, prima di affrontarne la lettura vi consiglio di approfondire gli argomenti propedeutici, pena una estrema frustrazione.

This book is gold for everyone involved with architecture and code design that is supposed to be business driven. The book nicely not only covers "DDD Lite", so the pure usage of the tactical patterns but from my perspective even more importantly the strategic side of things. Domains, subdomains, ubiquitous language, context maps and the like share light onto your IT landscape and will even point out foggy areas. If you struggled in the past to justify with business why a certain project needs to be done, after that book you will be able to. If you really want to make your architecture robust, scalable and understandable you will need to work with the business, use ubiquitous languages with your areas of expertise and think in subdomains. How that is going to work alongside with how you finally implement things Vaughn explains in an non-academic way when possible. For me as a non-native english reader it is quite beneficial that he points out things from different view points and uses an additional sentence to explain concepts here and there. The first chapters are the most important for me as DDD really only works when you achieve a DDD mindset. That is costly for a company as there will be an overhead for IT to go the DDD route first but Vaughn also clearly explains the business value. You will understand when it makes sense to buy new technology rather to build it yourself and when to clearly focus on what you need to build. Last but not least, as the "implementing" part of the book's title promises, yes there are code examples and nicely explained. There is even a full implementation of his example on github. Powerful book. A paradigm change if you allow it to be that can open up a new world of how you think about architecture, development and your business.

You have very few books which gives better clarity on DDD, this book is one of them. Worth the time.

Shows by scenarios how to applying DDD and clarifies its meanings in practical situation and how to applying DDD to code. Stays alignment with the DDD community. Explains about Domains, Subdomains, and Bounded Contexts, how to draw a context map, some layers architectures (Hexagonal, SO, REST, CQRS, Event-Driven, Data-fabric), Entities, Objects Values, Application Services and infrastructure, Events, Modules, Agregates, Factories, Repositories, Integrating Contexts, and ends with Agregates and Event Sourcing.