search menu icon-carat-right cmu-wordmark

Continuous Design of IT Systems

May 2019 Presentation
George Fairbanks (Google)

This presentation covers how to use continuous design on your projects with a mixture of agile, domain-driven design, functional programming, and architecture ideas.

Publisher:

Software Engineering Institute

This presentation was created for a conference series or symposium and does not necessarily reflect the positions and views of the Software Engineering Institute.

Abstract

I’ve been applying a mixture of agile, domain-driven design, functional programming, and architecture ideas to information technology (IT) systems. Most architectural case studies report on one round of design, but my projects were being designed and redesigned continuously. This talk covers some insights I’ve had and some ways of working that may help you on your projects.

  1. Agile and architecture differ in their use of control systems (open loop, closed loop) to guide projects. We can mix them, but only when the team agrees to the mixture; e.g., agilists don’t shout YAGNI and architects don’t stop the presses. We should use open loop control for some things and closed loop for others.
  2. The team won’t have a single architect but neither will it have silos of expertise. Instead, the team creates and evolves a shared understanding of the architecture that is represented in the code base (including types, framework components, comments, and READMEs).
  3. The team maintains intellectual control of the system. It keeps the state space small and sufficiently well understood to reason about it and derive conclusions. The design is continuously changing, so team members evolve the code to match that understanding and actively communicate relevant changes to the rest of the team.
  4. Humans are not ideal computing machines and work better with some external representations (i.e., source code) than others. To facilitate human reasoning, teams should mercilessly refactor their code so that it matches their internal theories of the requirements and the design. Without aggressive refactoring, complexity quickly accumulates, preventing axiomatic reasoning and intellectual control. Theory building is refactoring.
  5. We should expect the code tied to the domain to converge as the team masters the requirements. The architectural infrastructure may never converge. As the team’s theories become clearer, the source code (in the small) will take on a functional, definitional flavor regardless of programming language.