I presented our new Agile Architecture Method for the first time at the patterns & practices Summit.
Our Agile Architecture Method is an iterative and incremental approach for designing architectures.
To summarize, it’s a technique that:
- Scopes and focuses your architecture exercise.
- Uses scenarios to drive the design and evaluate potential solutions.
- Helps you think through your choice of application type, deployment, architectural style and technologies.
- Helps you quickly iterate through potential solutions.
- Helps you map potential patterns.
Here is a summary of the approach:
Here are the key inputs into the process:
- Use cases and usage scenarios
- Functional requirements
- Non-functional requirements (quality attributes such as performance, security, and reliability)
- Technological requirements
- Target deployment environment
Here are the key outputs of the process:
- Architecturally significant use cases
- Architecture hot spots
- Candidate architectures
- Architectural spikes
Summary of Steps
- Step 1. Identify Architecture Objectives.
- Step 2. Identify Key Scenarios.
- Step 3. Create an Application Overview.
- Step 4. Analyze Key Hot Spots.
- Step 5. Create Candidate Solutions.
Step 1. Identify Architecture Objectives
This is a scoping exercise. The purpose of this step is to figure out how much time and energy to spend on subsequent steps as well as guide your overall effort. You should know what you want in terms of outcomes. Here’s an example of potential goals:
- Build a prototype
- Identify key technical risks
- Test potential paths
- Share models and understanding
Step 2. Identify Key Scenarios
Identify relevant scenarios to focus your design on what matters most, and to evaluate your candidate solutions. In this case, you want to identify architecturally significant use cases. Architecturally significant use cases are those that meet the following criteria:
- They are important for the success and acceptance of the deployed application.
- They exercise enough of the design to be useful in evaluating the architecture.
You can draw key scenarios from your user stories, business stories and system stories.
Step 3. Create an Application Overview
Create an application overview. The application overview serves to make your architecture more real, connecting it to real-world constraints and decisions.
An application overview consists of the following steps:
- Determine your application type. First, determine what type of application you are building. Is it a mobile application, a rich client, a rich internet application, a service, a Web application, or some combination?
- Understand your deployment constraints. Next, understand your targeted deployment environment and determine what impact this will have on your architecture.
- Identify important architectural styles. Determine which architectural styles you will be using in your design. Will you build a service oriented architecture, client/server, layered, a message bus, or some combination?
- Determine relevant technologies. Finally, identify the relevant technology choices based on your application type, architectural styles and deployment constraints.
A good test of an application overview is whether you can whiteboard it.
Step 4. Analyze Key Hot Spots
Identify key hotspots based on quality attributes and the architecture frame. These are the areas where mistakes are most often made when designing an application.
Quality Attributes Frame
Understand the quality attributes that are important for your application and scenarios. For instance, most applications need to address security and performance and will be traded against usability, flexibility and other attributes that may be more or less important to you depending on your scenarios and requirements. You can use the following frame to identify key quality attributes to consider:
The architecture frame represents cross cutting concerns that will impact your design across layers and tiers. These are also the areas in which high impact design mistakes are most often made. Use the architecture frame to identify hot spots in your design that require additional attention to get right. You can use the following architecture frame to identify cross cutting concerns in your design:
Authentication and Authorization
Caching and State
Concurrency and Transactions
Coupling and Cohesion
Logging and Instrumentation
Step 5. Create Candidate Solutions
Create a candidate architecture and along with architectural spikes and evaluate it against your key scenarios, hot spots, and deployment constraints. The outcomes of this step are:
- Baseline / Candidate Architectures
- Architectural Spikes
Iterative and Incremental Design
You can iteratively flesh out your architecture as you work through your design and discover more details that impact your architecture. You don’t have to design your architecture in a single iteration. Do not get lost in the details; focus on the big steps and build a framework on which you can base your architecture and design.