As we know, the production process of software is: analysis, design, programming, testing, and deployment. In the past, the analysis and design of software were separated. As a result, the results of software requirement analysis cannot be directly designed and programmed, while the code that can be programmed and run distorts the requirements, causing customers to find that many functions are not what they want only after running the software, and the software cannot quickly follow the changes of requirements.

Domain-driven design breaks down this gap, introduces the concept of domain models, unifies analysis, design and programming of software, and makes software more flexible and fast to follow changing requirements. However, we must recognize that domain modeling is an artistic technique, not a mathematical technique, and it is a solution for complex software to rapidly adapt to changing requirements (i.e. software reuse that quickly adapts to changing requirements).

Domain models enable developers to express rich software functionality requirements, and the resulting software can meet the real needs of users. Therefore, they are recognized as the key to software design, and their importance is obvious. But there isn’t much good, practical information on how to use domain models in the software development process. Domain-Driven Design: Tackling Complexity in the Heart of Software is the most famous classic book in this field, which has been praised and promoted by many industry masters, and well received by the majority of worldwide readers.

This book combines the real project cases, systematically introduces the goals, meanings and methods of domain-driven development, and fully discusses the modeling and design problems of complex systems. It can guide object-oriented developers, system analysts and designers to organize their work properly, to have different focus and cooperate with each other, to develop complex systems in an orderly way, helping them build rich and practical domain models, and thus creating long-term quality software.

// Covered Topics //

• 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

// Table Of Contents //

• I. PUTTING THE DOMAIN MODEL TO WORK
  • 1. Crunching Knowledge.
  • 2. Communication and the Use of Language.
  • 3. Binding Model and Implementation.
• II. THE BUILDING BLOCKS OF A MODEL-DRIVEN DESIGN
  • 4. Isolating the Domain.
  • 5. A Model Expressed in Software.
  • 6. The Life Cycle of a Domain Object.
  • 7. Using the Language: An Extended Example.
• III. REFACTORING TOWARD DEEPER INSIGHT
  • 8. Breakthrough.
  • 9. Making Implicit Concepts Explicit.
  • 10. Supple Design.
  • 11. Applying Analysis Patterns.
  • 12. Relating Design Patterns to the Model.
  • 13. Refactoring Toward Deeper Insight.
• IV. STRATEGIC DESIGN
  • 14. Maintaining Model Integrity.
  • 15. Distillation.
  • 16. Large-Scale Structure.
  • 17. Bringing the Strategy Together.
• Conclusion
• Appendix: The Use of Patterns in This Book

// Download URLs //

Format	Download	Size
PDF		3.60 MB

(Homepage | InformIT)