Customer Reviews

Applying Domain-Driven Design and Patterns: With Examples in C# and .NET

5 star:		(7)
4 star:		(9)
3 star:		(2)
2 star:		(4)
1 star:		(0)

 

 

I was surprised that this book slipped under my radar for almost 3 months. I've been on the lookout for just such a unifying tome of knowledge that relates patterns and domain-driven design (DDD) to a practical .NET example for quite some while. The book delivers well on its promises, significantly surpassing the only other real competitor, Foundations of Object-Oriented Programming Using .NET 2.0 Patterns. The pros and cons, as I see them, are outlined below:

PROS

* Combines the ideas of Domain Driven Design (Evans) with Patterns of Enterprise Application Architecture (Fowler). These books are pretty much mandatory reading prior to diving into this book.
* Draws upon a myriad of other well-known sources, including materials from Refactoring to Patterns and the GoF, work from Johnson and Lowy, as well as a rare reference to Naked Objects. The more experienced and better read you are, the more this stuff will make sense.
* Rare .NET coverage of advanced concepts like Plain Old CLR Objects (POCOs), persistence ignorant (PI) objects, O/R mapping with NHibernate, Dependency Injection, Inversion of Control, and Aspect-Oriented Programming.

CONS

* While some sections are really insightful and could contain more interesting materials, other sections seem to drone on too long. The work on defining the NUnit tests, in particular, flows like a stream of consciousness and doesn't really add a lot of structured value to understanding DDD, patters, or TDD for that matter.
* Embedded comments in the text adopt from the style used in Framework Design Guidelines. It worked very well for Cwalina / Abrams in their book because it seemed planned in from the outset. Comments like "one reviewer commented on the code with the following, more succinct version" seem like editorial comments left in and not collaborative authoring by design.

All-in-all a very solid book that fills a unique market niche, leaving it pretty much without peers. If Amazon had a 4.5 starts rating, Applying DDD would get it. As a secondary reference book, it doesn't offer the earth shattering insights of some of the innovative source materials found in the Fowler Signature Series, for example. It does, however, weave together an interesting example of how to tie all of these concepts together for the .NET architect looking to take their understanding to the next level.

I was expecting this book for a looong time. For those who are new to DDD and want to be a good practitioner, I think this is a must read. The reason is not only that there are not many books in this topic (check out Eric Evan's DDD book if you haven't done so) but also there are not many "down-to-earth" books available. In this book you will find many "real world" examples where the author discusses the pros and cons. I like the books that discuss the trade-offs instead of the ones that try to give `universal" answers; as "it depends" is usually the answer to most of the questions in software development.

Apart from DDD, if you are also new to TDD, PEAA (Patterns of Enterprise Application Architecture by Martin Fowler, another great book), O/RM (NHibernate to be specific), Mocking frameworks (NMock to be specific), SOA, AOP etc you will find introductory level information in the book which is just enough to get started. With this book the link between the PEAA and DDD is clearer than ever. It does a great job on how to use PEAA and DDD in a complementary way.

I should also mention the format of the book; it is easy to read and grasp. No need to mention that the idea of having guest authors for specific topics is just great. And also as readers we might be subject to a new trend; having "product placements" in the book :) Some Swedish brands made it to the book as the author being a Swedish guy, which I think totally fair :)

I want to thank Jimmy and all the coauthors for this great work.

At the start the author says that this book is for "a wide target audience" and that if you don't have some knowledge of "object-orientation and C#" interest and enthusiasm will compensate for any lack of prior knowledge. I've been a web dev for over 10 years and know more than something about object-orientation etc. but this book is NOT for a beginner or even an intermediate programmer. On page 4 he starts discussion something called "case focus" with no definition and moves right into Domain-Driven Design Focus, again without explaining what this means. I found the book quite full of jargon and buzz words with a large presumption that one has already had experience in these topics. He says he is trying to build a bridge between users and developers. Most users will glaze over after the first chapter without any clue as to what he is talking about. If you are an advanced object-oriented programmer familiar with UML and other design technologies then this might be the book for you. Sorry. But a book this complex is not a bridge between users and developers.

Having read POEAA and DDD, I wondered where to go next, how to put it all together. Apparently the author was thinking the same thing. This book helped clear up a lot of the concepts that the previously mentioned classics introduced. The book is a joy to read and the author's tone is very humble and informal. Following along with the author's thought/design process, I feel I really learned a lot. I'm still not sure about the "rules" stuff, but the the treatment of aggregates is brilliant. However, the book sort of runs out of steam as it gets way too into the infrastructure and persistence concerns. At the time, I had never used NHibernate although I wanted to - so I really ate up the goodies here. But looking at it now, with new versions of NHibernate and Entity Framework, etc., this section seems sort of out of place. Might have been a good web-delivered supplement. (BTW - I would have paid extra for the actual code to NWorkspace!) The appendices are great, and I actually keep coming back to them - the sections on SOA, IOC and AOP were extremely enlightening for me. BUT - I'm not sure how well this stuff will stand the test of time. It is/was very timely material. Not to give a bad review though - I heartily recommend this to anyone doing DDD in .NET

I spent a few months reading blogs and articles on the web sites about DDD.
I was really interested in the topic so I decided to buy a book, instead of wandering around the web in search of "chunks of informations".
I choose Jimmy's book cause it seemed more up-to-date and less philosophical than the others.
I have to admit that I don't particularly love technical books cause I think the authors have to fill 500+ pages just to justify the cover price, and they could tell the same story in about 150 pages.
Anyway, this book is even worse than the average.
It's absolutely boring; almost unreadable.
There's more TDD than DDD in there.
It's really really slow.
It's there on my desk now, new and never finished.
A huge waste of money cause I've learned more from free web information than from a 60$ book.
Don't waste your money in this book, it is not worth.

The reviewer saying it sounds like a tired colleague's random ramblings is spot on. It's very hard to read, and not because the matter is difficult, but because it's terribly written. Fowler's and Evans' books are masterpieces. Very clean, focused, inspiring and readable. This one is nothing like that. A bit of TDD, a bit of NHibernate, but little concrete core.

What's worse, very often I find myself in complete disagreement with how the author is using various techniques. It hurt to read some of the TDD pieces, and it seems the author is yet to discover SOLID. Eventually the domain model looks like a complex, tangled ball of mud, not a consistent, elegant piece of art I expected.

Another excellent, approachable, useful book on the topic of Domain Driven Design. This book also discussed some exciting side topics that are difficult to find within the context of .NET. Topics such as: Aspect Oriented Programming (AOP), Dependency Injection, Inversion of Control (IOC), Mocking, and TDD. I found Nilsson's book crucial for filling in many of the implementation gaps that Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans skims over. I recommend reading this book alongside Evans seminal work on the topic of Domain Driven Design.

I really enjoyed reading this book. Jimmy has a very conversational writing style. He will show some code, talk about the pros and cons, make a change, talk about that change and repeat until he has something he is satisfied with. This was very helpful to me as it demonstrated that he has gone through the same growing process that we all need to take as software developers. He is not lecturing from a tower; he is a common programmer who has be able to develop some excellent techniques through research and experience working with others who also seek to be the best they can. His examples are clear and meaningful. He shows how you can actually use TDD to grow a domain model, which is something that has certainly been lacking from other resources I have used in the past. I read the book because I feel like my dev team needs a better focus and I am now more convinced that DDD and TDD will help us focus on creating maintainable code for our enterprise.

I have come back to this book after first digging into it when it first came out. At that time, I got bogged down and never really made it very far into the book. Here's why: A reader needs a basic conceptual familiarity with DDD before tackling this book. I'd suggest Domain-Driven Design: Tackling Complexity in the Heart of Software and Patterns of Enterprise Application Architecture (Addison-Wesley Signature Series). You might be able to get a running start by reading the free e-book "Domain Driven Design Quickly" (http://www.infoq.com/minibooks/domain-driven-design-quickly), but the Fowler book is particularly helpful, since it catalogs and explains a number of the patterns used in Nilsson's book.

Don't assume this book is outdated because it uses NHibernate instead of LINQ or the ADO Entity Framework. If you are a true DDD developer, neither product is quite 'there' yet, and NHibernate remains the best ORM framework available. And if the Entity Framework does become a viable ORM product in Version 2, the skills taught in this book should transfer easily.

In short, this book presents a really good nuts-and-bolts approach to explaining how to do DDD, but it assumes you already have a pretty good understanding of what DDD is all about.

This is really an exellent book on DDD, I read soon after the Evans book and I must admit that is really worth money I spent on it. Sure the book is not for beginners, and it is not an introduction to DDD, I think that a background on the subject is needed to fully appreciate this book.

Alk.