English | MP4 | AVC 1920×1080 | AAC 44KHz 2ch | 79 Lessons (5h 12m) | 1.10 GB
Start your Domain-Driven Design journey
Domain-Driven Design (or DDD for short) is one of the most popular approaches to software development, and that’s for a very good reason. As described excellently by Martin Fowler, it “is an approach to software development that centres the development on programming a domain model with a rich understanding of the processes and rules of a domain”. Building software that way, especially when dealing with a complex domain, leads to aligned business people and developers and better software that does precisely what the business needs. Ever since its formal definition by Eric Evans all the way back in 2003, developers have used it to create software based on a well-developed model of design. In this Getting Started course, Amichai Mantinband will break down Domain-Driven Design into a very easily digestible concept using his real-world experience.
Table of Contents
1 Welcome
2 What will you learn in this course
3 Who is the course for and prerequisites
4 What is Domain-Driven Design
5 What is a Domain
6 Why you should learn and practice DDD
7 The two parts of DDD
8 Section Recap
9 The domain we’ll be exploring
10 The domain’s Ubiquitous Language
11 Ubiquitous Language as a tool for detecting Domain Objects
12 The domain’s invariants
13 Enforcing invariants
14 Creating the domain objects
15 Invariants as Unit Tests
16 Enforcing Invariants that rely on dependencies
17 The Result Pattern
18 Section Recap,
19 What are Tactical Patterns
20 What is Tactical Design
21 Entities
22 Implementing the Entity base class
23 Value Objects
24 Implementing the Value Object base class
25 Aggregates
26 Shifting the focus to Aggregates
27 Implementing the Aggregate base class
28 Structuring the Domain Layer around Aggregates
29 Domain Services
30 Factories
31 Implementing a Static Factory Method
32 Repositories
33 Disconnected Domain Models
34 Repositories and EF Core
35 Implementing a Repository
36 Section Recap2
37 Accessing the Domain Layer via a web API
38 A system without Domain Events
39 Eventual Consistency
40 What is a Domain Event
41 The Domain Event Sausage Factory
42 Implementing a Domain Event
43 Section Recap3
44 Domain Modeling & Analysis Paralysis
45 Domain Model Identity Uniqueness
46 Domain Object Deletion
47 One Aggregate Per Transaction
48 Reference Between Domain Models
49 Section Recap
50 Application Services vs Domain Services
51 Transactional vs. Eventual Consistency
52 Rich vs. Anemic Domain Models
53 Always Valid vs. Not Always Valid
54 Persistence Ignorance
55 Section Recap4
56 What is Strategic Design
57 Sub-Domains
58 The 3 types of Sub-Domains
59 Context Mapping and Context Maps
60 Context Map example
61 Team Relationships
62 Context Map Patterns
63 Section Recap5
64 Bounded Contexts
65 Bounded Contexts vs. Sub-Domains (Problem vs. Solution Space)
66 Exploring our Domain’s Bounded Contexts
67 Exploring relationships between our Bounded Contexts
68 Defining our Context Map
69 Section Recap6
70 What are Integration Events
71 The chain of Integration and Domain Events
72 Using a Message Broker for distributing Integration Events
73 Error handling when publishing Integration Events
74 The Outbox Pattern
75 The Integration Events Sausage Factory – Outbox Writer
76 The Integration Events Sausage Factory – Integration Event Publisher
77 The Integration Events Sausage Factory – Consuming Integration Events
78 Section Recap7
79 Course conclusion
Resolve the captcha to access the links!