T1206

Hands-On DDD and CQRS (with .Net or Java)

What is Domain Driven Design really about? How might Command Query Responsibility Segregation help us to build better software? Are they complicated concepts, or can they be harnessed by everyday developers?

DDD and CQRS are gaining in popularity because they attack genuine challenges in software development. This course balances explaining important underlying theory with both design- and code-focused exercises, giving students both understanding and new practical development skills. Rather than teaching a framework, the course teaches a factoring and some ways to implement it, highlighting the key pitfalls to avoid along the way. During the course, a small application will gradually be built up from scratch. The course also includes coverage of testing, how to apply the insights from the course to existing systems and how to scale out a system developed using CQRS.

Kursen kan komma att genomföras Remote i Göteborg och Malmö
Informator Remote
Klicka på bilden för mer info om Remote!           

June 18th - 20th: Focus on .Net (Sthlm+GBG+Mlm)
August 13th - 15th: Focus on Java (Sthlm)

Prerequisites:

For the .Net edition of the course:

  • A good working knowledge of the C# language, including classes, interfaces and generics
  • Basic knowledge of SQL
  • Some basic experience with NUnit is beneficial, but not essential

For the Java edition of the course:

  • A good working knowledge of the Java language, including classes, interfaces and generics
  • Basic knowledge of SQL
  • Some basic experience with JUnit is beneficial, but not essential

Taking our Software architecture course is recommended but not required.

Course outline:

DAY 1

The Challenge of "Database Driven" Software Development

  • Types of complexity
  • Scaling and consistency
  • Testing
  • Integration

Introduction to Domain Driven Design

  • Domains and Domain Models
  • Ubiquitous Language
  • Exercise on building a domain model

Bounded Contexts

  • Why boundaries matter
  • Context Maps
  • Decomposition in the domain
  • Composition in the UI
  • Exercises on boundary hunting

Commands, Queries and Events

  • Normalization and denormalization
  • Write models and read models
  • Events as the write-side/read-side link
  • Eventual consistency and its consequences
  • Designing commands
  • Designing queries
  • Exercise on command and query design

Message Busses

  • Messages as decoupling
  • Publish/Subscribe
  • Send vs. Publish
  • Building a simple message bus
  • Exercise on message bus implementation

Write Side Architecture

  • Command handlers
  • State sourcing vs. event sourcing
  • Introduction to aggregates
  • Building up aggregates from past events
  • Transactional safety
  • Exercise on command handlers and aggregates

DAY 2

BDD Style Testing

  • Introduction to BDD
  • Commands, Events and BDD
  • Building a simple test framework
  • Exercise on BDD

Event Stores

  • Existing options
  • Building an event store on top of an RDBMS
  • Implementing a repository using an event store
  • Advantages of freeing aggregate representation from persistence
  • Optimizations using snapshots
  • Exercise on building an event store

Advanced Aggregate Design

  • Finding aggregate boundaries
  • Coping with relationships
  • Exercise on aggregate design

Building Read Sides

  • Overall approach
  • Relational DB read sides
  • NoSQL read sides
  • Other options
  • Re-building and introducing new read sides
  • Exercise on building read sides

DAY 3

Sagas

  • What is a saga?
  • Different types of saga
  • Handling saga state
  • Building a simple saga framework
  • Exercise on sagas

Evolving a System

  • Refining domain models
  • Handling changes to commands
  • Event versioning
  • Handling event upgrade
  • Exercise on event upgrading

CQRS, DDD and Existing Codebases

  • Introducing bounded contexts to existing systems
  • Separating commands and queries
  • Migrating towards event sourcing

Scaling out

  • Using the read/write separation to scale
  • Scaling write sides by bounded context and by aggregate
  • Scaling within an aggregate
  • Message distribution and reliability
  • Message queues and ESBs

Other Opportunities

  • Parallel development and outsourcing
  • Recreating previous states for debugging

Fakta

Kurs
T1206
Längd
3 dagar
Pris
19.900 kr (exkl. moms)
Bookmark and Share

Kursmaterial

Kursmaterial på engelska ingår.

I samarbete med:

Kontakta oss
för mer information:

08 - 587 116 10 (Stockholm)
031 - 773 07 90 (Göteborg)
040-662 20 60 (Malmö)
info@informator.se