All Software Architecture, All the Time
June 10-13, 2019
San Jose, CA

Agile architecture: Building systems that grow incrementally to accommodate change (Day 2)

Location: 212 C
Average rating: *****
(5.00, 2 ratings)

Who is this presentation for?

You're a developer, architect, product owner, or scrum master.

Level

Intermediate

Prerequisite knowledge

    Programming experience may be helpful for the architectural-patterns portion of the class but not otherwise required

What you'll learn

By the end of this two-day training course, you'll understand:

  • How architecture aligns with company structure and processes
  • How to define effective user stories
  • How to refine those stories and narrow them into small increments
  • How to develop a domain model and a system metaphor from those stories
  • How to turn that into an architecture that evolves incrementally in a way that maintains system coherence
  • How to design incrementally as you’re actually implementing

And you'll be able to:

  • Create an architecture in incremental steps as you discover new requirements rather than as a single up-front process
  • Optimize that architecture so that it can evolve over time to accommodate changing requirements
  • Create and size high-quality user stories and build an architecture around these stories
  • Use mob programming and TDD to develop code in an Agile way

Description

Agility is impossible if you’re fighting your code to make small changes. Agile-friendly architectures are designed to evolve incrementally, and you can’t be truly Agile if you’re not using them. In this hands-on workshop, learn how to create systems that are incremental, flexible, business focused, and easily evolve as you accommodate new requirements. These architectures are essential if you’re doing any sort of Agile development.

Using a hands-on approach, Allen Holub walks you through designing a system that can handle incremental development and then evolving it. You’ll start with a real-world problem provided by either you or your classmates and will end up with a flexible (Agile), domain-based architecture that can grow as the system evolves. The techniques you’ll learn are essential when building effective microservice APIs and in any development shop where requirements change as you’re working.

Topics include:

  • Characteristics of an Agile architecture
  • Conway’s Law: How agility and architecture interact
  • Modeling the domain
    • DDD basics: Bounded contexts, aggregates, entities
    • Agents (UI)
  • Working with stories
    • User goals
    • The system metaphor
    • Creating stories
    • Narrowing/splitting
    • Hands-on exercise (problem statements and story creation)
  • Orchestrated (declarative) systems
  • Design by coding
    • TDD
    • BDD: Given, when, then
    • DbC
      • Demo
      • Hands-on exercise (creating declarative APIs with DbC)
      • A quick introduction to mob programming
  • Choreographed systems: Reactive architectures
  • Event storming
    • Demo
    • Hands-on exercise (creating orchestrated/reactive systems).
  • Agile-architectural patterns
    • Structured monolith: The “layered” anti-pattern
    • Microservices
    • Microkernel
    • Message based
    • Reactive systems