Domain-driven design (DDD) was originally introduced by Eric Evans in his 2004 book [1]. Currently, Evans is with Domain Language, Inc., a consulting group that specializes in applied DDD. I mention Evans because he wrote the foreword of the book being reviewed here. According to the cover of this book, the author, Vaughn, is an experienced international DDD consultant.

To get an understanding of DDD, we need to review the topic of domain analysis (DA). Developed in the 1980s, DA is a term coined by James Neighbors to refer to the process of analyzing software systems in a particular domain to identify their common elements. DA is the first phase of domain engineering for systematic software development based on reuse. When models are used for implementing the software architecture (such as with unified modeling language or entity-relationship diagramming), the DA process amounts to a type of model-driven engineering. A systematic improvement to these previous methods culminated in the development of DDD. In other words, one can say that DDD is domain analysis on steroids.

The book is relatively complete, sparing the reader from having to research the vast history of the subject. The author’s preface is wonderful. He reviews all 14 chapters and the appendix with a bird’s eye view, to provide context for the book. In the preface, he also talks about his reasoning for using Java rather than C# and selecting development tools. There is also a very cute and informative guide to using the book. The author introduces the key concepts of DDD in the first three chapters: “Getting Started with DDD,” “Domains, Subdomains, and Bounded Contexts,” and “Context Maps.” Combined with the author’s preface, these three chapters make up 112 pages of the book, and provide a reasonably detailed foundation for the rest of the material.

The bulk of the book runs from page 113 to page 538. Chapter 4 examines the use of DDD in various architectures. Chapter 5 introduces the first tactical pattern of DDD, called entities. Chapter 6 is on value objects. Chapter 7, “Services,” discusses when to introduce a service rather than provide an entity or value object. Chapter 8, “Domain Events,” is a critical part of this book. (Domain events were not discussed in Evans’ 2004 book.) Chapter 9 is on modules and chapter 10 is on aggregates. The author spends considerable space clearly explaining the role of aggregates in DDD as a tactical tool. Chapters 11 and 12 are on factories and repositories, respectively. Chapter 13, “Integrating Bounded Contexts,” is another critical chapter, exploring different ways to implement model integrations using context mapping. Chapter 14 discusses applications and various related considerations that have not been explicitly addressed up to this point. The author closes the book with a detailed index and an appendix on “Aggregates and Event Sourcing.”

In conclusion, I tried hard to find some fault in this book, without success. One should know, however, that it is not just for reading. It is a serious practical book on DDD. One can learn a lot about DDD from it, provided the necessary time is spent on the examples.

More reviews about this item: Amazon, BCS, GoodReads