The first thing that strikes me about Eric Evans “Domain-Driven Design: Tackling Complexity in the Heart of Software” is how it seems to bring together the ideas that have resounded the best with me during the last few years. The central thesis of the book is that that enterprise software should to be built around the model that (non-software) experts in the field has of the problem domain. The shared understanding between the software developers and the domain experts and users facilitates communication. And also: In many domains, there are advanced models that have stood the test of time (for example double-entry bookkeeping). Reinventing such models is not the best thing software developers could spend their time doing.
The model driven design effort is based around the shared discovery of a ubiquitous language that is shared by the development team and the customers.
The part of the book that was most useful to me was Part III: Refactoring Toward Deeper Insight. Unique in the books I have read about modeling, Evans claims that a model that does not evolve is dead (or at least fossilized), and is a sign of failure for the project to be useful. This is in congruence with Robert Glass’s observation in “Facts and Fallacies of Software Engineering”: The most valuable programs are changed, as the users discover new needs. Evans describes how to keep a design supple by strategies that build on and extend the recommendations of Extreme Programming.
I only have two practical problems with the Domain-Driven Design approach.
- The software development projects I have been involved with lately has used technology that constains the design. The technologies are also so technically challenging that the development team don’t have the time to focus on the domain model.
- No software project is an island. Practicing domain driven design is hard in the face of legacy systems that the team must maintain or integrate with.
Evans addresses both of these topics, but I feel only the last is answered to my satisfaction.
The question of domain-driven design with the current technological trends is an interesting one. I feel a lot of vendors (but not all) are trying to sell technology that constrains the design further. The worst example IMHO is Enterprise JavaBeans. This is an example of a framework that is invasive, inflexible, and constraining. However, from the open-source scene, the current trend seems to be more in congruence with domain-driven design. IoC/Dependency Injection, AOP, and Naked-Objects are my favorite examples of paradigms where the goal of the frameworks is to get the technology out of the hair of the development team. “Domain-Driven Development” spells out the argument for such tools, even though Evans does not address this aspect directly.
I think this is the only failing of “Domain-Driven Development” as a book. Evans explains in detail a host of useful techniques for working in a domain-driven world. I feel the ideas are important enough to warrant more of a manifesto-like book. The book is great for implementing Domain-Driven Design once you have sold management and the team on the idea. There is a need for something something shorter and more persuasive as an introduction to the subject. Subjects like technology interaction with the domain-driven design should be explored further.
All in all, this book is not for everyone. I feel domain-driven development as a focus for developing software in the future is an essensial paradigm. However, Evans goes into too much details on the techniques, and the book ends up being a heavy read for anyone who just want to get an idea of what domain-driven development is about.
Copyright © 2004 Johannes Brodwall. All Rights Reserved.