CoursesAI WorkshopCompaniesPricingBlogNewsletter
  • Courses
  • AI Workshop
  • Companies
  • Pricing
  • Blog
  • Newsletter
Subscribe
  • Courses
  • Companies
  • Communities
  • Blog
  • Gift card
  • Newsletter
  • Help
  • Shop
  • ConfAiBot
  • Contact
  • Legal notice
  • General conditions
  • Privacy policy
  • Cookies policy

Course of Domain-Driven Design: DDD Applied

Standard
Javier FerrerRafa Gómez

By Javier Ferrer y Rafa Gómez – Software Design and Architecture

Learn to model your applications focusing on your domain, define Bounded Contexts, aggregates, value objects, and much more. All in a practical way with code examples.

Go to course

💸 First lesson available without registration!

In the Event-Driven Architecture course we analyze how the different services of our company communicate, but… How do we model the services and applications of our company?

If we want to model a complex system, we need to complement principles and techniques like the SOLID principles or Hexagonal Architecture with a strategic part. This is where Domain-Driven Design (DDD) comes in.

DDD acts as an umbrella grouping a whole series of concepts at a technical and strategic level to promote:

  • Collaboration between business or product and the technical team to model in code the specific problems of a certain domain (Bounded Contexts, Ubiquitous Language, Aggregates, Value Objects, Domain Events, Entities, Repositories…)
  • Focusing our application on the domain. Maintaining a high tolerance for change and evolution of systems over time
  • High testability of our business logic by decoupling from the infrastructure
  • Facilitating collaboration between different development teams

What we will see in this course:

  • How to define Bounded Contexts and Modules
  • Differences between Bounded Contexts, Subdomains, Modules, and Shared Kernel
  • Folder structure in a monorepository with multiple applications and Bounded Contexts
  • Implementation examples of monorepo in PHP, Java, and Scala
  • Hexagonal Architecture
  • Value Objects: Modeling our domain
  • What is an aggregate and what is it for
  • Aggregate root vs Entity
  • Repository Pattern
  • Role interfaces vs Header interfaces
  • Communication between Modules and Bounded Contexts
  • Migrating from legacy systems thanks to the Anti-Corruption Layer
  • Domain Events
  • Shared Kernel: What do we share between Bounded Contexts
  • CQRS in DDD
  • Read Model: Optimizing for read
  • Promoting a Module to Bounded Context
  • Ubiquitous Language: How to bring everyday jargon into code

This course is agnostic to programming language; however, to avoid it being pure theory, we will see implementation examples in PHP, Java, and Scala.

This course complements the courses on SOLID, Hexagonal Architecture, CQRS, Communication between [micro]services with Event-Driven Architecture, and CQRS and Event-Sourcing.

Therefore, we recommend that you first take the ones that interest you the most to have those concepts clear, and then delve into the more strategic concepts with this DDD course. For only €30, you have access to all courses!

Here is the first video of the course so you can get an idea of the quality of the content 😬

Videos of the course

  • DDD in 20 minutes

  • How to define Bounded Contexts
  • Differences between Bounded Contexts, Subdomains, Modules, and Shared Kernel
  • Folder structure in a monorepository
  • Let's review!
  • Let's practice! Define your Bounded Contexts

  • Flow of a request in Hexagonal Architecture
  • Our first use case: Student Sign Up
  • Let's review!
  • Let's practice! Create a use case

  • Refactoring to Value Objects
  • Where to put validations?
  • Let's review!
  • Let's practice! Adding Value Objects

  • Introduction to aggregates - Real World™️ Problems
  • Aggregate root vs Entity: Example Video and VideoHighlight
  • Miserably failing to model Aggregates 👼
  • Let's review!
  • Let's practice! Aggregates and Real World Entities

  • Refactoring Student Sign Up applying repository
  • Role interfaces vs Header interfaces
  • Communicate modules and Bounded Contexts: Repositories vs Application Service
  • Let's review!
  • Let's practice! Adding repository

  • How and why to decouple between modules and Bounded Contexts
  • Refactoring the use case by adding event publishing
  • Let's review!
  • Let's practice! Publishing events

  • Defining contracts at the domain interface level
  • Defining contracts at the domain event level
  • Implementing domain events
  • Let's review!
  • Let's practice! Listening to events

  • What we share between Bounded Contexts
  • Let's review!
  • Let's practice! Reviewing Shared

  • Request flow CQRS vs Hexagonal
  • Communicate modules and Bounded Contexts: Application Service vs Query Bus
  • Let's review!
  • Let's practice! Refactoring to CQRS

  • Communicate modules and Bounded Contexts: Query Bus vs Events
  • New feature: Total hours of a course
  • Let's review!
  • Let's practice! Querying via Query

  • Avoiding JOINs by denormalizing Read Model
  • Alternatives to add information
  • Let's review!
  • Let's practice! Adding information

  • Promoting the module Notifications to Bounded Context
  • Let's review!
  • Let's practice! Promoting to Bounded Context

  • Monorepo vs. Multirepo
  • 🐘 Monorepo in PHP
  • ☕ Monorepo in Java
  • 🧬 Monorepo in Scala
  • Let's review!
  • Let's practice! Knowing the application structure

  • Ubiquitous language and outside-in workflow in DDD
  • Let's review!
  • Let's practice! Designing new features

  • How to convince the team to apply DDD
  • Synchronous vs. Asynchronous buses? Integration in framework?
  • Transactionability? Sagas? Aggregates Logic?
  • Let's review!

  • A bit of a mess with the Tell, Don't Ask
  • Relationship between Bounded Contexts and Applications
  • Create a Validator that uses Value Objects in the Controller

  • Conclusion and next steps
  • Course improvement feedback and next steps
Go to course

Related courses

Standard
Design patterns: Inbox and Outbox

📬 Design patterns: Inbox and Outbox

Javier FerrerRafa Gómez

Learn when to use (and when not to use) the Inbox and Outbox patterns.

See course
Standard
Event Bus in a Database [Infrastructure Design]

🚏 Event Bus in a Database [Infrastructure Design]

Javier FerrerRafa Gómez

Add scalability by using your own database as an event bus.

See course
Standard
Green Slope Audit

🟢 Green Slope Audit

Javier FerrerRafa Gómez

Audit session where we review Green Slope's Software Design and Architecture.

See course
See full catalogue

Pay according to your needs

lite (only monthly)

19 €
per month
  • Essential programming courses to build a solid foundation
Popular

standard

24,92 €
Discount vs monthly of 49 €
Annual payment of 299 €
per month
  • Main catalog to master writing maintainable, scalable, and testable code
  • Receive job offers verified by Codely
  • Company invoice
  • Accumulate renewal discounts

premium

41,58 €
Discount vs monthly of 89 €
Annual payment of 499 €
per month
  • Exclusive AI courses to keep you always up to date
  • Early access to new courses
  • Discount on workshops
  • Receive job offers verified by Codely
  • Company invoice
  • Accumulate renewal discounts

We won't increase the price while your subscription is active

SubscribeSign in