Domain-Driven Design in Practice

Introduction
Have you ever felt that the topic of domain-driven design is too big, and you struggle to understand how to start applying its concepts in your own project? Or maybe you had a hard time to combine them with other well-known practices, such as unit testing and technologies, such as relational databases and object relational mappers. If so, you are on the right track. In this course, I'm going to show step by step how to grow an application from the very beginning to a full-fledged solution with DDD principles in mind. You will see the full process of building a software project using such concepts as entities, value objects, aggregates, repositories, bounded contexts, and domain events. Not only this, I will give detailed annotations along the way and explain why we make one decision over another. You will learn what DDD concepts are application in what particular case and why it is so. My name is Vladimir Khorikov and this is the Domain-Driven Design in Practice course in which I'm going to show how to apply the domain-driven design principles in a real world application, the thing I've been doing for more than five years now. Let's dive in.

Starting with the First Bounded Context
Hello, my name is Vladimir Khorikov, and this is the Domain-Driven Design in Practice course, starting with the first bounded context. In this module, we will begin the actual development process. We'll start off with the basic functionality for our model of a snack machine, inserting coins and notes to the machine and returning the money. You will see how entities differ from value objects and learn the best practices for working with them.

Introducing UI and Persistence Layers
Hello. My name is Vladimir Khorikov and this is the Domain-Driven Design in Practice course, Introducing UI and Persistence Layers. In this module, we will talk about the user interface and the database for our domain model. We will see how they feed the application built with the domain-driven design principles in mind, and how to work with the object-relational mapper in a way that allows us to keep our domain model simple and clean.

Extending the Bounded Context with Aggregates
Hello, my name is Vladimir Khorikov and this is the Domain-Driven Design in Practice course, Extending the Bounded Context with Aggregates. In this module, we will extend our SnackMachine model with the actual purchase functionality. Along the way, we will discuss best practices for working with aggregates, and we'll see how they are applicable to our project.

Introducing Repositories
Hello, my name is Vladimir Khorikov and this is the Domain-Driven Design in Practice course. In this module, we will talk about repositories. We will see how they are applicable to our project and what the best practices for working with them are.

Introducing the Second Bounded Context
Hello, my name is Vladimir Khorikov and this is the Domain-Driven Design in Practice course. In this module, we'll introduce the second bounded context in our application. Along the way, we'll discuss the differences between bounded contexts and sub-domains, and how they relate to each other. We will also talk about how to choose boundaries for them and how to perform context mapping. We will look at different types of physical isolation for bounded contexts, how they communicate with each other, and finally, we'll discuss the guidelines for using code between them.

Working with Domain Events
Hello, my name is Vladimir Khorikov and this is the Domain-Driven Design in Practice course. In this module, we will talk about domain events. We will see when they are applicable and how to actually represent them in code. We'll discuss two different ways to work with domain events, and we'll see which of them is better and why.

Looking Forward to Further Enhancements
Hello, my name is Vladimir Khorikov and this is the Domain-Driven Design in Practice course. In this module, we will discuss DDD concepts that we didn't cover in our sample project, and some further possible ways in which our application can evolve in the future. We will also look at some common anti-patterns programmers employ when they start applying DDD principles in practice.