Getting Started: Domain-Driven Design

What is Domain-Driven Design? (1:27)

What is a Domain? (4:26)

Why you should learn and practice DDD (2:19)

The two parts of DDD (4:57)

Section Recap (1:47)

The domain we’ll be exploring (6:06)

The domain’s Ubiquitous Language (4:30)

Ubiquitous Language as a tool for detecting Domain Objects (3:41)

The domain’s invariants (3:00)

Enforcing invariants (2:44)

Creating the domain objects (5:20)

Invariants as Unit Tests (10:41)

Enforcing Invariants that rely on dependencies (12:22)

The Result Pattern (10:08)

Section Recap (2:10)

What are Tactical Patterns? (3:15)

What is Tactical Design? (3:33)

Entities (3:49)

Implementing the Entity base class (2:23)

Value Objects (7:29)

Implementing the Value Object base class (2:39)

Aggregates (6:02)

Shifting the focus to Aggregates (6:16)

Implementing the Aggregate base class (1:09)

Structuring the Domain Layer around Aggregates (8:34)

Domain Services (5:32)

Factories (3:34)

Implementing a Static Factory Method (5:05)

Repositories (4:40)

Disconnected Domain Models (1:40)

Repositories and EF Core (3:18)

Implementing a Repository (3:14)

Section Recap (1:16)

Accessing the Domain Layer via a web API (4:49)

A system without Domain Events (6:45)

Eventual Consistency (1:16)

What is a Domain Event? (5:27)

The Domain Event Sausage Factory (6:43)

Implementing a Domain Event (6:41)

Section Recap (1:23)

Domain Model Identity Uniqueness (2:28)

Domain Modeling & Analysis Paralysis (1:41)

Domain Object Deletion (3:38)

One Aggregate Per Transaction (3:21)

Reference Between Domain Models (3:43)

Section Recap (0:55)

Application Services vs Domain Services (5:11)

Transactional vs. Eventual Consistency (5:08)

Rich vs. Anemic Domain Models (3:57)

Always Valid vs. Not Always Valid (2:32)

Persistence Ignorance (1:09)

Section Recap (1:20)

What is Strategic Design? (4:41)

Sub-Domains (3:30)

The 3 types of Sub-Domains (3:40)

Context Mapping and Context Maps (4:14)

Context Map example (4:43)

Team Relationships (1:44)

Context Map Patterns (3:07)

Section Recap (1:18)

Bounded Contexts (5:29)

Bounded Contexts vs. Sub-Domains (Problem vs. Solution Space) (5:17)

Exploring our Domain’s Bounded Contexts (4:06)

Exploring relationships between our Bounded Contexts (5:00)

Defining our Context Map (5:00)

Section Recap (1:09)

What are Integration Events? (2:46)

The chain of Integration and Domain Events (4:21)

Using a Message Broker for distributing Integration Events (4:29)

Error handling when publishing Integration Events (3:56)

The Outbox Pattern (4:25)

The Integration Events Sausage Factory - Outbox Writer (4:18)

The Integration Events Sausage Factory - Integration Event Publisher (1:56)

The Integration Events Sausage Factory - Consuming Integration Events (5:17)

Section Recap (0:45)

Conclusion (1:31)