- Good knowledge in OOP, UML, and Design Patterns
Audience
- Full-stack developers, technical domain experts and enterprise architects
In this course, you’ll learn the key concepts and means to implement DDD. As given the outlines is supposed to be given in two days, each day contains (from 5 to 6 hours), after the attendees start getting the required skills of DDD and because DDD offers invaluable insights regarding developing enterprise-level software projects, , we'll go through the whole process of building an application from the very beginning using the DDD principles.
As the Client request, we will not only work on green-field projects. We are most likely working on a legacy project.
By the end of this training,
- The attendees will explore how to model a software problem.
- The attendees will discover the elements of DDD.
- The attendees will learn how to leverage DDD in a sample software application.
- When finishing Day 1 with this course, the attendees will begin to have the skills and knowledge of DDD needed to tackle the complexity of their domain, build smarter software, and then starting to gain adeeper understanding of DDD.
- Giving strong foundation for learning how to build applications and microservices using DDD.
- Going through the process of building an application from the very beginning using the DDD principles
- The attendees and the trainer together will learn and collaborate how to make their way through the legacy system (a monolithic system with complicated business logic such as terminal operation system) by refactoring it one step at a time and when it is better to keep the existing legacy code base instead.
Resources & References
Domain-Driven Design, Eric Evans, 2003, Addison-Wesley , Professional amzn.to/3k7g948
Patterns, Principles, and Practices of Domain-Driven Design , Scott Millett, Nick Tune, 2015, Wrox amzn.to/2ZyaNH8
Domain-Driven Design, The First 15 Years, Essays from the community , leanpub.com/ddd_first_15_years
Getting to DDD: Pragmatic or Principled , Julie Lerman, KanDDDinsky 2018 youtu.be/CPd2BVR3hEM
Day 1
1. Introducing Domain-Driven Design
- Why DDD? Its advantages and Potential Drawbacks.
- Inspecting a Mind Map of DDD (Strategic and Tactical).
- Strategic Design (Ubiquitous Language, Context Maps and Bounded Context)
- Tactical Design (Layered Architecture, Entities, Value Objects, Services Modules, Aggregates, Factories, Repositories)
- Example, given as a Sample Application of some of the DDD principles, may be developed in C# (or any other Language),
2. Modeling Problems in Software
- Conversation with a Domain Expert, using Bounded Contexts and subdomains,
- Introducing Context Maps
- Separate Databases per Bounded Context and Specifying it in the Application.
- Understanding the Ubiquitous Language of a Bounded Context
3. Elements of a Domain Model
- Focusing on the Domain & Identifying Events Leads to Understanding Behaviors.
- Refactoring From Anemic Models to Rich Domain Models.
- Understanding Entities & Differentiating CRUD from Complex Problems, then Switching Between Contexts at the level of UI.
- Implementing Entities in Code and Synchronizing Data Across Bounded Contexts.
4. Understanding Value Objects & Services in the Model
- Recognizing Commonly Used Value Objects and Implementing it in Code.
- Understanding Domain Services as initiative to microservices.
5. Tackling Complexity with Aggregates
6. Working with Repositories
- Avoiding Repository Blunders and Considering Generic Repositories & Interfaces
- Specification Pattern
Day 2
1. Adding in Domain Events and Anti-corruption Layers
2. Evolving the Application Easily
3. The DDD Layered Architecture
4. Introducing UI and Persistence Layers
5. The CQRS Supporting Architecture
6. Event Sourcing
7. Exploring the Ways of Dealing with the Legacy Project