AoAD2 Practice: Evolutionary System Architecture

This is an excerpt from The Art of Agile Development, Second Edition. Visit the Second Edition home page for additional excerpts and more!

This excerpt is copyright 2007, 2021 by James Shore and Shane Warden. Although you are welcome to share this link, do not distribute or republish the content without James Shore’s express written permission.

Evolutionary System Architecture

Programmers, Operations

We build our infrastructure for what we need today, without sacrificing tomorrow.

Simple Design
Incremental Design
Reflective Design

Simplicity is at the heart of Agile, as discussed in the “Key Idea: Simplicity” sidebar. It’s particularly apparent in the way fluent Delivering teams approach evolutionary design: they start with the simplest possible design, layer on more capabilities using incremental design, and constantly refine and improve their code using reflective design.

What about your system architecture? By system architecture, I mean the components that make up your deployed system. The applications and services built by your team and the way they interact. Your network gateways and load balancers. Even third-party services. What about them? Can you start simple and evolve from there?

That’s evolutionary system architecture, and I’ve seen it work on small systems. But system architectures are slow to evolve, so there isn’t the same depth of industry experience behind evolutionary system architecture that there is behind evolutionary design. Use your own judgment about how and when it should be applied.

I make a distinction between system architecture and application architecture. Application architecture is the design of your code, including decisions about how to call other components in your system. It’s discussed in the “Application Architecture” section. This practice discusses system architecture: decisions about which components to create and use, and the high-level relationships between them. continue reading, buy the book!

In this Section

  1. Evolutionary System Architecture
    1. Are You Really Gonna Need It?
    2. Aim for Simplicity
      1. 1. Start with an ideal world
      2. 2. Introduce imperfect components and networks
      3. 3. Limit resources
      4. 4. Consider humans and teams
    3. Controlling Complexity
      1. Evolutionary design
      2. Self-discipline
      3. Fast deployment
      4. Vertical scaling
    4. Refactoring System Architecture
      1. Multirepo components → Monorepo components
      2. Components → Microliths
      3. Microliths → Modules
      4. Modules → New modules
      5. Big ball of mud → Modules
      6. Modules → Microliths
      7. Microliths → Components
      8. Modules → Components
      9. Monorepo components → Multirepo components
      10. Compound refactorings
    5. Prerequisites
    6. Indicators
    7. Alternatives and Experiments
    8. Further Reading

Discuss the book on the AoAD2 mailing list or Discord server. For videos and interviews regarding the book, see the book club archive.

For more excerpts from the book, see the Second Edition home page.

If you liked this entry, check out my best writing and presentations, and consider subscribing to updates by email or RSS.