Thursday 7th April, 2016
10:45am to 12:15pm
Thursday, April 7 - 10:45 AM
“Emerge your architecture” goes the agile mantra. That’s great. Developers get empowered and fluffy papers make room for real code structure. But, how do you ensure the cohesiveness of the result?
In this talk, we expose how architecture is an emergent property, how it is a commons, and we introduce an approach for how it can be steered.
Testing, pair programming and code reviewing are the proposed means to approach this problem. However, testing is only concerned with the functional side of a system, and thus, it is not able to capture structural contracts. Pair programming and reviewing work well in the small, but they do not scale when you need to handle the millions of details entailed in modern systems.
Another way of approaching the structure of the system is through standard checkers, such as FindBugs or Checkstyle. These are fine tools, but when they are left to only check standard idioms, the specifics of your architecture remain unverified.
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 tutorial we detail a method of approaching this challenge by steering the architecture on a daily basis through:
making architectural concerns explicit,
crafting automated checkers,
agreeing on findings, and
distilling corrective actions.
One challenging aspect is that of constructing custom analysis tools during development. This process requires a new kind of infrastructure and associated skills that enable you to craft such checkers fast and cheaply. 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.
This talk is targeted to both engineers and managers. We cover the basics of the process, and we accompany the conceptual descriptions with real life examples.
Brief introduction in software architecture by linking it to the keynote. Potentially enhance the definition of architecture: instead of “the important stuff”, make it “the important stuff right now”.
The value of architecture
The cost of architecture
Paper architecture vs. real architecture
Examples of systems
Architecture and agility:
Architecture and architects
Architecture and requirements
Architecture and testing
Architecture and pair programming
Architecture and code review
The emergent nature of architecture:
Architecture as an emergent property
Emergent properties and complex (as opposed to complicated) games:
Steering architecture by making concerns explicit through detections and by enabling all technical people to participate.
Detecting architecture drifts (shorter):
The limited impact of out-of-the-box detections
The need for contextual detection
The humane assessment method of crafting custom tools during development
Examples of custom detections
Architecture as a collaborative game:
Architecture as a commons
Small fixes vs. long term goals
The roles: stakeholder and facilitator
Integrating daily assessment in the development process
Examples of daily group decisions and actions
Sign in to add slides, notes or videos to this session