Architecture under Stress

A Hands-on Workshop

Overview

We live in a world of volatile requirements.

We've learned that big up-front design processes don't work. You have to approach design incrementally so that you can incorporate lessons learned. Our designs are constantly under stress, because they're constantly changing.

Programs not designed to handle that stress will kill your project. Code that resists change slows you down so much that Agile processes will fail, no matter how well you execute.

A new approach to design is essential. Traditional N-tier architectures just don’t work in this environment, for example. The best way to handle volatility is to firmly ground your architecture in the domain and then implement it in a highly modular way where the modules really are independent. Microservices and messaging are integral to this approach, and systems developed in this way are scalable, robust, and well suited for deployment in a cloud environment.

This hands-on class covers the entire system-design process, starting with planning strategies and “user stories” and ending with a full microservice-based implementation architecture. You'll work on real-world problems that you bring to class rather than a pedagogic exercise.

What you’ll learn

Over the course of a few days:
  • you'll learn how to create Problem Statements that establish an overall architecture.
  • you'll learn what user stories really are, and at how to write and organize them effectively.
  • you'll learn how to factor stories, how to extract architectural elements from them, and how to derive classes and microservices from those elements.
  • you'll learn how to build an architectural model from the stories, and how to forge that model into a coherent system architecture.
  • you'll learn about the best physical architectures for volatile environments, including microservices, messaging, and agents.

You'll come away with

You'll come away from this class understanding how to build a scalable and robust system that can easily expand incrementally and accommodate new and changing requirements. In particular, you'll
  • understand the entire system design process, starting with “user stories” and ending with a full implementation architecture
  • learn how to develop stories, how to factor them into smaller units, how to extract architectural elements from them, and how to derive classes and microservices from them
  • know how to look at your system design from both the within-the-application coding architecture and the system architecture perspective

Alternative presentations

The class can be presented in an abbreviated, lecture only, format. However, designing around volatility requires thinking about both the problem and solution in a new way, and this shift in thinking can be difficult to achieve without a guided exercise. I can also add an extra day or two of hands on if you want to work on a complex problem.

Audience

This hands-on course is aimed both at:
  • Engineers who’ve learned (or are learning) an agile process but are unsure how best to build code that works well with that process
  • Architects currently migrating architectures from monolith to microservices.

Prerequisites

Prior understanding of object-oriented concepts (classes, interfaces, subclassing, etc.) is helpful.

Computer requirements

None. This is a design, not a programming class. We will be working in groups, and each group may opt to use a shared computer for document creation, so it can’t hurt to bring yours along, but we can do everything on a whiteboard.