SATURN 2012 Keynote: Michael Stal, Win-Win With Agile Architecture

Win-Win with Agile Architecture
Michael Stal, Siemens Corporate Research

This keynote covered software architecture and how it can be combined with Agile in systematic way; perspectives on agility and architecture.

“Experts solve problems, geniuses avoid them” (Einstein). Architects should be geniuses.

Architecture and design are two sides of the coin. If you knew everything in advance, you could design the best architecture. Waterfall would be a perfect fit.  But the real world is not perfect.

The other side of the coin is represented by the Agile Manifesto. In software architecture, embracing change is important. However, change should be planned.

Agile architecture requires us to detect failures early and draw the right conclusions. See To Engineer Is Human, Henry Petroksi. Learn from failure. Try to understand what went wrong and what went right. Agile architecture is detecting failures early and learning from them. We don’t deliberately make errors, but we need to learn how to cope with them.

Ad hoc changes inevitably cause design erosion.

Agility ain’t anarchy. It is about KISS (keep it simple, stupid).

Change-driven architecture is fragile; big design up front (BDUF) architecture (analysis paralysis) is either unsuitable or overengineered. Extreme approaches seldom work. Can we combine architecture and agility?

Iterative = re-do, a rework scheduling strategy that helps improve quality of product; requires continuous rework and quality improvement.

Incremental = add onto; avoids big-bang integration; architecture grown piece by piece in evolutionary approach; product quality after each end-to-end slice.

Agile = iterative-incremental process with additional characteristics.

  • requirements not frozen up front
  • iterations time-boxed
  • set of principles, values, and development methods for all stakeholders

From centralization to swarm intelligence. Stakeholders are involved and communicate with each other. Agility is about communication, people working together.

Agile principles help increase architecture quality. A risk- and requirements-driven orientation. Test-driven design can be applied to architecture design. Goal of iteration is product quality and less risk at each iteration so the next one can be on safe ground. Especially important in the beginning.

Frederick Brooks: Iterative evolutionary design is essential. In first phase of system development, requirements engineering and architecture should go hand in hand. Architects don’t fully understand requirements, stakeholders don’t fully understand design. Write down all assumptions about users and their uses in the beginning; learn from predecessors.

“If you think good architecture is expensive, try bad architecture.” –Brian Foote and Joseph Yoder

Len Bass: Design is a continuous activity of making decisions. Begin with decisions that have broad systemwide scope, move to collection of decisions that have narrow scope. Decision is architectural if it has systemwide impact or affects achievement of a quality attribute important to system. Strategic design and tactical design. At beginning consider only strategic requirements. Tactical perspective encompasses local design decisions with non-systemic impact.

“Architecture is about everything costly to change.” (Grady Booch)

Observations and experiences:

  • Best designs are not invented by committees but by (a small number of) individuals.
  • Architecture is about communication.
  • Architecture and design require collaboration of stakeholders.
  • Change is the rule, not the exception; must embrace change in a planned way.

Agile architecture should be use-case driven and scenario based.

Onion model. Architecture design follows structure of an onion. Start with inner core, incrementally continue with outer layers:

  • functional core
  • distribution and concurrency infrastructure
  • strategic qualities
  • tactical qualities

Start with architecture baseline, use onion model. Baseline architecture must be as complete as necessary to govern subsequent software development and as simple as possible to be understood and communicated.

Not-invented-here (NIH) syndrome. “Human beings, who are almost unique in having the ability to learn from the experience of others, are also remarkable for ther apparent disinclination to do so.” (Douglas Adams)

Reuse increases quality and abides to KISS principle.

  • Efficiency and effectiveness are more important than originality.
  • Proven expertise instead of inventing new solutions, to avoid accidental complexity.

Reusability is basic foundation of Agile development.

Domain model as common language in problem domain. Basis for understanding functional requirements.

Evolutionary design embraces systematic change. Design erosion is the root of evil. All projects become brownfield projects. Unsystematic approaches (workarounds) cure the symptom but not the problem. Workarounds lead to design erosion, affect quality attributes. Such systems are doomed to fail.

Goal of Agile architecture evolution and improvement: achieve or meet quality attributes.

Internal quality indicators for the system: economy, visibility, spacing, symmetry, emergence.

“If it stinks, there must be something to clean up (strange architectural smells).”

Technical debt: sometimes must temporarily accept, but technical debt in strategic parts might be critical. If something smells–refactoring, reengineering, and rewriting are complementary approaches to sustain architecture and code quality.

Software architect’s dilemma: “Life must be understood backwards, but it must be lived forwards.” (Kierkegaard)

Architecture assessments find the bad smells; qualitative and quantitative reviews at each iteration.

Architects must know the right requirements. “A program which perfectly meets a lousy specification is a lousy program.” (Cem Kaner) Requirements must have high quality. Quality of requirements determines quality of architecture.

Architecture testing is important part of Agile mindset. Mind risks and conduct early risk analysis. A risk-based test strategy.

Communication is essential. “Software development is a collaborative game.” (Alexander Cockburn) Frequent change requires agile collaboration.

Conclusions:

  • Agile architecture fulfills Agile Manifesto. 
  • Agility and architecture are not contradictory. Agile design embraces change; agile architecture is about planned change. Sustainable architecture baseline is precondition for successful Agile development.
  • Architect’s framework for agile architecture: specify and implement software architecture systematically and in timely fashion; check and ensure appropriate architecture quality; respond to changes; deal with problems that arise during definition and realization of software architecture.

 

About these ads

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s