Apply Domain-Driven Design and Microservices Patterns

Last updated 09/2023
English
  06:37:04

Price: FREE

What you'll learn
In nowdays, building microservices on major cloud platforms like Microsoft Azure, Amazon AWS, Google Cloud, Oracle Cloud, and IBM Cloud requires a modern approach to software design. This means understanding core principles like easy maintenance, reusability, testing, high performance, and scalability.

Throughout this course, you'll dive deep into microservices development using the Devprime Platform. We'll also cover best practices in software development. Key topics include Domain-Driven Design (DDD), Event Storming, Hexagonal Architecture, and Event-Driven Architecture (EDA).

The Devprime Platform provides a smart set of tools, making it easier for developers. During the course, you'll see firsthand how these tools can boost your productivity.

We'll focus on Domain-Driven Design (DDD), helping you model business domains and standardize business rules. This not only makes your code easier to maintain and test, but it also boosts your productivity aand helps solve real-world problems.

We'll also cover Hexagonal Architecture, a technique that separates business logic from technical implementation. This promotes code standardization and improves maintainability.

In addition, we'll delve into Event-Driven Architecture (EDA), a strategy for asynchronous communication between microservices. You'll learn about important EDA concepts like Events, Subscriptions, Event Notification Patterns, event loops, and event rejection.

Throughout the course, you'll get hands-on experience with the Devprime platform. This includes features like automatic log tracking, standardized software architecture, and intelligent tools like retry, circuit-breaker, and resilience. These tools make developing microservices a smooth journey towards digital transformation in businesses.

This course offers practical insights that address common challenges faced by developers. Learning to navigate these challenges not only saves time but also enpowers you with valuable skills to modernize applications and build high-performing, scalable software.
Course Content

In this chapter we will see the basic course structure. The course source code is available
  • Summary   00:01:58

Origin and definition, how to create software that solves real-world problems, engagging together business teams and I.T teams
  • Introduction to domain driven design   00:00:43
  • Origin and definition   00:01:29
  • Create software that solves real world problems   00:01:10
  • Connect your team to business experts   00:01:32
  • Technical team speaking business language   00:00:59
  • Every subdomain has its own language   00:01:04
  • Behaviors are more important than properties   00:02:54
  • Domain events   00:01:40
  • Domain subdomain and bounded context   00:01:44
  • Coexistence of legacy and anti-corruption layer   00:00:00
  • Strategic DDD and tatical DDD   00:01:39
  • What did we learn   00:00:53

Creating bounded contexts and context maps, separate concerns don't leak responsibilities
  • Introduction to domain driven design   00:00:43
  • Define business domain   00:01:44
  • Estabilish a stopping point   00:01:32
  • Find the bounded contexts   00:01:39
  • The same ter mean a different thing on a different context   00:01:42
  • Separate concerns and dont leak responsabilities   00:00:48
  • Checkout and Billing (context leaks)   00:01:01
  • Context map   00:01:15
  • Customer registration propagates to help desk   00:00:54
  • Product changes propagates from stock to the store front   00:00:42
  • What did we learned   00:00:30

Introducing all domain build-blocks that we need to describe business rules inside one bounded context (Aggregates, Entities, Value Objects and Domain Services)
  • Understand tatical DDD   00:00:35
  • What is tatical domain drive design   00:00:48
  • Rich or anemic domains   00:02:02
  • What is an Entity   00:02:07
  • What is a value object   00:02:53
  • When to use entity or value object   00:00:53
  • What is an aggregate   00:00:41
  • What is an aggregate root   00:01:49
  • What is the role of a domain service   00:02:26
  • What is a domain event   00:00:47
  • Difference between domain event and value object   00:00:43
  • Difference between domain service and domain event   00:00:30
  • Shared value objects   00:00:59
  • Shared domain event   00:01:05
  • What did we learn   00:00:34

Understanding the business narrative, and the knowledge distribution to modeling business scenario
  • Introduction to Event storming   00:00:19
  • Origin and definition   00:00:43
  • The knowledge distribution   00:02:25
  • The workshop   00:02:36
  • Understand the business narrative   00:02:28
  • The context map   00:01:26
  • Modeling our scenario   00:03:12
  • What did we learn   00:00:19

In this video we are going to implement the most common domain patterns, see how to use Aggregates, Entities, Value Objects and Domain Services
  • Implementing business classes   00:45:17

An overview of hexagonal architecture in a real-life application
  • Understand Hexagonal Architecture   00:00:31
  • Introduction of hexagonal architecture   00:02:13
  • Separation of concerns   00:01:04
  • What are adapters   00:01:24
  • Driving adapters, driven adapters   00:01:15
  • application layer   00:01:18
  • The interface mechanism   00:00:54
  • Mapping inputs and outputs   00:00:44
  • Keep the domain decoupled   00:03:23
  • Using external libraries   00:00:56
  • What did we learn   00:00:28

Let's understand each component inside architecture, what does the dp init exactly changes
  • Exploring code generation in pratice   00:42:02

Let's see some common mistakes that people does when modeling domain classes
  • Common mistakes in business rules modeling   00:43:46

An if I need to reference one aggregate root from another? How would I do that?
  • Explore aggregate roots interactions   00:31:40

We need to enforce consistency in our microservices scenario, and there are two important concepts that we need to keep in mind: Local Transactions and Idempotency.
  • Aggregate roots in consistency scenarios   00:28:39

Emitting events, detecting and reacting to events, event carried state transfer, event notification, events contracts
  • Developing event-driven applications   00:45:26

Even though we are living in the microservices time, there are no blocking in create monolith applications with devprime, actually they also have a huge fit due to devprime's capacity to separete concerns, responsabilities and to organize developer's code.
  • Split monolith application to microservices   00:30:10

Projects are living beings and they change during the time, so sometimes we start from two saparated applications and them we need to merge them together as a single one
  • Unifying different aggregates and related classes   00:31:14

Devprime provides a fully decoupled architecture so we can change components at any time we need, because of new features or even changes in technology during the life-time of our projects
  • Exploring modern software architecture on devprime   00:22:05
Last updated 09/2023
English
  06:37:04

Price: FREE