Implementing Domain-Driven Design

Dépassez la théorie et plongez au coeur de la réalisation logicielle

Aperçu du cours

Atelier IDDD intensif sur trois jours, conduit par Vaughn Vernon

Dépassez la théorie du DDD et estimer comment votre équipe peut réellement l’utiliser pour accélérer vos initiatives stratégiques et ainsi apporter un avantage concurrentiel pour votre entreprise. L’accent est mis sur le développement logiciel artisanal en intégrant les concepts du domaine métier dans le code source, ceci dans le cadre de processus agiles, et afin de supporter de véritables initiatives stratégiques.

L’événement s’adresse aux développeurs de logiciels de niveau senior et intermédiaire, et aux architectes qui s’intéressent à l’artisanat logiciel et à la modélisation du domaine en utilisant l’approche Domain-Driven Design (DDD).

Si votre organisation cherche une voie à suivre avec les architectures Microservices, considérez cet atelier comme une base essentielle.

Il s’agit d’un atelier pratique. Les participants sont encouragés à s’engager dans des exercices organisés en atelier, et à implémenter des contextes ubiquitaires DDD avec des Microservices dynamisés par évènements. Ce développement logiciel intègre les conceptions DDD stratégique et tactique.

Cet atelier est conduit par  Vaughn Vernon l’auteur des livres Implementing Domain-Driven Design et Domain-Driven Design Distilled.

Premier jour

Getting started, strategic design, and architecture

The goal of Day 1 is for you to get grounded with a DDD mentality that will free your mind from data-driven approaches. This is necessary to grasp the thrust of developing a Ubiquitous Language within a Bounded Context, the hallmark of DDD. From there you will be ready to embrace strategic design using Sub-domains, Bounded Contexts, and Context Maps. Day 1 then crosses over to architecture, preparing you to employ Ports and Adapters, Event-Driven, and other powerful architectural tools as you develop new Bounded Contexts in classroom exercises. Students learn ways to develop a Ubiquitous Language within a Bounded Context, using both Specification by Example and Event Storming. Find your way toward correct software delivery goals using Impact Mapping. Teams of students will use these tools to reach a shared understanding of a Core Domain and Sub-domains. Each team will present their “big picture” and “design level” direction and receive helpful feedback before the Implementation begins on Day 2.

Getting started with DDD

Understand the essence of DDD. Form the right mentality for powerful software modeling. Develop a Ubiquitous Language for your project using the Specification by Example approach and Acceptance Tests. This lays a foundation for moving forward with DDD.

Domains, subdomains, and bounded contexts

Grasp the core concepts of DDD strategic modeling, and put them to use. Learn to vigorously gather core concepts and separate irrelevant ones. Learn why strategic design is so essential. Develop the ability to determine when your domain models are composed correctly and when they required more rigorous design.

Context mapping

Learn how to integrate with other subsystems using DDD and straightforward design techniques. Context Maps are not just drawings. Use them for cross-team communications, project thinking, learning, planning, and as an integration tool.

Architectures that support DDD

See how various architecture styles and patterns can be used to support your DDD projects. We will look at the following: Layers; Dependency Inversion Principle; Hexagonal; Microservices; REST; Event-Driven; Process Management; Event Sourcing and CQRS; Actor Model. Coupled with DDD, these architecture styles and patterns will support your microservices efforts.

Domain events and event storming

Learn to use Domain Events and Event Storming for both “big picture” systems designs and “detail level” tactical designs. Exercises will lead to using and Event-Driven Architecture in Day-2 implementations.

Deuxième jour

Tactical Design

In Day 2 we switch our focus to tactical design, giving you the aptitude to make proper finer-grained modeling decisions within a Core Domain. Whether its the use of Entities, Value Objects, Aggregates, Domain Events, or Domain Services that best fit your specific modeling situation, you can put each of the tactical tools to use in your own Core Domain project. As the day progresses, you will learn the advantages of using each of the tools, and when another tool could provide a better set of trade-offs.

Entities

There will likely be at least some Entities in object-oriented domain models because of the need to manage change over the life cycle of mutable objects. Understand how to properly employ this necessary modeling tool, but also why you should use these less often than you may think. Rather than overusing Entities, learn how to best use them only when a domain concept must change over time.

Value objects

Embrace this invaluable, functional modeling tool, which you should use as often as possible. You will learn the Value Object characteristics and why using Values where possible is a safer way to design. You will learn by modeling concepts as Values, and you may even decide to use Value-prolific designs rather than Entities.

Aggregates

Learn how to integrate with other subsystems using DDD and straightforward design techniques. Context Maps are not just drawings. Use them for cross-team communications, project thinking, learning, planning, and as an integration tool.

Domain events

Learn how to model, publish, and consume the facts of what happened in a domain model. You will see how Domain Events have a far-reaching impact on your designs across the enterprise. Here you will gain an understanding of how to publish and consume Events using messaging.

Domain services

Add powerful stateless operations to your model when its use is appropriate. The modeling techniques cover both domain-specific services and those of a more technical nature, often used for integration.

Modules

Understand the importance of and techniques for organizing concepts within a single domain model. Why go to all the trouble to carefully craft domain objects but without proper modularization using your Ubiquitous Language?

Factories

See when and how to use factories to support the creation of domain objects.

Troisième jour

Aggregate persistence, integrating bounded contexts, application

During Day 3 we bring all the parts together to form an application. We look at different ways to persist Aggregates using object-relational mapping, document databases, key-value stores, as well as by employing Event Sourcing. We then take a deep dive into applying Context Mapping techniques as we return to strategic design, but this time by developing integration solutions between Core Domains and other Bounded Contexts in your whole-system solution. Finally, we give attention to other parts of the application, such as the user interface and querying with CQRS. We also take a look at how to use Applications Services when necessary. With all this background you will be better prepared to move forward with a DDD project of your own or to make greater strides in your current DDD strategic initiative.

Repositories and event sourcing

Consider two primary approaches to persisting and reconstituting your domain objects. You will learn how to persist and retrieve your Aggregates using both SQL and NoSQL databases. You will also learn how to use Event Sourcing as both a persistence approach and to publish Domain Events for broader consumption.

Integrated bounded contexts

Employ both REST and messaging to realize your Context Maps in the code as you integrate multiple Bounded Contexts of enterprise applications. Understand the complexities and challenges of distributed computing environments, and how to deal with them. An important lesson that is reemphasized is to model each Bounded Context cleanly and separately from those with which you integrate.

Application

Learn how the components that surround your domain model comprise a whole subsystem application. Consideration is given to User Interface strategies and the Application Programming Interface (API) using Application Services. Here you will learn how to apply CQRS from Domain Events and Event Sourcing.

Instructor
Vaughn Vernon
Method
Atelier
Audience
Architect, Business Analyst, Software Developers
Material Language
Anglais
Training language
Anglais
There're no item that match your search criteria. Please try again with different keywords.

Intéressé à travailler avec nous?