The adoption of Microservices, Cloud Computing and Reactive Design has driven an intense focus on cleanly partitioning large systems according to the real world boundaries that exist within the business. This in turn has caused a resurgence of interest in Domain Driven Design (DDD) and associated modelling techniques, such as Event Storming.
Domain Driven Design is a methodology for breaking down complex businesses into a set of semi-independent models (known as Bounded Contexts) each with their own Ubiquitous Language. Design models which are created using DDD are amenable to implementation as Microservices and compatible with the Event Stream Architecture advocated by Functional Reactive Programming (FRP).
This course familiarises delegates with the mechanics of Domain Driven Design and enables them to use DDD to create models of a clients business - typically by organizing and participating in Event Storming workshops. They will then be able to evolve this domain model into Microservice projects that can be independently deployed and scaled.
Introducing DDD and Microservices
- Software architecture before the WWW
- Monolithic Web Applications in JEE and .NET
- The move to SPA, Microservices and the Cloud
- Partitioning and clear boundaries are now essential
- The rediscovery of DDD in relation to Microservices
- How DDD enables well defined and scalable services
- Using the Event Storming technique as part of DDD
- The overlap between DDD, Event Storming, FP and RX
First Steps With Domain Driven Design
- What exactly counts as a Domain?
- Core, Support and Generic Domains
- Why DDD needs a Layered Architecture
- DDD is all about a Ubiquitous Language
- How the language and model are inseparable
- Distinguishing between Entity and Value types
- Grouping Entity and Value objects into Aggregates
- Managing domain types via Factories and Repositories
- Defining Services with high cohesion and loose coupling
Advanced Concepts in Domain Driven Design
- Why precisely defined types require explicit boundaries
- How poorly defined types lead to the 'Big Ball Of Mud'
- Dividing the domain into a series of Bounded Contexts
- Creating Context Maps to translate between subdomains
- Merits of the Partnership and Shared Kernel relationships
- Customer / Supplier and the idea of an Interchange Context
- The Conformist relationship and Anticorruption Layers
Using Event Storming to build Business Models
- Key considerations when interviewing stakeholders
- Ensuring the right people are present and participate
- Setting up an environment conducive for Event Storming
- Helping clients identify Domain Events in their processes
- Arranging Domain Events into timelines with concurrency
- Associating events with Commands, Actors and Aggregates
- Defining Aggregates in terms of behaviour and state machines
- Classifying state transitions in terms of Read and Write models
- Handling gaps in knowledge and disputes between participants
- Separating the concepts discovered into Bounded Contexts
- Using Event Storming as a source of Acceptance Tests
- Using Event Storming as a precursor to UI Wireframes
Review of core Microservices concepts
- What distinguishes a Microservice from a Web App?
- Creating Microservices using Spring Boot and .NET
- Defining contracts and RESTful API's for services
- Deploying and scaling services via a Cloud Provider
- Monitoring services and enforcing security rules
- Microservices, Event Streams and Reactive Design
Using DDD to define your Microservice Architecture
- How each Bounded Context is a potential Microservice
- Using isolated deployment to enforce context boundaries
- Mapping contexts and adding Anticorruption Layers via REST
- Implementing Domain Events directly via Actors and messaging
- Using platforms like Kafka to manage streams of events
Delegates should have good knowledge of OO programming concepts and have implemented RESTful services using tools like Spring Boot, Dropwizard and the ASP .NET Web API.