Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer -no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the author
Domain-Driven Design: Tackling Complexity in the Heart of Software 1st Edition
Purchase options and add-ons
Incorporate effective domain modeling into the software development process
Software design thought leader and founder of Domain Language, Eric Evans, provides 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 system 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 modeling and development.
- Domain Model: Part I outlines the goals of domain-driven development, defines terms, and gives an overview of the implications of using the domain model to drive communication and design
- Model-Driven Design: Part II condenses a core of best practices in object-oriented domain modeling into a set of basic building blocks and focuses on the kinds of decisions that keep the model and implementation aligned with each other, each reinforcing the other’s effectiveness
- Refactoring:Part III delves into modeling principles that can guide choices along the way, and techniques that help direct the search
- Strategic Design: Part IV explores a triad of principles that apply to the system as a whole: context, distillation, and large-scale structure
Throughout the book, discussions are illustrated not with over-simplified, “” problems, but with realistic examples adapted from actual projects. 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.
“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 ofDesign Patterns
- ISBN-100321125215
- ISBN-13978-0321125217
- Edition1st
- PublisherAddison-Wesley Professional
- Publication dateAugust 20, 2003
- LanguageEnglish
- Dimensions7.25 x 1.4 x 9.6 inches
- Print length560 pages
Frequently bought together
Similar items that may deliver to you quickly
Customers also bought or read
- Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series)
PaperbackJPY7,211JPY 1,707 deliveryFri, Feb 20 - Refactoring: Improving the Design of Existing Code (2nd Edition) (Addison-Wesley Signature Series (Fowler))
HardcoverJPY9,766JPY 1,776 deliveryFri, Feb 20 - Design Patterns: Elements of Reusable Object-Oriented Software#1 Best SellerObject-Oriented Design
HardcoverJPY5,282JPY 1,713 deliveryFri, Feb 20 - Software Architecture: The Hard Parts: Modern Trade-Off Analyses for Distributed Architectures
PaperbackJPY6,913JPY 1,700 deliveryFeb 24 - Mar 11 - Learning Domain-Driven Design: Aligning Software Architecture and Business Strategy
PaperbackJPY5,891JPY 1,719 deliveryFri, Feb 20 - The Pragmatic Programmer: Your Journey To Mastery, 20th Anniversary Edition (2nd Edition)#1 Best SellerSoftware Testing
HardcoverJPY7,840JPY 1,700 deliveryFri, Feb 20 - Test Driven Development: By Example (Addison-Wesley Signature Series (Beck))
PaperbackJPY5,343JPY 1,571 deliveryFri, Feb 20 - Working Effectively with Legacy Code (Robert C. Martin Series)
PaperbackJPY5,245JPY 1,700 deliveryTue, Feb 24 - Fundamentals of Software Architecture: A Modern Engineering Approach#1 Best SellerComputer Programming Logic
PaperbackJPY9,020JPY 1,776 deliveryFri, Feb 20 - Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series)
PaperbackJPY8,204JPY 1,824 deliveryFri, Feb 20 - Unit Testing Principles, Practices, and Patterns: Effective testing styles, patterns, and reliable automation for unit testing, mocking, and integration testing with examples in C#
PaperbackJPY7,856JPY 1,669 deliveryFri, Feb 20 - Code Complete#1 Best SellerClient-Server Networking Systems
PaperbackJPY6,272JPY 1,996 deliveryTue, Feb 24 - Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software 2nd Edition
PaperbackJPY6,913JPY 1,776 deliveryFri, Feb 20 - Domain-Driven Refactoring: A hands-on DDD guide to transforming monoliths into modular systems and microservices
PaperbackJPY4,779JPY 1,707 deliveryFeb 16 - 20 - Mythical Man-Month, The: Essays on Software Engineering, Anniversary Edition
PaperbackJPY6,075JPY 1,639 deliveryFeb 23 - Mar 5 - Modern Software Engineering: Doing What Works to Build Better Software Faster
PaperbackJPY3,341JPY 1,571 deliveryFri, Feb 20 - Architecture Patterns with Python: Enabling Test-Driven Development, Domain-Driven Design, and Event-Driven Microservices
PaperbackJPY5,830JPY 1,639 deliveryFri, Feb 20 - Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#
PaperbackJPY7,535JPY 1,639 deliveryFri, Feb 20 - Release It!: Design and Deploy Production-Ready Software
PaperbackJPY6,342JPY 1,692 deliveryFri, Feb 20 - Head First Software Architecture: A Learner's Guide to Architectural Thinking
PaperbackJPY8,384JPY 1,713 deliveryFri, Feb 20 - Fundamentals of Software Architecture: An Engineering Approach
PaperbackJPY8,996JPY 1,700 deliveryMar 2 - Apr 2 - Architecture for Flow: Adaptive Systems with Domain-Driven Design, Wardley Mapping, and Team Topologies (Addison-Wesley Signature Series (Vernon))
PaperbackJPY5,982JPY 1,557 deliveryFri, Feb 20 - Accelerate: The Science of Lean Software and DevOps: Building and Scaling High Performing Technology Organizations
PaperbackJPY2,755JPY 1,526 deliveryFeb 19 - Mar 3
From the Publisher
From the Foreword by Martin Fowler
"The key to controlling complexity is a good domain model, a model that goes beyond a surface vision of a domain by introducing an underlying structure, which gives the software developers the leverage they need. A good domain model can be incredibly valuable, but it’s not something that’s easy to make. Few people can do it well, and it’s very hard to teach.
Eric Evans is one of those few who can create domain models well. I discovered this by working with him—one of those wonderful times when you find a client who’s more skilled than you are. Our collaboration was short but enormous fun. Since then we’ve stayed in touch, and I’ve watched this book gestate slowly.
It’s been well worth the wait."
 Domain-Driven Design Distilled |  Domain-Driven Design |  Implementing Domain-Driven Design | |
|---|---|---|---|
| Customer Reviews | 4.4 out of 5 stars625 | 4.6 out of 5 stars1,543 | 4.5 out of 5 stars662 |
| Price | JPY 6,284 | JPY 6,256 | JPY 9,730 |
| Core DDD techniques for building better software | A systematic approach to DDDs for building better software | A top-down approach to understanding DDD | |
| Overview | Concise, readable, and actionable guide to the basics of DDD: What it is, what problems it solves, how it works, and how to quickly gain value from it. | 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. | Building on Eric Evans’ seminal book, Vaughn Vernon couples guided approaches to implementation with modern architectures, highlighting the importance and value of focusing on the business domain while balancing technical considerations. |
| What Will You Learn | Each core DDD technique for building better software. Never buries you in detail–it focuses on what you need to know to get results. | Design best practices, experience-based techniques, and fundamental principles that facilitate the development of software projects facing complex domains. | Practical DDD techniques through examples from familiar domains and how to use DDD within diverse architectures, including Hexagonal, SOA, Rest, CQRS, Event-Driven, and Fabric/Grid-Based. |
Editorial Reviews
From the Back Cover
“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 ofDesign 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 ofDesigning 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 ofBeyond 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 ofEnterprise Java™ Programming with IBM® WebSphere®
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.
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.
Product details
- Publisher : Addison-Wesley Professional
- Publication date : August 20, 2003
- Edition : 1st
- Language : English
- Print length : 560 pages
- ISBN-10 : 0321125215
- ISBN-13 : 978-0321125217
- Item Weight : 2.75 pounds
- Dimensions : 7.25 x 1.4 x 9.6 inches
- Best Sellers Rank: #37,856 in Books (See Top 100 in Books)
- Customer Reviews:
About the author
Eric Evans is a thought leader in software design and domain modeling. The founder of Domain Language and author of Domain-Driven Design, he recently founded a modeling community where those interested in domain modeling can come together to learn and discuss effective practices. He’s worked on successful Java and Smalltalk projects in fields including finance, shipping, insurance, and manufacturing automation.
Eric looks for opportunities to help organizations to get more value from their software development efforts by connecting technical thinking with business thinking—and developing supple domain models that form the heart of software applications. He conducts workshops and coaches teams on strategic design and domain modeling. He aslo, mentors teams to smoothly mesh design and process best practices and bring those techniques to bear on effectively delivering core value.
For information on the trainings Eric and his staff provide, visit his website at www.domainlanguage.com.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonCustomers say
Select to learn more
Top reviews from the United States
There was a problem filtering reviews. Please reload the page.
- Reviewed in the United States on July 15, 2004Format: HardcoverVerified PurchaseI read this book in its draft form on a cross-country flight and was just blown away by it, enough so that I bought a bound version to make it easier to carry around and reread.
I suppose what blew me away was that Evans crystallized and laid out quite clearly about a dozen ideas which were existing at the edge of my consciousness, but which I could not clearly verbalize.
It fits quite nicely between the patterns books and the process books, but it's not a cookbook and it's not strictly a method. It's a must read for the multitude of Java/C#/C++ developers who continue to write procedural code while claiming they're OO developers because they're using an OO language and they've read Design Patterns. - Reviewed in the United States on December 26, 2025Format: HardcoverVerified Purchasea timeless classic that is especially relevant now
- Reviewed in the United States on June 19, 2025Definitely there were chapters that were easy to read and some others hard to follow. I feel like some instances of the objects he proposed would have made the diagrams easier to read like the Route, Leg, Itinerary, etc
- Reviewed in the United States on August 16, 2013Format: HardcoverVerified PurchaseThe book explains concepts and patterns very well. Each definition comes along with a good example to make the whole idea clearer. Each pattern can solve only a class of problems and Eric Evans highlights when and why to apply a specific pattern, also provides scenarios to combing patterns for a more expressive system.
Principles that must be present in a software project are highlighted (such as communication through a language used by all team members, a language that is built from discussions with domain experts). Importance of software design and how it favors problem solving and clear communication between team members and teams.
For a while I was looking at refactoring as a "thing to do when the software is done if time allows it", Eric Evans highlights refactoring as a necessity and must not be neglected because continuous refactoring leads to deeper knowledge and understanding of what the Software needs to do and how it actually does it.
Practical problems such as the possibility of multiple models to exist within the same system have been addressed and given solutions from using one common (unified) model in the whole system (also the costs of such a choice are presented) to totally independent models. An algorithm described in steps is presented for getting two totally independent models to be completely unified allows designers and developers to combine any part of their software towards new features required by the business.
Also a common problem at this time is integration with legacy systems (there are lots of systems that were written using old, now unreliable, components that need migration towards newer, safer, faster components), this problem is approached and it's solution is detailed from beginning to end where the system is completely migrated.
Last but not least, a small oriented graph is given to visualize how concepts in the book are connected and how all pieces fall into the puzzle. Any software developer should read this book at least one time. - Reviewed in the United States on June 25, 2022Format: KindleVerified PurchaseI figured this would be a good addition for someone without a lot of formal education in software development. This is a great read that will validate a lot of your latent knowledge in software design, including layered architecture, common patterns, and all the things to watch out for when designing robust software.
- Reviewed in the United States on June 19, 2016Format: HardcoverVerified PurchaseThis is serious book about domain modeling in software design. Software development society lives from one hype wave to another. OOP, patterns, XP, TDD, CI/CD, BigData, DevOps - this is just to name few. This book is originated from golden age of OOP. The author admits that object oriented paradigm is not the only one available but the bias toward OOP/OOD is obvious (and justifiable). This book tells about how to do the modeling of core software components “the right way”.
With fast pace of modern software development, it’s easy to forget that the main part of software value is in its “brains”. You can change GUI technology or infrastructure layer. You even can totally rewrite your application but the application domain stays more or less the same and at the end of the day the model defines whether this software is useful or not.
I can say that this book is targeting architects, domain experts, business analysts (and I believe these professionals are the main audience) but this would be the usual fallacy of separating software developers into first and second class. So I say the opposite – if you want to transcend from craft of software development to its art you should read this book. - Reviewed in the United States on December 28, 2013Format: HardcoverVerified PurchaseDo not be afraid by the publish date of this book (2003). Its concepts are timeless!
Every mid- to senior-level developer who is serious about their craft must read this book. I am confident that well written (i.e. SOLID), maintainable software is impossible to achieve without a model-driven design perspective. Simply using "design patterns" is not enough. This book gives you the knowledge behind model-driven design (or Domain-Driven design) and how to apply it (albeit in abstract ways--as every software project and its requirements are different--better stated, you just need to practice the concepts within and gain experience with them in order to more effectively use them over time).
I read a copy of this years ago, but at my level of software development maturity, I was not ready for the concepts presented and found it difficult to read. Having a few more years under my belt, I decided to purchase my own copy (Hardback, no less!!) and immediately began to read it again. I am truly excited about what I'm (re)learning in this book and can't wait to begin trying to view software systems and business requirements through the lens of model-driven design. - Reviewed in the United States on April 24, 2021Format: KindleVerified PurchaseClassic DDD book. It's full of great ideas and examples. Some of the aspects of modern development are not in line with the book (it's almost 20 years old), but I think it's still brings great value.
Top reviews from other countries
- ThiagoReviewed in Brazil on December 25, 2020
5.0 out of 5 starsDDD
Format: KindleVerified PurchaseEric Evans, tal qual outros renamados autores da área já declararam sobre está obra, entrega muito conteúdo de grande relevância para quem lida com desenvolvimento de software. É um livro mandatório no assunto - Amazon CustomerReviewed in India on May 25, 2021
5.0 out of 5 starsSystem Architecture
Format: KindleVerified PurchaseIf you are a practicing architect, this book is good fun. Every concept you read, you'll catch yourself cross checking if you'd done it in a similar way! You reminisce, and that's a good thing. - Jurriaan RuitenbergReviewed in the Netherlands on May 1, 2024
2.0 out of 5 starsOld and hard to read
Format: KindleVerified PurchaseI know this is _the_ book about ddd. But I found it a very hard read. Endless chapters, that feel more like rambling than concrete examples and theory. Having recently seen a video with the author explains a lot, since that too became a longwinded rambling. So I guess in it time this book was ground breaking and the theory is still actual and solid. However the book is not. Trying to solve problems that long since have been solved by well designed frameworks and languages does not help conveying the message. By now there are better books handling the subject - Wojciech NowickiReviewed in Poland on June 14, 2021
5.0 out of 5 starsSoftware development is not only the technology
Format: HardcoverVerified PurchaseSoftware development is more than just the technology used. Although this book was written almost twenty years ago it didn't run out of date. A good foundation for a DDD journey. This is a must-read for senior software developers and architects and product owners, business analysis, or even managers in tech companies.
I can call it one of the most important books about software design I've ever read! - isanReviewed in Mexico on April 3, 2023
5.0 out of 5 starsA most have
Format: HardcoverVerified PurchaseWhat else to say about the blue book?
Only that you should read it
