Steering Agile Architecture

a course for engineers, architects and managers

"Emerge your architecture" goes the agile mantra and with it developers get empowered and fluffy papers make room for real code. But, how do you ensure the cohesiveness of the result? Yes, testing and code reviews are useful tools, but the challenge of working with software systems stems from their sheer size and their continuously shape changing nature. The system's architecture is a business asset as it can make or break a system in the long run. Thus, keeping track of what goes on in the system is critical. This is a course about knowing the real architecture of your software system, and choosing to how to steer based on that reality.

Description

The architecture of the system is important and it deserves special attention because it is too easy for it to go wrong in the long run, and it is too expensive when that happens. In this course, we take a systematic look at what architecture is, and we detail a method of approaching the challenge of steering it on a daily basis through:

making architectural concerns explicit,

crafting automated checkers,

agreeing on findings, and

distilling corrective actions.

This approach requires the team to build custom tools and use them to guide decisions actively. This requires new skills and an appropriate technical infrastructure. However, this is a technical detail. The critical benefit comes from making architectural decisions explicit, and from the daily actions of cleaning the state of the system.

Target audience

Steering agile architecture is a challenge regardless of the type of system or chosen architecture and it should concern everyone involved in building the system. That is why, this course is targeted to both engineers and managers. We cover the multiple facets of the process, and we accompany the conceptual descriptions with real life examples from multiple case studies.

Course outline

Approaching architecture

What is software architecture:

Paper architecture vs. real architecture

When is architecture important?

Who should care about architecture?

Architecture and architects

Architecture and requirements

Architecture and testing

Architecture and pair programming

Architecture and code review

Architecture and code reading

Architecture and agile development:

Architecture as an emergent property

Emergent properties and complex (as different from complicated) games

Growing architecture

Architecture and technical debt:

Architecture and quality

The benefits and limitations of the technical debt metaphor

Beyond technical debt: software habitability as a positive metaphor

Architecture as a collaboration:

Architecture as a commons

Architecture as a work in progress

Architecture as a negotiation

Small fixes and long term goals

The daily assessment game:

The roles: stakeholder and facilitator

Integrating daily assessment in the development process

Dealing with the queue of technical tasks

Examples of daily group decisions and actions

Exposing architecture

Detecting and testing architecture drifts:

The limited impact of out-of-the-box detections

The need for contextual detection

Testing architecture

Hypothesizing and the humane assessment method of crafting custom tools during development

Introduction in software analysis:

Overview of what software analysis is and how it helps software architecture