The 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.

Do 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.

Definitely 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

An absolute MUST READ for Engineers and Architects, whether you're designing systems, coding them directly, or guiding AI Agents to do your bidding. The lessons taught in this beefy text are nothing short of critical!

This 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.

Though Domain Driven Design was written several years ago, the concepts are still a major game changer for software developers who want to take their careers to the next level.

After reading this book, I realized why many of the projects I was on were so frustrating. As a team, we had failed to employ the patterns described in this book. The UBIQUITOUS LANGUAGE pattern described in the book, helped me understand that I can't just be a code monkey if I want to build successful software. Eric Evans has fantastic insight into what makes well designed code that really understands the problems that it solves.

This is a must have book on your shelf (or on your kindle).

a timeless classic that is especially relevant now

I 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.

Eric 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

Must read for a software developer with any level of experience.

I 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

Cet excellent ouvrage d'Eric Evans est fondateur dans le Domain Driven Design. Il offre une manière carrée et structurée de penser son code, ainsi qu'une approche à développer avec le Responsable du Produit (Product Owner) ou autres experts du domaine. Ce livre a changé ma manière de concevoir des applications.

Je le recommande à tout développeur, tout simplement.

Software 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!