Incremental Architecture

Agility is impossible if your architecture makes even trivial changes insanely difficult. The solution is in Gall’s Law: A complex system that works is invariably found to have evolved from a simple system that worked. The inverse proposition also appears to be true: A complex system designed from scratch never works and cannot be made to work. You have to start over, beginning with a working simple system.

The most maintainable and effective architectures are those designed to grow incrementally as a system evolves rather than being defined in one giant up-front phase. Since they’re as simple as possible at any given moment, these systems are easy to expand and refactor (and maintain). However, as we evolve, our architecture must remain coherent and easily withstand the stress of changing requirements. The best way to do that is with a domain focus. The structure of the domain is the structure of the architecture. When the domain changes, the architecture easily adapts.

In this hands-on workshop, you’ll learn how to develop a coherent architecture that grows incrementally as you learn. You’ll learn a complete process for designing incrementally, starting with domain analysis and ending with code. You’ll come away with a solid understanding of how to build incremental-friendly architectures (and products).

You’ll learn to start from “-ilities” and incremental-friendly patterns. You’ll learn how to focus the architecture on customer needs through the user’s stories. Domain-Driven-Design and Event Storming (a way to implement complex reactive systems such as choreographed microservice systems that directly reflect the domain so easily adapt as the domain changes). You’ll also learn a little about working in an ensemble (mob), which we’ll use in the exercises.

Outline

Part 1

1. Working incrementally
2. Integrating coding and product development
3. The inspect-and-adapt loop.
4. Incremental-friendly architectural patterns.
   1. Monolithic vs. incremental deployment
   2. Layered architectures
   3. Hexagonal (MicroKernel) architectures
   4. Component architectures
   5. Distributed architectures
   6. Event-driven architectures
5. Selecting core architecture from patterns *
   1. Realizing -ilities *
6. Creating Problem Statements *
7. The User’s Story *

Part 2

1. Domain-Driven Design
2. Opaque components, hard boundaries
3. Event-driven systems (recap)
4. Lightweight messaging systems
5. Event Storming*
   1. demo
   2. full-class exercise
6. Converting the event model to a static model for implementation *
7. Implementation traps & pitfalls *
   
   * These topics involve extensive hands-on exercises, time permitting.