Learning Domain-Driven Design: Aligning Software Architecture and Business Strategy 1st Edition Table Of Content

Foreword

Preface

1. Why I Wrote This Book
2. Who Should Read This Book
3. Navigating the Book
4. Example Domain: WolfDesk
5. Conventions Used in This Book
6. Using Code Examples
7. O’Reilly Online Learning
8. How to Contact Us
9. Acknowledgments

Introduction

I. Strategic Design

1. Analyzing Business Domains

1. What Is a Business Domain?
2. What Is a Subdomain?
3. Types of Subdomains
4. Comparing Subdomains
5. Identifying Subdomain Boundaries
6. Domain Analysis Examples
7. Gigmaster
8. BusVNext
9. Who Are the Domain Experts?
10. Conclusion
11. Exercises

2. Discovering Domain Knowledge

1. Business Problems
2. Knowledge Discovery
3. Communication
4. What Is a Ubiquitous Language?
5. Language of the Business
6. Scenarios
7. Consistency
8. Model of the Business Domain
9. What Is a Model?
10. Effective Modeling
11. Modeling the Business Domain
12. Continuous Effort
13. Tools
14. Challenges
15. Conclusion
16. Exercises

3. Managing Domain Complexity

1. Inconsistent Models
2. What Is a Bounded Context?
3. Model Boundaries
4. Ubiquitous Language Refined
5. Scope of a Bounded Context
6. Bounded Contexts Versus Subdomains
7. Subdomains
8. Bounded Contexts
9. The Interplay Between Subdomains and Bounded Contexts
10. Boundaries
11. Physical Boundaries
12. Ownership Boundaries
13. Bounded Contexts in Real Life
14. Semantic Domains
15. Science
16. Buying a Refrigerator
17. Conclusion
18. Exercises

4. Integrating Bounded Contexts

1. Cooperation
2. Partnership
3. Shared Kernel
4. Customer–Supplier
5. Conformist
6. Anticorruption Layer
7. Open-Host Service
8. Separate Ways
9. Communication Issues
10. Generic Subdomains
11. Model Differences
12. Context Map
13. Maintenance
14. Limitations
15. Conclusion
16. Exercises

II. Tactical Design

5. Implementing Simple Business Logic

1. Transaction Script
2. Implementation
3. It’s Not That Easy!
4. When to Use Transaction Script
5. Active Record
6. Implementation
7. When to Use Active Record
8. Be Pragmatic
9. Conclusion
10. Exercises

6. Tackling Complex Business Logic

1. History
2. Domain Model
3. Implementation
4. Building Blocks
5. Managing Complexity
6. Conclusion
7. Exercises

7. Modeling the Dimension of Time

1. Event Sourcing
2. Search
3. Analysis
4. Source of Truth
5. Event Store
6. Event-Sourced Domain Model
7. Advantages
8. Disadvantages
9. Frequently Asked Questions
10. Performance
11. Deleting Data
12. Why Can’t I Just…?
13. Conclusion
14. Exercises

8. Architectural Patterns

1. Business Logic Versus Architectural Patterns
2. Layered Architecture
3. Presentation Layer
4. Business Logic Layer
5. Data Access Layer
6. Communication Between Layers
7. Variation
8. When to Use Layered Architecture
9. Ports & Adapters
10. Terminology
11. Dependency Inversion Principle
12. Integration of Infrastructural Components
13. Variants
14. When to Use Ports & Adapters
15. Command-Query Responsibility Segregation
16. Polyglot Modeling
17. Implementation
18. Projecting Read Models
19. Challenges
20. Model Segregation
21. When to Use CQRS
22. Scope
23. Conclusion
24. Exercises

9. Communication Patterns

1. Model Translation
2. Stateless Model Translation
3. Stateful Model Translation
4. Integrating Aggregates
5. Outbox
6. Saga
7. Process Manager
8. Conclusion
9. Exercises

III. Applying Domain-Driven Design in Practice

10. Design Heuristics

1. Heuristic
2. Bounded Contexts
3. Business Logic Implementation Patterns
4. Architectural Patterns
5. Testing Strategy
6. Testing Pyramid
7. Testing Diamond
8. Reversed Testing Pyramid
9. Tactical Design Decision Tree
10. Conclusion
11. Exercises

11. Evolving Design Decisions

1. Changes in Domains
2. Core to Generic
3. Generic to Core
4. Supporting to Generic
5. Supporting to Core
6. Core to Supporting
7. Generic to Supporting
8. Strategic Design Concerns
9. Tactical Design Concerns
10. Transaction Script to Active Record
11. Active Record to Domain Model
12. Domain Model to Event-Sourced Domain Model
13. Generating Past Transitions
14. Modeling Migration Events
15. Organizational Changes
16. Partnership to Customer–Supplier
17. Customer–Supplier to Separate Ways
18. Domain Knowledge
19. Growth
20. Subdomains
21. Bounded Contexts
22. Aggregates
23. Conclusion
24. Exercises

12. EventStorming

1. What Is EventStorming?
2. Who Should Participate in EventStorming?
3. What Do You Need for EventStorming?
4. The EventStorming Process
5. Step 1: Unstructured Exploration
6. Step 2: Timelines
7. Step 3: Pain Points
8. Step 4: Pivotal Events
9. Step 5: Commands
10. Step 6: Policies
11. Step 7: Read Models
12. Step 8: External Systems
13. Step 9: Aggregates
14. Step 10: Bounded Contexts
15. Variants
16. When to Use EventStorming
17. Facilitation Tips
18. Watch the Dynamics
19. Remote EventStorming
20. Conclusion
21. Exercises

13. Domain-Driven Design in the Real World

1. Strategic Analysis
2. Understand the Business Domain
3. Explore the Current Design
4. Modernization Strategy
5. Strategic Modernization
6. Tactical Modernization
7. Cultivate a Ubiquitous Language
8. Pragmatic Domain-Driven Design
9. Selling Domain-Driven Design
10. Undercover Domain-Driven Design
11. Conclusion
12. Exercises

IV. Relationships to Other Methodologies and Patterns

14. Microservices

1. What Is a Service?
2. What Is a Microservice?
3. Method as a Service: Perfect Microservices?
4. Design Goal
5. System Complexity
6. Microservices as Deep Services
7. Microservices as Deep Modules
8. Domain-Driven Design and Microservices’ Boundaries
9. Bounded Contexts
10. Aggregates
11. Subdomains
12. Compressing Microservices’ Public Interfaces
13. Open-Host Service
14. Anticorruption Layer
15. Conclusion
16. Exercises

15. Event-Driven Architecture

1. Event-Driven Architecture
2. Events
3. Events, Commands, and Messages
4. Structure
5. Types of Events
6. Designing Event-Driven Integration
7. Distributed Big Ball of Mud
8. Temporal Coupling
9. Functional Coupling
10. Implementation Coupling
11. Refactoring the Event-Driven Integration
12. Event-Driven Design Heuristics
13. Conclusion
14. Exercises

16. Data Mesh

1. Analytical Data Model Versus Transactional Data Model
2. Fact Table
3. Dimension Table
4. Analytical Models
5. Analytical Data Management Platforms
6. Data Warehouse
7. Data Lake
8. Challenges of Data Warehouse and Data Lake Architectures
9. Data Mesh
10. Decompose Data Around Domains
11. Data as a Product
12. Enable Autonomy
13. Build an Ecosystem
14. Combining Data Mesh and Domain-Driven Design
15. Conclusion
16. Exercises

Closing Words

1. Problem
2. Solution
3. Implementation
4. Further Reading
5. Advanced Domain-Driven Design
6. Architectural and Integration Patterns
7. Modernization of Legacy Systems
8. EventStorming
9. Conclusion

A. Applying DDD: A Case Study

1. Five Bounded Contexts
2. Business Domain
3. Bounded Context #1: Marketing
4. Bounded Context #2: CRM
5. Bounded Context #3: Event Crunchers
6. Bounded Context #4: Bonuses
7. Bounded Context #5: The Marketing Hub
8. Discussion
9. Ubiquitous Language
10. Subdomains
11. Boundaries of Bounded Contexts
12. Conclusion

B. Answers to Exercise Questions

1. Chapter?1
2. Chapter?2
3. Chapter?3
4. Chapter?4
5. Chapter?5
6. Chapter?6
7. Chapter?7
8. Chapter?8
9. Chapter?9
10. Chapter?10
11. Chapter?11
12. Chapter?12
13. Chapter?13
14. Chapter?14
15. Chapter?15
16. Chapter?16

References

Index