Read Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans Online


"Eric Evans has written a fantastic book on how you can make the design of your software match your mental model of the problem domain you are addressing. "His book is very compatible with XP. It is not about drawing pictures of a domain; it is about how you think of it, the language you use to talk about it, and how you organize your software to reflect your improving und"Eric Evans has written a fantastic book on how you can make the design of your software match your mental model of the problem domain you are addressing. "His book is very compatible with XP. It is not about drawing pictures of a domain; it is about how you think of it, the language you use to talk about it, and how you organize your software to reflect your improving understanding of it. Eric thinks that learning about your problem domain is as likely to happen at the end of your project as at the beginning, and so refactoring is a big part of his technique. "The book is a fun read. Eric has lots of interesting stories, and he has a way with words. I see this book as essential reading for software developers--it is a future classic." --Ralph Johnson, author of Design Patterns "If you don't think you are getting value from your investment in object-oriented programming, this book will tell you what you've forgotten to do. "Eric Evans convincingly argues for the importance of domain modeling as the central focus of development and provides a solid framework and set of techniques for accomplishing it. This is timeless wisdom, and will hold up long after the methodologies du jour have gone out of fashion." --Dave Collins, author of Designing Object-Oriented User Interfaces "Eric weaves real-world experience modeling--and building--business applications into a practical, useful book. Written from the perspective of a trusted practitioner, Eric's descriptions of ubiquitous language, the benefits of sharing models with users, object life-cycle management, logical and physical application structuring, and the process and results of deep refactoring are major contributions to our field." --Luke Hohmann, author of Beyond Software Architecture "This book belongs on the shelf of every thoughtful software developer." --Kent Beck "What Eric has managed to capture is a part of the design process that experienced object designers have always used, but that we have been singularly unsuccessful as a group in conveying to the rest of the industry. We've given away bits and pieces of this knowledge...but we've never organized and systematized the principles of building domain logic. This book is important." --Kyle Brown, author of Enterprise Java(TM) Programming with IBM(R) WebSphere(R) The software development community widely acknowledges that domain modeling is central to software design. Through domain models, software developers are able to express rich functionality and translate it into a software implementation that truly serves the needs of its users. But despite its obvious importance, there are few practical resources that explain how to incorporate effective domain modeling into the software development process. Domain-Driven Design fills that need. This is not a book about specific technologies. It offers readers a systematic approach to domain-driven design, presenting an extensive set of design best practices, experience-based techniques, and fundamental principles that facilitate the development of software projects facing complex domains. Intertwining design and development practice, this book incorporates numerous examples based on actual projects to illustrate the application of domain-driven design to real-world software development. Readers learn how to use a domain model to make a complex development effort more focused and dynamic. A core of best practices and standard patterns provides a common language for the development team. A shift in emphasis--refactoring not just the code but the model underlying the code--in combination with the frequent iterations of Agile development leads to deeper insight into domains and enhanced communication between domain expert and programmer. Domain-Driven Design then builds on this foundation, and addresses modeling and design for complex systems and larger organizations.Specific topics covered include:Getting all team members to speak the same language Connecting model and implementation more deeply Sharpening key distinctions in a model Managing the lifecycle of a domain object Writing domain code that is safe to combine in elaborate ways Making complex code obvious and predictable Formulating a domain vision statement Distilling the core of a complex domain Digging out implicit concepts needed in the model Applying analysis patterns Relating design patterns to the model Maintaining model integrity in a large system Dealing with coexisting models on the same project Organizing systems with large-scale structures Recognizing and responding to modeling breakthroughs With this book in hand, object-oriented developers, system analysts, and designers will have the guidance they need to organize and focus their work, create rich and useful domain models, and leverage those models into quality, long-lasting software implementations....

Title : Domain-Driven Design: Tackling Complexity in the Heart of Software
Author :
Rating :
ISBN : 9780321125217
Format Type : Hardcover
Number of Pages : 560 Pages
Status : Available For Download
Last checked : 21 Minutes ago!

Domain-Driven Design: Tackling Complexity in the Heart of Software Reviews

  • Alexander Petrov
    2019-06-01 09:37

    Amazing book!Every programmer must read it! As well as Pragmatic Programmer by Dave Thomas and Andy Hunt and Refactoring by Martin Fowler.There are many books tells you to separate domain logic from other parts like UI and Persitence, because it is the most valuable part of application and you should be able to make changes as quick, as your business changes and as your understanding of domain improves. But! There are very few books about how to design domain layer of your application!This is the first of and The Best one!It is very easy to read DDD, because of excellent language of Eric Evans. Every pattern and principle goes with clear example from real authors practice.One of my favourite points in the book, that you can never make all requirements and design upfront and write all code right after, unless you are working on very small application, or(and) requirements are as clear as the periodic table of Dmitry Mendeleev. That is because only the code reflects your current understanding of domain model and gives you deeper understanding of directions of increasing your model and UBIQUITOUS LANGUAGE. Clear justification of this point is in the book! I can recommend DDD to every programmer, also with small experience.The world would be much better if every project (especially enterprise) and product manager also read this book! But unfortunately it is utopia:(The earlier you read it the happier professional you will become!

  • Einar
    2019-05-22 09:38

    This book is impossible to rate. The ideas in this book are incredibly useful, and I am grateful to the author for sharing them with the software development community. In this perspective, not reading this book borders on professional negligence.Unfortunately, I find the writing practically impenetrable. There are so many quaint and opaque verbs and adjectives that never get defined or even justified. Does "tightening" make a model "richer" and/or "deeper"? What about "enriching"? Is either one distinct from "distilling"? Is a "sharp" design always "supple" and vice versa? Could you "sharpen" a model too, or does it only apply to designs? What is it about the nature of domains that makes "carve off" a suitable description of what you do when you separate out a subdomain? What does it mean for knowledge to be "crunched"? There are so many vague terms, so many implied metaphors! Why? I am convinced that it would be possible to present these terrific ideas in a much more -ah- "distilled" form. With a "tighter" vocabulary. As it is, I am using a high-concentrate mixture of willpower and espressos to force my way through because I need the insights buried underneath the text. The book also suffers from poor editing. There is quite a bit of redundancy, and some discussions lack focus. Many of the introductions or summaries to chapters could have been cut in their entirety. I've even found the same sentence repeated just a few paragraphs apart - something that just a single alert proofreader capable of focusing throughout the text should have caught. But it *is* hard to keep that focus.It is a crying shame, since the underlying ideas and intentions are so good.

  • Andreea
    2019-06-01 13:46

    While reading this book I complained a lot about the author repeating the same ideas supported by different examples. However, I really enjoyed reading it and I feel I gained a lot of knowledge about designing software applications. Of course, this knowledge is purely theoretical, but we all have to start somewhere.One thing I really appreciated is that the author doesn’t isolate the design and development part from the human interaction. One has to know the team members’ skills and employ them as efficiently as possible in the software development process. The main idea he tries to promote is knowing your domain and making your code express that domain.This book does not offer recipes for designing and developing software applications, but provides a series of guidelines that one can follow and/or adapt to a certain project.I think it’s quite a valuable book to read, although it might arise some developer mixed feelings about the author giving exhaustive examples and explanations in some cases. It is always a pleasure to read a book that has behind it a lot of experience in software development and also in applying domain driven design principles throughout one’s work.

  • Jan
    2019-06-04 08:03

    Bardzo ważna, ale niestety równie fatalnie (a przynajmniej nieprzystępnie) napisana książka - językowo blisko jej do pracy naukowej. Na pewno nie na początek z DDD.

  • Tom
    2019-06-06 07:43

    Great, great book. However, you should probably have at least some understanding of agile, design patterns, and refactoring before reading this book if you truly want to get the most out of it. The book talks about using model-driven design to create a domain model and ubiquitous language that everyone in the company can leverage - a topic that seems to be getting more attention as of late.Some of the topics are pretty abstract, and I would have liked to see some more code and concrete examples for some of them. Nonetheless, I encourage all programmers to at least read chapters 1-3, 5, 6, 9, 10, and 14.

  • Emad
    2019-06-19 10:46

    Please take this with grain of salt; most of my reading of this book was fast reading.What I like about this book is that there is a genuine trial to bring examples to the various concepts. This is done throughout the book.What I don't like:- Too much repetition and too verbose- I feel that the statements are structured in a way that makes it really hard for fast reading- Even with examples, sometimes I feel it's too much theory

  • David
    2019-06-11 05:55

    Been reading this on and off for a while now. I would put this on the "must read" shelf of anyone involved in the development side of software engineering, including programmers, designers, architects, even development managers. It presents a lot of important points and topics that some developers sort of know or understand but never clearly defined and put forth. There are best practices on patterns, approaches to design and development, architecture, and communication.It takes OO development up to a new level, expanding on the generic technical ideas into the realm of domain knowledge. It's about closing the gap of understanding between business users, project owners, and and the developers.The concepts presented take some time to absorb and are best learned when put in actual practice. It's not easy to digest but as you glean bits and pieces there, sometimes it's like, "I know doing this way always felt right", and now the book explains why it felt right. Some of the explanations are rather abstract (there are very specific examples throughout the book) for things that are hard to define, so I'd say I found it difficult to relate to things where I had no practical experience. Still, I come away from this book with a good understanding of the benefits of placing high importance on the correctness and representational value of domain model.

  • Bjørn
    2019-05-29 08:54

    Excellent software engineering book. It presents a working strategy for writing and organizing software code in classes and packages in a clean and usable environment. The book presents a "common language" concept that improves communication between team members and between the team and stake holders. It presents strategies for managing code by associating class names and packages with specific functionalities, proving and common understanding of what-goes-where for a team working with domain driven design (DDD).We have been working with DDD in our team increasingly over the last 6 months. Together with Domain-Driven Design Quickly (which we use as our quick guide) the book by Eric Evans provides excellent value for us. By helping us with create a common understanding of what different concepts, like service, model, value object etc, means to our team, we can make our code a lot better organized. By incorporating concepts from the DDD book, for example stateless services, domain objects and root aggregates we improve our code quality as well.

  • Sebastian Gebski
    2019-05-30 07:43

    Actually, it's the 2nd time I've read that book. After the 1st time I was quite happy with what I've received - I've generally agreed to author's approach, even more: I've found it rather obvious ("so not a big deal") - I'd do pretty much the same in the example cases, I agree that those design decisions are more reasonable, etc.Some time has passed, I've discussed DDD with several people on several occassions and I think now I got the value of this book: author does not only gives you the example of good design, but he provides you the rules / formulas how to achieve that. I didn't see that when I was reading DDD for the first time, because I'm doing design "automatically" / intuitively, so I've never really needed those rules (and I've ignored them, to put it bluntly).But I have a problem with teaching people how to make a good design, how to make a difference between snapshotting reality and making a proper model. And here's where this book really excels, this is the first book I've seen that actually CAN make reader a better designed. Very recommended.

  • JoseSeco Sanz
    2019-06-07 11:54

    There is a lot of things to learn in here. Probably I should read it again.

  • Stijn
    2019-05-31 08:48

    Ironic how a book that advocates concise documentation and diagrams over text looses itself in way too much narrative. The ideas in this book are good, but it could have easily been have as long. It keeps on repeating itself in long paragraohs, full of vague terms.The used examples are realistic (all coming from real projects), but sometimes lacked context to understand the reasoning that was applied to apply the patterns.

  • Rafal Piekarski
    2019-06-01 07:02

    It took me more than a year to read this book. It was tough. This book is more like a directory of patterns and I believe that you shouldn't use all of them will every project. I have heard before reading this book about many cases when implementing domain driven design failed. Especially in the Ruby world in which I write most of my daily code. But I believe the true reason of the failure was that people were trying to use all ideas from the DDD. But the book written by Eric Evans in final chapter emphasized that DDD is not a silver bullet and not every concept presented inside applies to your project and case. Nevertheless this book opens my eyes for role of ubiquitous language and importance of being on the same side with client. So you shouldn't use DDD as an oracle for doing your next project. Because it's easy way to over-engineer things and I strongly believe that author was aware of it. In "conclusion" chapter he have written it couple of times. So if you want to get familiar with Repository pattern, Value Objects, Aggregates, Bound Context, Core Domain or Policies it's very good place to start. But stay sceptic. And focus on your project and client needs instead of surfing on every new buzzword you would find there. What I disliked was way this book was written. Language and sentences were hardly to read quick and I felt like crawling through each page instead of reading and going straight to using it in my projects. I'm sure that this could be improved.

  • Erika RS
    2019-06-14 05:42

    See elsewhere for my more detailed summary.The short summary is that Domain-Driven Design is a great book for any programmer or software designer who wants to deepen their ability to model application domains. Evans describes why domain modelling is important and sets out a number of patterns for achieving better models. He has a good grasp of real world complexities and, because of that, insists that a model must be implementable if it is to be successful. Any overlap between the model and the implementation should be identical or the model will become obsolete.Evans provides a number of patterns to help determine the best domain model for an application. These patterns range from the abstract to the concrete, from the brilliant to the pedantic. Overall, I highly enjoyed the book although, at just over 500 pages, I am glad that I had a reading group to work through it with.

  • Lars Cronsioe
    2019-06-02 12:43

    Inexplicably dull for such an important subject. Given the American habit of paying people per page, signal/noise ratio is way too low and he keeps regurgitating the few valid points over and over. This book could have been written so much snappier and more entertaining.Really, most of this is common sense, although sadly not very common in the developer community, which is generally more fascinated with technical gadgetry than actual mature software engineering. Technical people usually stink at communication, we already knew that.That said, it's good to have someone stir up the dust and get the community aware of the long-standing need for defining domain concepts more strictly within organizations, and to devise a number of patterns for entities, value objects etc. While the book is certainly not without value, still I would have wished for the standard work on this subject to be more accessible and to the point.

  • Robert
    2019-06-09 09:02

    This is one of the best books on software design and architecture currently available. This has the potential to be as forever mind-changing as Design Patterns, POSA, or PoEAA. The book talks about an interesting way to design and architect software: That of letting the domain drive the results. The books takes traditional OOP approaches and turns them on it's ear. By making the underlying focus of the application the actual objects (and their relationships/lifecycle) the right things get built in the right way. I can't stress enough how valuable/important this book is. While it can take a bit to get your head around it, once you do you will never want to build software any other way.This is a seminal work, one that should be life changing...

  • Xavier Shay
    2019-06-03 10:35

    Long (I'm starting to feel that way about all programming books...), but worthwhile. Key takeaways for me:- If business people use terms that don't appear in your model, that's bad.- "Make implicit concepts explicit." Important business rules should not be hidden away in conditionals inside an unrelated object.- Constrain relationships as much as possible. For instance a has_many should only be bidirectional if it is really necessary. A way around it is to use repositories to access the information.- Responsibility layers can be a good way to structure the model (operations, decision support, policy, potential, etc...)- "Refactor towards greater insight."- "Distill the core." Ruthlessly extract generic concepts that aren't essential to the domain.

  • Stijn
    2019-06-10 05:50

    Domain-Driven Design is a book that was recommended to my several times. I think that the translation between these models and some technical implementations will always be a challenge. Though, I can't recommend this book enough to anyone in the technical and non-technical software business.

  • Bayram Üçüncü
    2019-06-18 09:00

    Excellent book to learning complex software development solutions. I recommand it. This book does not contain a code based application.

  • Kiril Kirilov
    2019-06-19 11:48

    This book contains some interesting conceptions/terms. Like - Entity, Value Object, Closure of Operations, Repository, side effect free function, Core Domain, Bounded Context.

  • Max Savchenko
    2019-06-07 13:35

    Одна из тех книг, которые формируют "архитектурное" мышление программиста. Если вы работаете в команде над более-менее сложными проектами - книга для вас.

  • Arjay
    2019-06-03 13:43

    A must read book for any serious developer.

  • Luc.Leysen
    2019-06-10 08:49

    The bible of DDD.

  • Alejandro Teruel
    2019-06-12 06:46

    This is an extremely interesting book which tackles the important topic of developing, refining and evolving the core domain model of an object-oriented software design. It covers the design process, the design as product, design dynamics and the importance of domain design as a fundamental touchstone of software development.It is hard to write a book about software design. On the one hand, if you write at too abstract a level you run the danger of uttering platitudes or hinting at general principles which may turn out to be too vague to be of much real use. On the other hand, if you write at too concrete a level, you run the danger of drowning the reader in far too much detail. In the main, Eric Evans succesfully drives a middle course and gives much food for thought, even though novice designers will occasionally find themselves out of their depth or wondering what the fuss is all about, whereas more experienced designers will occasionally yawn and wonder why some points needs to be made over and over again.Eric Evans tries to cast his ideas in the form of patterns, but, in my opinion, fortunately follows the pattern framework in a rather loose and idiosyncratic way.Some ideas correspond to old wine in new bottles. Such is the case for his Ubiquituous Language pattern which insists that the designers, the developers and his clients must develop and use a common language. It is worth recalling that ever since people started seriously churning out software development methodologies, most of them also insisted on the development of common glossaries of key terms It is certainly welcome to see agile methodologies returning to this very important common sense and time-tried fundamental.In true Agile fashion, Evans lashes out against what he terms the manufacturing metaphor for software development:Manufacturing is a popular metaphor for software development. One inference from this metaphor: highly skilled engineers design; less skilled laborers assemble the product. This metaphor has messed up a lot of projects for one simple reason -software development is all design.[...]If the people who write the code do not feel responsible for the model or don´t understand how to make the model work for an application, then the model has nothing to do with the software. If developers don´t realize that changing code changes the model, then their refactoring will weaken the model rather than strengthen it. Meanwhile, when a modeler is separated from the implementation process, he or she never acquires, or quickly loses,a feel for the constraints of implementation.[...] Any technical person contributing to the model must spend some time touching the code, whatever primary role he or she plays on the project. Anyone responsible for changing code must learn to express a model through the code[...]The sharp separation of modeling and programming doesn´t work... Interestingly, at a more technical level of design, Evans suggests three key patterns of design model elements: entities, value objects and services. Value objects are distinguished by the value of their attributes whereas entities have a life-cycle identity that trascends the particular values their attrributes may hold at any given time. Thus two value objects are equal if all their attributes are equal, whereas two entities are different even if all their (visible) attributes are equal. Thus:Tracking the identity of ENTITIES is essential, but attaching identities to other objects can hurt system performance, add analytic work and muddle the model by making all objects look the same [...]VALUE OBJECTS are often passed as parameters in messages between objects, they are frequently transient, created for an operation and then discarded. When you care only about the attributes of an element of the model classify it as a VALUE OBJECT. Treat the VALUE OBJECT as immutable, don´t give it any identity and avoid the design complexities necessary to maintain ENTITIES.Thus, as he points out, value objects may be good candidates to apply the Flyweight pattern to, whereas it is inevitably a mistake to attempt to apply the flyweight pattern to entities.Evans also attaches particular importance to aggregates:An AGGREGATE is a cluster of associated objects that we treat as a unit for the purpose of data changes. Each AGGREGATE has a root and a boundary. The boundary defines what is inside the AGGREGATE. The root is a single, specific ENTITY contained in the AGGREGATE. The root is the only member of the AGGREGATE that outside objects are allowed to hold reference to, although objects within the boundary are allowed to hold references to each other. ENTITIES other than the root have local identity, but that identity needs to be distinguishable only within the AGGREGATE, because no outside object can ever see it out of the context of the root ENTITY.[...] Invariants, which are consistency rules that must be maintained whenever data changes will involve relationships between members of the AGGREGATE. Any rule that spans AGGREGATES will not be expected to be up-to-date at all times [but] the invariants applied within an AGGREGATE will be enforced with the completion of each transaction.Not surprisingly, once you think about it, the Factory pattern is applicable generating value objects, particularly lightweight value objects, and also for generating or reconstituting aggregates, while the Repository pattern fundamentally should be applied to aggregates. One of Evans´ key design suggestions is when designing, one should take into account that there are probably different ways of aggregating entities and value objects -and the designer should try out several different ways and get a feel for their advantages and disadvantages.At the software architecture level, Evans pays particular attention to layered designs. One of the most interesting parts of the book is on strategic design has to do with what sort of relationship should be developed and maintained between core domain concepts and the rest of the model and the system. The discussion of ideas and patterns such as core domain, abstract core, segregated core, shared kernel, customer-supplier relationships, separate ways, generic subdomains and highlighted core is well worth careful study. The important idea of an anticorruption layer to keep legacy systems from corrupting the core domain is one of those natural and fascinating ideas which one wishes Evans had gone into more detail on.Evans suggests that good design is based on deep but flexible models of the domain. Not surprisingly, Evans asserts that there are no shortcuts to deep models ("useful models seldom lie on the surface"); a good deep model is the consequence of hard work, close and open collaboration by designers and domain specialists, and multiple design refactorizations followed by breakthroughs: A breakthough is not a technique but an event. [...] When the prospect of a breakthough to a deeper model presents itself, it is often scary. Such a change has higher opportunity and higher risk than most refactorings. And timing may be inopportune.Much as we might like it to be otherwise, progress isn´t a smooth ride. The transition to a really deep model is a profund shift in your thinking and demands a major change to the design. On many projects the most important progress in model and design come in these breakthroughs.Don´t become paralyzed tring to bring about a breakthrough. The possibilty usually comes after many modest refactorings [...] Don´t introduce "supple designs" that are just demonstrations of technical virtuosity but fail to cut to the core of the domain. Don´t introduce a "deeper model" that you couldn´t convince a domain expert to use, no matter how elegant it seems. It is also worthwhile recalling his advice on system metaphors:Unfortunately few projects have found really useful METAPHORS and people have tried to push the idea into domains where it is counterproductive.Warning: Steer clear of "naive" metaphors -a mature domain model is anything but naive.Finally, Evans considers design to be a team activity that depends on the maturity of the team members. Since Evans work represents, in my opinion, a maturation of agile processes, he fittingly winds up the book by quoting Christopher Alexander (The Oregon Experiment, 1975) -the architect who inspired the so-called Gang of Four (Gamma, Helm, Johnson and Vlissides, ) to introduce patterns to the software developer community- on the perils of designing by a master plan:The master plan attempts to set down guidelines to provide for coherence in the environment as a whole -and still leave freedom for individual buildings and open spaces to adapt to local needs [...] and all the various parts of this future university will form a coherent whole, because they were simply plugged into the slots of the design.[...I]n practice master plans fail -because they create totalitarian order, not organic order. They are too rigid; they cannot easily adapt to the natural and unpredictable changes that inevitably occur in the life of a community. As these changes occur ....the master plan becomes obsolete, and is no longer followed. And even to the extent that master plans are followed... they do not specify enough about connections between buildings, human scale, balanced function, etc. to help each local act of building and design become well-related to the environment as a whole.[...] At best , the order which results from such a process is banal.[...] Thus as a source of organic order, a master plan is both too precise, and not precise enough. The totality is too precise: the details are not precise enough.[...T]he existence of a master plan alienates the users [because by definition] the members of the community can have little impact on the future shape of the community because most of the most important decisions have already been made.In short, a book well worth reading and meditating on.

  • Jano Suchal
    2019-05-27 11:58

    Review in Slovak:

  • Jeremy Huiskamp
    2019-05-24 11:43

    Quite early in my career, I read The Pragmatic Programmer, which introduced the idea of low coupling / high cohesion. While it was useful to learn that this is a good goal to aim for, I was always a little bit frustrated at the lack of a formula for discovering breakdowns that achieved this goal. I think Doman-Driven Design does a very good job of tackling that problem.The book brought me to a new-found respect for object oriented programming. It was written at perhaps the height of OO programming, right around the time when I was learning it, but I think at that point, the reasoning behind the model was not being taught well. Or at least as a student, I absorbed only the mechanics and not the nuance. At any rate, since then, I think OO has become somewhat less popular, due in part to the fact that no persistence paradigm that fits it well really ever became mainstream. Evans confirmed that in a 2015 podcast with Software Engineering Radio, stating that event-driven programming has arisen since then, and that he no longer works with OO himself. (Of course OO and event-driven programming are not mutually exclusive...)The later chapters in particular piled on a lot of concepts, often without direct relation to concepts introduced earlier in the book (eg, Entities and Value Objects are not mentioned in the large-scale structure discussion). This makes it difficult to distill all the knowledge into a usable representation in one's own head. In fact, by the time I got to the end of the book, I had forgotten all about many of the concepts introduced earlier.It would be beneficial to continue to refer to the book over time. Fortunately, it is formatted in such a way that makes it fairly easy to use as a reference. For example, all the core patterns are written in small caps (making them easy to find in the table of contents) and they follow a common pattern that makes them easy to skim.I found the examples in the book quite difficult to digest and learn from. It's not that they seemed poorly done, just that, by definition, they required a lot of familiarity with the domain being discussed. I found it much easier to relate the abstract patterns to experiences from my own career. In fact, I don't think I would have been able to absorb it at the time I read The Pragmatic Programmer...

  • M
    2019-06-12 07:42

    very valid conceptbut, omg, so painful to readI am not sure what is wrong with it, but I just couldn't finish it. It's boring, long-winded and just hard work...I can't really recommended. I mean the concepts are all valid, but I'd rather go for a summary...I am not sure this topic justifies 516 pages...For those who are interested, this goes will withImplementing Domain-Driven DesignAnd this seems to be a shorter summary (though I have not read it yet myself):Domain-Driven Design Distilled

  • Inxive Neoy
    2019-06-16 12:56

    The best book on Domain Modeling that I can recommend. It helped me finally understand encapsulation and aggregation/composition. And gave me a lot of other tools to help with modeling software systems.The next power thing that I learned is how to truly decoupling modules that depend on similar concepts (like a User). This is reinforced in the book through Bounded Contexts and Ubiquitous Language.The examples given in the book is really practical but simple enough to understand and complex enough to drive the point home. The range of techniques and tools can be applied to both low-level modeling and high-level modeling. In fact, the book is divided into these two parts.

  • Luk
    2019-06-02 09:55

    When going into this book, many of my peers warned me about how this is a tough read. And how the examples are so far-fetched and hard to understand. How it is a slog to go through.Well, I'm glad I read it, and I found it to be amazing. The theory provided in the book, spans several different possibilities and is not just based on the happy path of a software project. On top of all that are all the examples on the book to make the theory really come to life.Granted, some are harder to understand than others, but all of them are integral to the goal of this book.I'm looking forward to putting all the principles en practices provided by this book to use.

  • Betty
    2019-05-27 12:41

    I'm perplexed after finishing the book. It started off slowly, giving some useful advice and interesting examples (ubiquitous language, modules, value-objects, etc.). At some places it got me completely -e.g., the language + the shared understanding between devs, architects, domain experts, users, and even the customers. However, the content does not follow its own minimalism guideline and after 200-300 pages it repeats itself. A great starter in DDD, though.

  • Michael Ryan
    2019-06-17 11:52

    A good and useful book. It fills in some of the gaps around object-oriented domain modeling. I shall use it as a reference in future. it is basically a software architect-level book. Not for bunnies.