MinuteRead
30 min
Loading…
Book summary
by Eric Evans
Premium summary · Opens in the app · 30 min read
Every software project begins with a promise. The promise is that the software will capture something essential about the business, encode it faithfully, and make it work better than before. Yet walk through any large organization and you will find systems that have broken that promise. Systems where the code says one thing, the business says another, and nobody can quite explain how the two drifted apart.
**Author:** Eric Evans
**Estimated Reading Time:** 45 minutes
**What You'll Learn:**
- Why the language your team uses may be the single biggest factor in software success or failure - How to bind your code directly to the business concepts it represents - The essential building blocks for modeling any domain: entities, value objects, services, aggregates, factories, and repositories - How to protect your model from outside corruption while integrating with other systems - How to find and protect the part of your software that actually creates business value
**Who This Book Is For:**
Software developers, architects, and technical leads who have felt the pain of building complex business software that drifts away from the business it serves. It is also for product managers and domain experts who want to understand why communication with developers so often breaks down, and what can be done about it.
Every software project begins with a promise. The promise is that the software will capture something essential about the business, encode it faithfully, and make it work better than before. Yet walk through any large organization and you will find systems that have broken that promise. Systems where the code says one thing, the business says another, and nobody can quite explain how the two drifted apart. Eric Evans wrote *Domain-Driven Design* to address a problem that had been hiding in plain sight for decades. The problem was not a lack of technical sophistication. Developers had better languages, better tools, and better methodologies than ever before. The problem was deeper and more uncomfortable. The people building software and the people who understood the business were not actually speaking the same language. Consider a typical project. The business analyst produces a requirements document filled with terms like "policy," "exposure," and "risk assessment." The developer reads that document and translates it into classes called `PolicyManager`, `DataProcessor`, and `RiskUtils`. The database designer creates tables with names like `POL_MST` and `RSK_IND`. The user interface designer creates screens that talk about "accounts" in a way that means something slightly different from what the analyst meant. Within months, the same word means three different things depending on who is speaking. Within a year, nobody is entirely sure what the software actually does. This is not a communication problem in the soft, interpersonal sense. It is a structural problem. When the language used to discuss a system is not the same language used to build it, the system itself becomes unreliable. The code drifts away from the business. The business loses trust in the code. Developers lose the ability to reason about what they are building. The project becomes a slow-motion collision between two worlds that were supposed to be one.…
Continue reading in the MinuteRead app
Get the complete 30-minute summary of Domain-Driven Design
Get the complete summary in the appUse the model as the backbone of a language, and use that language everywhere, especially in the code.
Bind the domain model directly to the code. The analysis model and the design model should be the same model.
Isolate the Domain layer from technical concerns. Business rules belong in the Domain layer, not in the user interface o
Distinguish between Entities, Value Objects, and Services. Entities are defined by identity, Value Objects by attributes
Use Aggregates to define boundaries around clusters of objects, with a root Entity as the only external access point.
Use Factories to encapsulate complex object creation and Repositories to encapsulate persistence access.
"Domain-Driven Design" is a strong fit if you want practical ideas around programming, computer science, technology, especially themes like use the model as the backbone of a language, and use that language everywhere, especially in the code; bind the domain model directly to the code. the analysis model and the design model should be the same model. The MinuteRead summary distills these concepts into a focused read, whether you're deciding whether to buy the book or applying its lessons at work.
Motivated to help readers with modeling software to match a domain according to input from that domain's experts, Eric Evans wrote “Domain-Driven Design” as a practical guide drawn from years of experience and research. Through “Domain-Driven Design”, Eric Evans distills the core ideas on programming into lessons readers can absorb in a single short sitting. Readers turn to this work when they want Eric Evans's perspective on the subject without working through the entire original volume. The bo…
Continue Reading
Access the complete 30-minute summary and thousands more nonfiction books in the MinuteRead app.
Continue reading the complete summary in the MinuteRead app.
