Rating: 
Summary: Concretes the abstract worlds of patterns and principles
Review: This book answers the question of how you tie in cookbooks like the GoF book or Fowler's Enterprise Patterns book with the Wirfs-Brock book on designing systems. Reading this will help you to understand how to identify and apply great patterns in your design, where and when those patterns are important, and how many resources it's worth investing on rolling them out. More importantly, it helps you to understand and convey to others the importance of a clean design model.I also really enjoyed his notes on large refactorings (yes, in practice, sometimes you *do* encounter the need for large changes!) and the author's pragmatism around having to make decisions about where you invest heavily and where you don't. His points around large project constraints and how it becomes non-linearly expensive to maintain continuous integration and design consistency to the finest detail also hit home -- I've seen more than one group try to do that, fail, and give up entirely. A bit of balance, as he advocates in the book, would have really helped maintain some consistency and a solid core without requiring moving heaven and earth to get every interface looking Architect Approved (tm). The only place the book was lacking was in how you tie together and manage quite a bit larger projects. For instance, near the end he says, "No project will ever employ every technique in this book"; however, I've been on one that used everything he mentioned in this book in one place or another -- of course, it's tens of millions of lines of code :-)
Rating:
Summary: A Framework for Proper Object Thinking
Review: This book may change the way you think about software design. Of all the software books I purchased over the last year, this book ranks as one of the most important (another is Lean Software Development by Mary and Tom Poppendieck). The book presents an elegant pattern language to help the modeler understand and design the domain in which he is crafting software. The pattern language addresses both the human factor of modeling (i.e., effective communication with all stakeholders) and the technique of modeling (i.e., the application of object concepts). This well-organized book succeeds on many levels: * It helps prepare the modeler to work with his domain by suggesting he must develop the right mindset and communicate with the people who understand the domain. * Emphasizing the need to keep the domain model as pure as possible, it explains the absolute fundamentals of a domain model, including the all-important notions of entities, value objects, services, and modules. It presents the object-lifecycle, including the mechanisms of factory and repository (and their advantages). * It provides techniques for object discovery and refinement and model flexibility. * It provides ideas for organizing cooperative teams. * It is highly compatible with agile processes, such as eXtreme Programming (XP). In fact, the author himself has practiced XP. This book should be the second book a novice modeler should purchase. A seasoned modeler should buy this book immediately.
Rating: 
Summary: A real disappointment
Review: This book sets the expectations for grandiose and profound insights on software engineering, but it really failed to deliver. To be fair, there are some good insights, but they are buried in lots of `water' and structure less presentation. The points that author wants to emphasize appear in bold. Instead of bolding important things out, how about refactoring this book from 500+ pages to 200? But the amount of `water' is by far not the only problem with the book. For example, the author has made a point to use lots of practical modeling examples in the book. However, these examples lack continuity, as he they try cover too much. It would be better to develop 1 example through entire book. I thought I knew what Domain Driven design was before I read this book. I think that people, who did not, would not get clear idea of what it is. A simple, single message that software needs to capture the underlying phenomenon being modeled is not really coming through. The first few chapters focus on explaining what the Domain Driven Design is. Lots of emphasis is put on discussing the model with the customer in order to extract the essential concepts from the problem domain. While this idea is great, the suggestions that customers and engineers will speak the same language, where things are described like this: 'Car maintains collection of wheels', is rather strange. I do not believe that customers need to know that Car class actually stores wheels. The following chapters proudly introduce Entities, Value Objects, Services and Modules - the core of Domain Driven Design. I found these ideas trivial. What is new in anything that's been presented? Also, author raises a lot of complex questions such as identity management and shared access, but does not really answer them. The rest of book I can't really describe because things are just out of order. Not only I find no connection between chapters, the pages inside the chapter do not follow one another. To sum up, I regret that I spent my money on this book. Alex
Rating:
Summary: Rocked My Programming World
Review: This is one of the few books that has seriously changed my perspective on Software Design. I used to fall into the trap of applying technology to the solution, an technique he quietly rebuked and showed the solution. I'm not totally sure that beginning software professionals would understand what is being said in the book. It seems a bit subtle to me. For me, the revelations came out of experience coupled with the text. Nonetheless, it is written in such a way that it makes you think: and then the resulting revelation is your own. In short, it caused me to rethink my current projects that I'm working on and seriously changed their scope.
| 
