Rainbow: Architecture-Based Self-Adaptation with Reusable Infrastructure

Reference: Garlan, D., Cheng, S.-W., Huang, A.-C., Schmerl, B. & Steenkiste, P. (2004). Rainbow: Architecture-Based Self-Adaptation with Reusable Infrastructure. IEEE Computer 37(10): 46–54. DOI: 10.1109/MC.2004.175. URL

Summary

Rainbow is a framework for adding self-adaptation to existing systems by using an architectural model of the target system as the basis for monitoring, problem detection, and repair. Its core claim is that a software architecture — components, connectors, and properties — is the right level of abstraction for reasoning about system-wide adaptation: it is abstract enough to be tractable and to express global constraints (latency, cost, availability), yet concrete enough to map to real system elements. This is a concrete realisation of the MAPE-K loop where the architecture is the runtime model (see Models@run.time).

The framework provides a reusable infrastructure with clearly separated, customisable parts. Probes instrument the running system; gauges aggregate probe readings into updates on the architectural model; a model manager maintains the architecture; a constraint evaluator checks the model against invariants and triggers adaptation when they are violated; and an adaptation engine selects and carries out repairs through system-level effectors. Rainbow separates this generic machinery from a system-specific adaptation knowledge layer — the architectural style, constraints, and repair strategies — so the same infrastructure can be retargeted to different systems at much lower cost than bespoke, code-level adaptation.

Rainbow’s key engineering contribution is thus reuse: rather than weaving adaptation logic into application code, developers supply an architectural model, a set of constraints, and a library of repair strategies, and the shared infrastructure supplies the control loop. The approach is later extended with utility-based strategy selection and the Stitch adaptation language, and exercised on canonical exemplars such as the Znn.com news-service testbed, which together made Rainbow the reference example of architecture-based self-adaptation.

Key Ideas

Architecture as the locus of adaptation: reason about the system through its component-and-connector model, not its source.
Reusable control-loop infrastructure: probes, gauges, model manager, constraint evaluator, adaptation engine, effectors.
Separation of generic mechanism from system-specific adaptation knowledge (style, constraints, strategies) — the source of reuse and low retargeting cost.
Constraint-triggered repair: violated architectural invariants drive selection of a repair strategy.
Externalised adaptation: the adaptation logic lives outside the target system, keeping the application unchanged.
Later refinements: utility-based strategy selection and the Stitch strategy language; Znn.com as the standard testbed.

Connections

Conceptual Contribution

Claim: Self-adaptation should be engineered at the architectural level using a reusable framework: a runtime model of the system’s architecture, plus system-specific constraints and repair strategies, lets the same adaptation infrastructure be retargeted across systems instead of hand-coded each time.
Mechanism: Probes instrument the system; gauges update an architectural model; a constraint evaluator detects invariant violations; an adaptation engine selects repair strategies and enacts them via effectors — a MAPE-K loop over an architectural runtime model, with generic infrastructure cleanly separated from a customisable adaptation-knowledge layer.
Concepts introduced/used: Architecture-Based Adaptation, MAPE-K, Models@run.time, Software Architecture, Constraint Evaluation, Utility Function
Stance: engineering / framework
Relates to: The canonical architecture-based exemplar of The Vision of Autonomic Computing; complements the layered separation of concerns in Self-Managed Systems - an Architectural Challenge and sits inside the taxonomy of Self-Adaptive Software - Landscape and Research Challenges. Its “architecture as formal artefact” stance rhymes with pattern-based dependability in Architectural Patterns for Dependable Software Systems - SOL.

Backlinks

Linked Pages

Architectural Patterns for Dependable Software Systems - SOL

Specification, Analysis and Implementation of Architectural Patterns for Dependable Software Systems

Reference: Yau, S. S., Mukhopadhyay, S., Bharadwaj, R. (2005). Proc. 10th IEEE Intl. Workshop on Object-Oriented Real-Time Dependable Systems (WORDS’05). Source file: WORD2005-2.pdf. URL

Summary

The paper presents the Secure Operations Language (SOL) and the agent-based SINS middleware for specifying, analyzing, and deploying architectural patterns that realize non-functional requirements (security, fault tolerance, real-time) of distributed dependable systems. SOL is a synchronous specification language with a precise formal semantics supporting automated analysis (theorem proving, model checking); SINS runs SOL agents on virtual machines distributed over hosts, with encrypted inter-agent messaging via a Secure Agent Control Protocol.

The authors illustrate SOL by formalizing a stack safety policy (a safestack module that constrains illegal pushes/pops) and the Hot Standby and Majority Vote fault-tolerance patterns as SOL modules with observable fail events. They extend SOL with module imports, an implicit fail variable, and middleware notification of module failures — enabling compositional dependability reasoning across heterogeneous deployments.

Key Ideas

SOL: synchronous language for agent specification with formal semantics.
SINS middleware runs SOL agents across encrypted VMs.
Patterns (HotStandby, MajorityVote) as reusable SOL modules.
Safety policies enforced at the language level.
Compositional analysis of dependability requirements.

Connections

Conceptual Contribution

Claim: Dependability (security, fault tolerance, real-time) in distributed systems is best achieved by specifying architectural patterns as formal modules in a synchronous agent language and deploying them on a middleware that enforces the same semantics at runtime.
Mechanism: SOL is a synchronous language with precise formal semantics amenable to theorem proving and model checking; programs are agents running on SINS virtual machines across hosts, communicating over the Secure Agent Control Protocol. The authors extend SOL with module imports, an implicit fail variable, and middleware fault notifications, then encode stack-safety, Hot Standby and Majority Vote as reusable SOL modules whose composition preserves dependability guarantees.
Concepts introduced/used: Secure Operations Language, SINS Middleware, Synchronous Language, Architectural Pattern, Hot Standby, Majority Vote, Safestack, Secure Agent Control Protocol, Compositional Dependability
Stance: engineering
Relates to: A concrete agent-middleware realisation of the security calculus in Secure Communications Processing for Distributed Languages; its formal-specification stance meets the language-workbench pragmatics of The Spoofax Language Workbench; pattern reuse echoes dependability concerns in Are Multiagent Systems Resilient to Communication Failures and Theory of Self-Reproducing Automata.

Self-Adaptive Software: Landscape and Research Challenges

Reference: Salehie, M. & Tahvildari, L. (2009). Self-Adaptive Software: Landscape and Research Challenges. ACM Transactions on Autonomous and Adaptive Systems (TAAS) 4(2), Article 14. DOI: 10.1145/1516533.1516538. URL

Summary

This survey organises the self-adaptive-software field into a coherent taxonomy and a research roadmap. Its recurring analytic device is a set of “self-*” questions derived from the classic journalistic hexad — where, what, when, why, who, how — used to structure both what a system adapts and how it is built. The authors position self-adaptation against the neighbouring traditions of Autonomic Computing, multi-agent systems, control theory, and machine learning, and distil their shared structure into an adaptation feedback loop of the MAPE-K form.

On what and where, the survey classifies adaptation by the properties being maintained — the self- properties* (self-configuring, self-healing, self-optimising, self-protecting, and the enabling self-awareness/self-monitoring) — and by the artefacts and layers where change is applied. On when, it distinguishes reactive from proactive adaptation and static from dynamic decision-making. On how, it surveys the mechanisms of monitoring, detecting, deciding, and acting, together with the models and knowledge each phase needs.

The paper’s lasting contribution is as a map and vocabulary: it fixes the terminology (adaptation properties, the MAPE-style loop, the object and level of adaptation) that later work builds on, and it enumerates the open research challenges — engineering trustworthy adaptation, assurance and verification, handling uncertainty, and decentralised/large-scale control — that motivate much of the subsequent SEAMS-community literature.

Key Ideas

A taxonomy via the six “self-*” questions (where/what/when/why/who/how) spanning object, level, timing, and mechanism of adaptation.
Self- properties* organised into a hierarchy: general (self-managing), major (configuring/healing/optimising/protecting), and enabling (self-awareness/self-monitoring).
Adaptation loop cast in MAPE-K terms as the common structure across autonomic computing, control theory, and agents.
Reactive vs. proactive and static vs. dynamic decision-making as key design axes.
A research roadmap: assurance/verification of adaptation, dealing with uncertainty, trust, and scale/decentralisation.

Connections

Conceptual Contribution

Claim: The self-adaptive-software field can be organised by asking, of any adaptation, where/what/when/why/who/how — yielding a taxonomy of adaptation properties, objects, timing, and mechanisms that unifies autonomic computing, control theory, and agent-based approaches under a common feedback-loop structure.
Mechanism: A survey framework built on the six self-* questions and a hierarchy of self-* properties, mapped onto a MAPE-style adaptation loop, used to classify existing systems and to expose gaps (assurance, uncertainty, trust, scale).
Concepts introduced/used: Self-Adaptation, MAPE-K, Adaptation Dimensions, Self-* Properties, Assurance
Stance: survey / taxonomy
Relates to: The standard map for the cluster anchored by The Vision of Autonomic Computing; classifies architecture-based approaches like Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure and reference models like Self-Managed Systems - an Architectural Challenge, and shares its property vocabulary with the ensemble-oriented Self-Adaptation Self-Expression Self-Awareness ASCENS.

Self-Managed Systems - an Architectural Challenge

Self-Managed Systems: an Architectural Challenge

Reference: Kramer, J. & Magee, J. (2007). Self-Managed Systems: an Architectural Challenge. In Future of Software Engineering (FOSE ’07), at ICSE 2007, pp. 259–268. DOI: 10.1109/FOSE.2007.19. URL

Summary

Kramer and Magee frame self-management as fundamentally an architectural problem and offer a reference model for structuring it. Building on their work on dynamic software architecture — systems whose components and connectors can be added, removed, and rewired at runtime — they argue that self-configuration, self-healing, and self-optimisation are best organised around explicit architectural change rather than ad-hoc code.

Their central proposal is a three-layer reference model (see Three-Layer Reference Model), adapted from Gat’s three-layer architecture in autonomous robotics. The bottom component-control layer is the running application, instrumented to report status and to reconfigure itself. The middle change-management layer holds a repertoire of pre-computed plans that respond to status reports and effect reconfigurations, escalating upward when it has no plan for the situation. The top goal-management layer synthesises new plans from high-level goals via (slower) deliberative planning. Separating layers by timescale and abstraction lets fast reactive adaptation and slow deliberative planning coexist cleanly.

The paper is as much an agenda as an architecture. Kramer and Magee catalogue the hard open problems this structure exposes — deriving correct plans from goals, guaranteeing consistency and safety during runtime reconfiguration, managing decentralised control across many self-managed components, and eliciting and evolving the goals themselves — positioning assurance of self-adaptive behaviour as a first-order software-engineering challenge.

Key Ideas

Self-management is an architectural problem, grounded in dynamic (runtime-reconfigurable) software architecture.
Three-layer reference model: component control → change management → goal management, borrowed from robotics.
Separation by timescale/abstraction: fast reactive plan execution below, slow deliberative planning above; escalation when no plan applies.
Runtime reconfiguration must preserve consistency and safety of the executing system.
A research agenda: plan synthesis from goals, assurance, decentralised control, goal elicitation and evolution.

Connections

Conceptual Contribution

Claim: Self-managed systems should be structured as a three-layer architecture that separates component control, change management, and goal management — matching each adaptation concern to the timescale and abstraction at which it operates.
Mechanism: A dynamically reconfigurable component layer reports status upward; a change-management layer applies pre-computed plans and escalates when none fit; a goal-management layer generates new plans from high-level goals through deliberative planning — a layered decomposition of the Plan/Execute half of a MAPE-K loop.
Concepts introduced/used: Three-Layer Reference Model, Dynamic Software Architecture, MAPE-K, Runtime Reconfiguration, Goal Management
Stance: architecture / research agenda
Relates to: Gives The Vision of Autonomic Computing a concrete reference architecture and complements the reusable-infrastructure stance of Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure; the robotics lineage connects to layered control in A Robust Layered Control System; its open problems are surveyed in Self-Adaptive Software - Landscape and Research Challenges.

The Vision of Autonomic Computing

Reference: Kephart, J. O. & Chess, D. M. (2003). The Vision of Autonomic Computing. IEEE Computer 36(1): 41–50. DOI: 10.1109/MC.2003.1160055. URL

Summary

This manifesto argues that the chief obstacle to further progress in computing is not raw capability but complexity: the installation, configuration, tuning, and maintenance of large heterogeneous systems is outstripping the ability of human administrators to manage them. Taking the human autonomic nervous system as its metaphor — it regulates heartbeat and temperature without conscious attention — the paper proposes autonomic computing: systems that manage themselves against high-level objectives supplied by administrators, who say what is wanted rather than how to achieve it.

The paper’s central architectural abstraction is the autonomic element: an autonomic manager wrapping a managed element, coupled to it through sensors and effectors, and running a closed control loop. That loop — Monitor, Analyse, Plan, Execute over a shared Knowledge base — is the MAPE-K loop that became the field’s organising pattern. Autonomic elements are composed into larger systems whose global self-management emerges from local manager behaviour and inter-element relationships (service agreements, negotiation).

Kephart and Chess frame the field’s goals through four self- properties*: self-configuration (systems configure themselves from high-level policy), self-healing (detect, diagnose, and repair faults), self-optimisation (continually tune performance and resource use), and self-protection (defend against and anticipate attacks). They lay out a research agenda spanning the individual-element level (theory of autonomic elements, lifecycle, learning) and the system level (emergent behaviour, negotiation, trust, and the engineering and assurance challenges of large adaptive systems).

Key Ideas

Complexity is the limiting factor; the answer is systems that manage themselves given high-level goals.
Autonomic element = autonomic manager + managed element, joined by sensors and effectors.
MAPE-K control loop: Monitor → Analyse → Plan → Execute over shared Knowledge.
Self-CHOP properties: self-configuration, self-healing, self-optimisation, self-protection.
Policy-based, goal-directed management: administrators specify objectives, not procedures.
System-level self-management as emergent from many interacting autonomic elements (agreements, negotiation, trust).
A broad research agenda naming learning, optimisation, negotiation, and assurance as open problems.

Connections

Conceptual Contribution

Claim: As systems outgrow human administrability, they must become self-managing — regulating their own configuration, health, performance, and defence against high-level objectives rather than step-by-step instructions.
Mechanism: Wrap each managed element in an autonomic manager that runs a Monitor–Analyse–Plan–Execute loop over a shared Knowledge base (MAPE-K), reading sensors and driving effectors; compose autonomic elements, coordinated by service agreements and negotiation, into self-managing systems judged by the self-CHOP properties.
Concepts introduced/used: Autonomic Computing, MAPE-K, Self-Adaptation, Feedback Loop, Models@run.time
Stance: vision / research agenda
Relates to: The origin point for the self-adaptive cluster — the architecture-based realisation in Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure, the reference architecture of Self-Managed Systems - an Architectural Challenge, and the taxonomy of Self-Adaptive Software - Landscape and Research Challenges all build on this framing. The biological metaphor complements the biology-inspired adaptation in Self-Adaptation Self-Expression Self-Awareness ASCENS.

Utility Function

A scalar-valued function that maps a system state (or a candidate configuration) to a measure of how good it is against the stakeholders’ objectives, so that competing alternatives can be ranked and the best chosen. In self-adaptive and autonomic systems, utility functions are the standard basis for decision-making in the Plan step of a MAPE-K loop: rather than encoding fixed if-then adaptation rules, the manager evaluates the utility of each reachable configuration (trading off, say, performance against cost and reliability) and adapts toward the one of highest expected utility.

Utility-based control is what lets a system reconcile multiple, possibly conflicting non-functional goals and handle requirements that admit trade-offs. In this vault it underpins the utility-based strategy selection of Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure (its Stitch strategies are chosen by expected utility) and the goal-driven planning of the Three-Layer Reference Model.

In this vault

Constraint Evaluation

(page does not exist)

Software Architecture

The structure of a system in terms of its components, the connectors between them, and their configuration and properties — the level of abstraction at which system-wide qualities (latency, availability, cost, reliability) are expressed and reasoned about. In self-adaptive systems the architecture is not just a design document: architecture-based adaptation makes a runtime model of the component-and-connector graph the artefact that is monitored, checked against constraints, and reconfigured, because it is abstract enough to be tractable yet concrete enough to map onto real system elements.

This stance runs from An Architecture-Based Approach to Self-Adaptive Software (Oreizy et al. 1999), which first proposed keeping the architecture “in the loop”, to Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure (Garlan et al. 2004), where the software architecture literally is the runtime model against which constraints are evaluated and repairs planned, and the layered separation of Self-Managed Systems - an Architectural Challenge.

In this vault

Models@run.time

The principle that a self-adaptive system should keep a causally-connected, runtime-accessible model of itself (and often of its environment and goals) that both reflects the running system and can be used to reason about and drive adaptation. Where classic model-driven engineering uses models at design time, models@run.time extends abstract models into the running system as first-class artefacts that the adaptation logic queries and updates.

Such a runtime model is the natural home for the Knowledge in a MAPE-K loop: the Monitor phase keeps it in sync with reality, and the Analyse/Plan phases reason over it rather than over raw code. Architecture-based approaches like Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure make the software architecture the runtime model against which constraints are evaluated and repairs planned.

MAPE-K

The reference control loop of Autonomic Computing and self-adaptive software: an autonomic manager runs a closed feedback loop of Monitor → Analyse → Plan → Execute over a shared Knowledge base, acting on a managed element through sensors (probes/gauges) and effectors.

Monitor — collect and aggregate sensor data from the managed element and its environment.
Analyse — detect when adaptation is needed (symptoms, constraint/SLA violations, drift from goals).
Plan — select a course of action (a strategy/tactic, reconfiguration, or repair).
Execute — enact the plan through effectors on the managed element.
Knowledge — models, policies, goals, and history shared across the four phases (see Models@run.time).

Introduced in The Vision of Autonomic Computing (Kephart & Chess 2003) as the organising abstraction for the self-* properties (self-configuration, self-healing, self-optimisation, self-protection). It is the connective tissue linking architecture-based adaptation (Rainbow - Architecture-Based Self-Adaptation with Reusable Infrastructure), reference models (Three-Layer Reference Model), and the broader survey landscape (Self-Adaptive Software - Landscape and Research Challenges).

In this vault

Architecture-Based Adaptation

(page does not exist)

Architectural Pattern

A reusable, named solution to a recurring system-level design problem, described in terms of components, connectors, and constraints on their composition. Unlike design patterns, architectural patterns govern overall structure and cross-cutting quality attributes such as dependability or scalability.

In this vault

Self-Adaptive Systems

Systems that monitor and modify their own behaviour: self-organisation, self-expression, self-awareness.

Self-Adaptation

A system’s capability to modify its own behaviour or structure at runtime in response to internal or environmental change, without external intervention. It is typically implemented as a MAPE-K loop (Monitor-Analyse-Plan-Execute over a Knowledge base), the control abstraction introduced by Autonomic Computing.

In this vault

Autonomic Computing

A software-engineering tradition, launched by IBM’s 2001 manifesto and crystallised in The Vision of Autonomic Computing (Kephart & Chess 2003), that responds to spiralling system complexity by building systems that manage themselves given high-level objectives. The biological metaphor is the autonomic nervous system: low-level regulation happens without conscious control so the administrator specifies what is wanted, not how to achieve it.

Autonomic systems are organised as MAPE-K loops — autonomic managers regulating managed elements — and are judged by the self- properties*: self-configuration, self-healing, self-optimisation, and self-protection (collectively “self-CHOP”). The tradition is the engineering counterpart to the biology-inspired Self-Adaptive Systems line already in this vault: where the latter asks why systems adapt, autonomic computing asks how you build and assure the adaptation.

Rainbow: Architecture-Based Self-Adaptation with Reusable Infrastructure

Summary

Key Ideas

Connections

Conceptual Contribution

Tags

Backlinks