| help | account  


Domain-Driven Design: Tackling Complexity in the Heart of Software
View Larger Image
Eric Evans
Addison-Wesley, Hardcover, Published August 2003, 529 pages, ISBN 0321125215
List Price: $64.99
Our Price: $50.50
You Save: $14.49 (22% Off)


FREE Shipping on Orders over $40!*
Availability: Out-Of-Stock

Be the First to Write a Review and tell the world about this title!

People who purchase this book frequently purchase:

Books on similar topics, in best-seller order:Books from the same publisher, in best-seller order:

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.



Table of Contents

Foreword.
Preface.
Acknowledgments.

I. PUTTING THE DOMAIN MODEL TO WORK.

1. Crunching Knowledge.
2. Communication and the Use of Language.
UBIQUITOUS LANGUAGE.
Documents and Diagrams.

3. Binding Model and Implementation.
MODEL-DRIVEN DESIGN.
Letting the Bones Show; Why Models Matter to Users.
HANDS-ON MODELERS.

II. BUILDING BLOCKS OF A MODEL-DRIVEN DESIGN.


4. Isolating the Domain.
LAYERED ARCHITECTURE.
The Domain Layer Is Where the Model Lives.
SMART UI ANTI-PATTERN.

5. A Model Expressed in Software.
Associations.
ENTITIES (AKA REFERENCE OBJECTS).
VALUE OBJECTS.
SERVICES.
MODULES (AKA PACKAGES).
Modeling Paradigms.

6. The Lifecycle of a Domain Object.
AGGREGATES.
FACTORIES.
REPOSITORIES.
Designing Objects for Relational Databases.

7. Using the Language in an Example: A Cargo Shipping System.

III. REFACTORING TOWARD DEEPER INSIGHT.

8. Breakthrough.
9. Making Implicit Concepts Explicit.
Listening.
Scrutinizing Awkwardness.
Read the Book.
Try, Try Again.
Expressing Less Obvious Categories of Concepts.
Explicit Constraints.
Representing Processes as Domain Objects.
SPECIFICATION.

10. Supple Design.
INTENTION REVEALING INTERFACES.
SIDE-EFFECT-FREE FUNCTIONS.
ASSERTIONS.
CONCEPTUAL CONTOURS.
STANDALONE CLASSES.
CLOSURE OF OPERATIONS.
Declarative Design.
Extending SPECIFICATIONS in a Declarative Style.
Where to Start.
Example Integrating the Patterns: Shares Math.

11. Applying Analysis Patterns.
12. Relating Design Patterns to the Model.
STRATEGY AKA POLICY.
COMPOSITE.
Why Not FLYWEIGHT?

13. Bringing the Pieces Together.

IV. STRATEGIC DESIGN.

14. Maintaining Model Integrity.
BOUNDED CONTEXT.
CONTINUOUS INTEGRATION.
CONTEXT MAP.
Relationships Between BOUNDED CONTEXTS.
SHARED KERNEL.
CUSTOMER/SUPPLIER DEVELOPMENT TEAMS.
CONFORMIST.
ANTICORRUPTION LAYER.
SEPARATE WAYS.
OPEN HOST SERVICE.
PUBLISHED LANGUAGE.
Unifying an Elephant.
Choosing Your Model Context Strategy.
Transformations.
Merging CONTEXTS (SEPARATE WAYS * SHARED KERNEL).
Merging CONTEXTS (SHARED KERNEL * CONTINUOUS INTEGRATION).
Phasing Out a Legacy System.
OPEN HOST SERVICE * PUBLISHED LANGUAGE.

15. Distillation.
CORE DOMAIN.
GENERIC SUBDOMAINS.
DOMAIN VISION STATEMENT.
HIGHLIGHTED CORE.
COHESIVE MECHANISMS.
Distilling to a Declarative Style.
SEGREGATED CORE.
ABSTRACT CORE.
Deep Models Distill.
Choosing Refactoring Targets.

16. Large-Scale Structure.
EVOLVING ORDER.
SYSTEM METAPHOR.
RESPONSIBILITY LAYERS.
KNOWLEDGE LEVEL.
PLUGGABLE COMPONENT FRAMEWORK.
How Restrictive Should a Structure Be?
Refactoring Toward a Fitting Structure.

17. Bringing the Strategy Together.
Bringing Together Large-Scale Structures and BOUNDED CONTEXTS.
Bringing Together Large-Scale Structures and Distillation.
Assessment First.
Who Sets the Strategy.

V. CONCLUSIONS.


Epilogue: Looking Forward.
Appendix A: Use of Patterns in This Book.
Glossary.
References.
Index

 

About the Author

Eric Evans is the founder of Domain Language, a consulting group dedicated to helping companies build evolving software deeply connected to their businesses. Since the 1980s, Eric has worked as a designer and programmer on large object-oriented systems in several complex business and technical domains. He has also trained and coached development teams in Extreme Programming.




Forgot your password?
FAQs
Shipping Options
Returns
Your Orders
Your Account