10% off for 2+ classes.

Building an Incremental Architecture (Jul 15–18)

$1,995.00

4 half-day remote hands-on workshop.
July 15–18, 2024
You can’t simultaneously fight your code and be Agile—it slows you down too much. Your system’s architecture must evolve incrementally along with your understanding of the product. In this workshop, you’ll learn everything you need to create an highly adaptable architecture literally as you implement. Along the way, you’ll also experience Event Storming and other Domain-Driven Design techniques.

13 slots remaining

[10% off, 2 or more classes]
SKU: incr-arch-07-24 Categories: ,

A big-up-font design is a sure way to build the wrong thing. We learn as we work, and the things we learn impact our architecture. Incremental architectures—which grow and adapt over time—are the most effective, lowest cost, lowest risk way to build a solid product that can easily adapt to customer needs. We can’t just add helter skelter, however. Our evolving architecture must remain coherent and easily stand up to the stress of change. It must also be as simple as possible, adding complexity only as needed. Together, those characteristics make changes cheap and easy to do, and make business agility possible.

In this hands-on workshop, you’ll learn how to create architecture incrementally as our systems evolve rather than in one giant up-front phase. You’ll learn how to develop a coherent architecture that grows incrementally as you learn. You’ll learn a complete design process, starting with domain analysis and the user’s story and ending up with code. You’ll learn how to start from “-ilities” and incremental-friendly patterns. You’ll learn how to focus the architecture on customer needs through the user’s stories. You’ll get hands-on experience with practical techniques like Design by Coding (a way to design incrementally literally while you’re coding) and Domain-Driven-Design/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). Along the way, you’ll also learn about ensemble (mob) programming, which we’ll use in the exercises, and Architectural TDD.

We’ll cover

  • the SOLDIER principles (Simple, Obvious, Lightweight, Domain focused, Independent, Essential, Refactorable)
  • architectural patterns appropriate for incremental development
  • how to create strictly-isolated highly decoupled subsystems
  • domain-focused architectures (including DDD)
  • how to use the domain to maintain system coherence as the architecture grows
  • how to identify key abstractions, bounded contexts, entities, aggregates.
  • how to use events and messaging instead of declarative interfaces and APIs
  • event storming as both an analysis and design tool

You’ll come away knowing how to build a coherent and highly maintainable system and architecture that can easily accommodate changing requirements and grow incrementally as the system evolves.”

Agenda

  • Working incrementally
  • The SOLDIER principles (Simple, Obvious, Lightweight, Domain focused, Independent, Essential, Refactorable)
  • Integrating code and product development
  • The inspect-and-adapt loop.
  • Incremental-friendly architectural patterns.
  • Componenets, and strictly-isolated decoupled subsystems
  • Domain-focused systems
  • Exercise: Selecting core architecture from patterns
  • Exercise: Realizing -ilities
  • Exercise: Creating Problem Statements
  • Exercise: Capturing the User’s Story
  • Exercise: Activity mapping
  • The walking skeleton
  • The MVP (no, it’s not a product)
  • Incrementally evolving the MVP
  • Example-Driven Development (TDD)
  • Exercise: Ensemble/Mob Programming (setup & basics)
  • Exercise: Creating Declarative APIs (Design by Coding)
  • Domain-Driven Design
  • Bounded Contexts, Aggregates, and Entities
  • Event-driven systems
  • Lightweight messaging systems
  • Exercise: Using Event Storming to create Dynamic systems.

Details

Hands-on workshop. July 15–18, 8AM-12PM US-Pacific time (San Francisco/Los Angeles).

Time converter at worldtimebuddy.com

 

We may go overtime. Class is taught in English. You must enable your video during class, and please use a headset or a good-quality microphone. We will contact you a few days prior to the first day of class with additional details about connection, software, etc. Classes are taught using a mixture of Zoom.com and Spatial.chat, we use Mural.co for shared whiteboards, and VSCode for programming exercises (I'll set up a shared repo for that). We will email additional details to you a few days before class.

We are happy to present this class in-house as full-day sessions. We can adjust the number of days, but shorter classes will have less hands-on work. Please contact Allen (allen@holub.com) for pricing and other details.

Your Instructor

Allen Holub (https://holub.com, @allenholub, allen@holub.com) is an internationally recognized software architect and consultant/trainer focusing on organizational agility. He speaks all over the planet on these topics and agile-friendly implementation technology like microservices and incremental/evolutionary architecture, but his bread and butter is helping you create or improve highly functional Lean/Agile organizations, and helping you design and build software architectures suitable for agile environments. He provides both in-house training and consulting services. Allen started his career as a hardware engineer, but after being pressed into writing a compiler and real-time operating system for the robot his team was building, ended up a developer. He's helped with many commercial applications, web based and otherwise, and has served twice as a CTO for early-stage startups.

Allen is widely published (10 books, many hundreds of articles both in print and online) and was a Contributing Editor at both Dr. Dobb's Journal and JavaWorld. His many video classes have been published by Pluralsight (Swift in Depth, Picturing Architecture, Object-Oriented Design), LinkedIn Learning (Architecture Fundamentals, and Domain-Driven Design), and O’Reilly (Design Patterns in the Real World). Allen taught for the University of California, Berkeley, Extension for many years, and is the current Chan-Norris Distinguished Professor of Computer Science at Mills College.

If you'd like to bring Allen in house for keynotes, consulting, or training work, set up a chat to discuss your needs.

Related products