[ABC+01] "Ayars2001:SMIL"
Jeff Ayars, Dick Bulterman, Aaron Cohen, Ken Day, Erik Hodge, Philipp Hoschka, Eric Hyche, Muriel Jourdan, Michelle Kim, Kenichi Kubota, Rob Lanphier, Nabil Layaïda, Thierry Michel, Debbie Newman, Jacco van Ossenbruggen, Lloyd Rutledge, Bridie Saccocio, Patrick Schmitz, and Warner ten Kate. Synchronized multimedia integration language (smil 2.0), 7. August 2001. W3C Recommendation.
[Act96] "Active-Database-Manifesto1996"
Corporate Act-Net Consortium. The active database management system manifesto: A rulebase of adbms features. SIGMOD Record, 25(3):40-49, 1996.
[ADB+99] "Abowd2003:Towards-better-understanding-context"
Gregory D. Abowd, Anind K. Dey, Peter J. Brown, Nigel Davies, Mark Smith, and Pete Steggles. Towards a better understanding of context and context-awareness. In Handheld and Ubiquitous Computing: First International Symposium, HUC'99, Karlsruhe, Germany, September 1999., volume 1707 of Lecture Notes in Computer Science (LNCS), pages 304-307. Springer-Verlag, June 1999. Online in SpringerLink seit: 2003.
[ADG98] "Allen1998:Dynamic-SA"
Robert Allen, Rémi Douence, and David Garlan. Specifying and analyzing dynamic software architectures. In Fundamental Approaches to Software Engineering, volume 1382 of Lecture Notes in Computer Science (LNCS), pages 21-37. Springer-Verlag, 1998.
Abstract
A critical issue for complex component-based systems design is the modeling and analysis of architecture. One of the complicating factors in developing architectural models is accounting for systems whose architecture changes dynamically (during run time). This is because dynamic changes to architectural structure may interact in subtle ways with on-going computations of the system. In this paper we argue that it is possible and valuable to provide a modeling approach that accounts for the interactions between architectural reconfiguration and nonreconfiguration system functionality, while maintaining a separation of concerns between these two aspects of a system. The key to the approach is to use a uniform notation and semantic base for both reconfiguration and steady-state behavior, while at the same time providing syntactic separation between the two. As we will show, this permits us to view the architecture in terms of a set of possible architectural snapshots,each with its own steady-state behavior. Transitions between these snapshots are accounted for by special reconfiguration-triggering events.
[AFG+03] "Comquad:Zwischenbericht2003"
Ronald Aigner, Elke Franz, Steffen Göbel, Hermann Härtig, Heinrich Hußmann, Klaus Meißner, Klaus Meyer-Wegener, Marcus Meyerhöfer, Andreas Pfitzmann, Christoph Pohl, Martin Pohlack, Simone Röttger, Alexander Schill, Frank Wehner, and Steffen Zschaler. Zwischenbericht der dfg-forschergruppe 428: "`components with quantitative properties and adaptivity (\textscComquad)"'. Technical Report TUD-FI-03-10-August, Technische Universität Dresden und Friedrich-Alexander Universität Erlangen-Nürnberg, 10. August 2003.
[AFL03] "Andrade2003:Coordination-DS"
Luis Filipe Andrade, José Luiz Fiadeiro, and Antónia Lopes. Coordination for distributed business systems. In CAiSE'03 Workshop Proceedings, Klagenfurt/Velden, Austria, June 16-20, 2003, 2003.
Abstract
We motivate, discuss and present extensions to architecture modelling techniques through which business systems can support services and applications that are location and network aware. These extensions provide a complete separation between three concerns: Computation, which accounts for the way service functionalities are provided in system components, Coordination, which accounts for the interactions that need to be put in place to enforce business rules, and Distribution, which accounts for the need to reconfigure the way services are provided in reaction to changes in the locations where functionalities are computed and the communication infrastructure over which coordination takes place.
[AIT04] "Autili2004:Automatic-Adaptor"
Marco Autili, Paola Inverardi, and Massimo Tivoli. Automatic adaptor synthesis for protocol transformation. In First International Workshop on Coordination and Adaptation Techniques for Software Entities (WCAT04), 2004.
[Alm01] "Almeida:Thesis"
João Paulo Andrade Almeida. Dynamic reconfiguration of object-middleware-based distributed systems. Master's thesis, University of Twente, Enschede, The Netherlands, June 2001.
[AOW03] "Amberg2003:Adaptionsframework"
Michael Amberg, Shota Okujava, and Jens Wehrmann. Ein komponenten-framework für die situationsabhängige adaption web-service-basierter standardsoftware. In 5ter Workshop Komponentenorientierter betrieblicher Anwendungssysteme (WKBA5), 2003.
Abstract
In dieser Arbeit wird zunächst der Gesamtkontext adaptiver Software für betriebliche Standardsoftware diskutiert, bevor ein Komponenten-Framework für die situationsabhängige Adaption Web-Service-basierter Standardsoftware vorgestellt wird. Die wesentlichen Bestandteile des Komponenten-Frameworks sind die Grundkonzeption der situationsabhängigen Adaption mit Web-Services, die dazu erforderlichen Komponenten zur Protokollierung, die zentralen Komponenten des Adaptionsprozesses, sowie eine Gesamtarchitektur, die das Zusammenspiel der verwendeten Komponenten beschreibt.
[App01] "ApICS2001:When-to-use"
Applied Industrial Control Solutions LLC (ApICS LLC). When to use feedforward feed-forward control and feedback control in industrial automation applications, 2001.
[Ark98] "Arkin1998:Intelligent-robots-autonomous-agents"
Ronald C. Arkin. Behavior-Based Robotics. Intelligent robots and autonomous agents. MIT Press, 1998.
[AW89] "Astroem1989:Adaptive-Control"
Karl Johan \AAström and Björn Wittenmark. Adaptive Control. 1989.
[AWO03] "Amberg2003:Adaptive-Software"
Michael Amberg, Jens Wehrmann, and Shota Okujava. Adaptive software: Protokollierung, verwaltung und verwertung von nutzungsprofilen in betriebswirtschaftlicher standardsoftware unter besonderer berücksichtigung von personalisierungsfunktionen. Technical Report Wirtschaftsinformatik III, Nr. 01/2003, Friedrich-Alexander Universität Erlangen-Nürnberg, 2003.
[AWPvS] "Almeida2001:Paper"
João Paulo A. Almeida, Maarten Wegdam, Luís Ferreira Pires1, and Marten van Sinderen. An approach to dynamic reconfiguration of distributed systems based on object-middleware. Submitted to the '19º Simpósio Brasileiro de Redes de Computadores' (SBRC'2001), Florianópolis, Santa Catarina, Brazil, 21-25 May 2001.
Abstract
There is an increasing demand for long running and highly available systems. This holds particularly for distributed systems based on object-middleware, which are becoming increasingly popular nowadays. Dynamic reconfiguration consists of modifying the configuration of a system during runtime, contributing to the availability of the system. This paper introduces a novel approach to dynamic reconfiguration of distributed systems based on object-middleware. The paper also discusses some issues related to the implementation of our approach and proposes a design for a Dynamic Reconfiguration Service using CORBA standard mechanisms.
[BAB+00] "Blair2000:Supporting-dynamic-QoS"
G[ordon] S. Blair, A[nders] Andersen, L[ynne] Blair, G[eoff] Coulson, and D. Sánchez. Supporting dynamic qos management functions in a reflective middleware platform. volume 147, pages 13-21, February 2000.
[Bal96] "Balzer1996:ACL"
Robert Balzer. Enforcing architecture constraints, October 1996. International Software Architecture Workshop (ISAW-2).
Abstract
We have built an infrastructure which reifies the architectural connections between modules into a data structure that constantly reflects the dynamic structural architecture of a software system. It similarly makes available all communications passing through those connectors.\ Since these connections and the communications passing through them constitute the entire behavior of an architecture, our infrastructure provides the basis for a full range of architecture-level monitoring, testing, debugging, and enforcement tools.\ This paper concentrates on the latter by presenting a language for stating architectural constraints which can be checked against the data structure that dynamically reflects the software system’s structural architecture.
[BBI+00a] "Blair2000:The-role-SA-adaptation-middleware"
Gordon S. Blair, Lynne Blair, Valérie Issarny, Petr Tuma, and Apostolos Zarras. The role of software architecture in constraining adaptation in component-based middleware platforms. In IFIP/ACM International Conference on Distributed systems platforms, volume 1795 of Lecture Notes in Computer Science (LNCS), pages 164-184. Springer-Verlag, 2000. auch beziehbar über ACM \urlhttp://portal.acm.org/citation.cfm?id=338361&coll=ACM&dl=ACM&CFID=18423705&CFTOKEN=31181706#.
Abstract
Future middleware platforms will need to be more configurable in order to meet the demands of a wide variety of application domains. Furthermore, we believe that such platforms will also need to be re-configurable, for example to enable systems to adapt to changes in the underlying systems infrastructure. A number of technologies are emerging to support this level of configurability and re-configurability, most notably middleware platforms based on the concepts of open implementation and reflection. One problem with this general approach is that widespread changes can often be made to the middleware platform, potentially jeopardizing the integrity of the overall system. This paper discusses the role of software architecture in maintaining the overall integrity of the system in such an environment. More specifically, the paper discusses extensions to the Aster framework to support the re-configuration of a reflective (component-based) middleware platform in a constrained manner. The approach is based on i) the formal specification of a range of possible component configurations, ii) the systematic selection of configurations based on a given set of non-functional properties, and iii) the orderly re-configuration between configurations, again based on formally specified rules.
[BBI+00b] "Blair2000:The-role-SA-adaptation-middleware-ACM"
Gordon S. Blair, Lynne Blair, Valérie Issarny, Petr Tuma, and Apostolos Zarras. The role of software architecture in constraining adaptation in component-based middleware platforms. In IFIP/ACM International Conference on Distributed systems platforms, pages 164-184. Springer-Verlag New York, Inc., 2000.
Abstract
Future middleware platforms will need to be more configurable in order to meet the demands of a wide variety of application domains. Furthermore, we believe that such platforms will also need to be re-configurable, for example to enable systems to adapt to changes in the underlying systems infrastructure. A number of technologies are emerging to support this level of configurability and re-configurability, most notably middleware platforms based on the concepts of open implementation and reflection. One problem with this general approach is that widespread changes can often be made to the middleware platform, potentially jeopardizing the integrity of the overall system. This paper discusses the role of software architecture in maintaining the overall integrity of the system in such an environment. More specifically, the paper discusses extensions to the Aster framework to support the re-configuration of a reflective (component-based) middleware platform in a constrained manner. The approach is based on i) the formal specification of a range of possible component configurations, ii) the systematic selection of configurations based on a given set of non-functional properties, and iii) the orderly re-configuration between configurations, again based on formally specified rules.
[BCA+01] "Blair2001:Design-OpenORB"
Gordon S. Blair, Geoff Coulson, Anders Andersen, Lynne Blair, Michael Clarke, Fabio Costa, Hector Duran-Limon, Tom Fitzpatrick, Lee Johnston, Rui Moreira, Nikos Parlavantzas, and Katia Saikoski. The design and implementation of open orb v2. IEEE Distributed Systems Online, 2(6), 2001.
[BCB+02] "Blair2002:Reflection-OpenORB"
Gordon S. Blair, Geoff Coulson, Lynne Blair, Hector Duran-Limon, Paul Grace, Rui Moreira, and Nikos Parlavantzas. Reflection, self-awareness and self-healing in openorb. In Proceedings of the first workshop on Self-healing systems, pages 9-14. ACM Press, 2002.
Abstract
There is a growing interest in the area of self-healing systems. Self-healing does however impose considerable demands on system infrastructures-especially in terms of openness and support for reconfigurability. This paper proposes that the self-awareness inherent in reflective technologies lends itself well to the construction of self-healing systems. In particular, the paper examines the support provided by the Open ORB reflective middleware technology for the construction of this increasingly important class of system.
[BCDW04] "Bradburya2004:Classification-Formal-Spec-Dynamic-SA"
Jeremy S. Bradburya, James R. Cordya, Juergen Dingela, and Michel Wermelinger. A classification of formal specifications for dynamic software architectures. eingereicht zu \emphFSE-12 - ACM SIGSOFT 2004 12th International Symposium on the Foundations of Software Engineering im April 2004, 10 Seiten, 2004.
[BG99] "Balzer1999:Mediating-connectors"
Robert M. Balzer and Neil M. Goldman. Mediating connectors. In Electronic Commerce and Web-based Applications/Middleware, Proceedings. 19th IEEE International Conference on Distributed Computing Systems Workshops, pages 73-77. IEEE, June 1999.
Abstract
We have developed a technology for mediating all shared library calls. These mediators can be dynamically installed and removed during execution. They can be used as an instrument for these interfaces, to monitor their behavior, to integrate legacy components together, or to encapsulate potentially harmful or unreliable components. Since modern commercial operating systems promote packaging third party functionality as shared libraries and are themselves composed of shared libraries the ability to mediate these interfaces provides access to the broad range of services available on that platform. An implementation of this technology is available for Windows NT
[BGW03] "CLOS2003"
Daniel G. Bobrow, Richard P. Gabriel, and Jon L White. Clos in context: The shape of the design space, 2003. Vermutlich elektronische Version des 1993 bei MIT Press erschienenen gleichnamigen Buchs.
[BJ04] "Bialek2004:Framework"
Robert Bialek and Eric Jul. A framework for evolutionary, dynamically updateable, component-based systems. In Proceedings of the 24th International Conference on Distributed Computing Systems Workshops - W7: EC (ICDCSW'04), pages 326-331. IEEE Computer Society, 2004.
[BMM02] "Babaoglu2002:Anthill"
Ozalp Babao\uglu, Hein Meling, and Alberto Montresor. Anthill: A framework for the development of agent-based peer-to-peer systems. In 22nd International Conference on Distributed Computing Systems (ICDCS '02), pages 15-22. IEEE, July 2002.
Abstract
Recent peer-to-peer (P2P) systems are characterized by decentralized control, large scale and extreme dynamism of their operating environment. As such, they can be seen as instances of complex adaptive systems (CAS) typically found in biological and social sciences. In this paper we describe Anthill, a framework to support the design, implementation and evaluation of P2P applications based on ideas such as multi-agent and evolutionary programming borrowed from CAS. An Anthill system consists of a dynamic network of peer nodes; societies of adaptive agents travel through this network, interacting with nodes and cooperating with other agents in order to solve complex problems. Anthill can be used to construct different classes of P2P services that exhibit resilience, adaptation and self-organization properties. We also describe preliminary experiences with Anthill in implementing a file sharing application.
[Bri02] "Bridges2002:PhD"
Patrick G. Bridges. Composing and Coordinating Adaptations in Cholla. PhD thesis, University of Arizona, 2002. Zusand per Mail.
[BSGHL01] "LNCS:1936:ADS"
Israel Ben-Shaul, Hovav Gazit, Ophir Holder, and Boris Lavva. Dynamic self adaptation in distributed systems. In Self-Adaptive Software: First International Workshop, IWSAS 2000, Oxford, UK, April 2000, volume 1936 of Lecture Notes in Computer Science (LNCS), pages 134-142. Springer-Verlag, 2001.
Abstract
The emergence of global network connectivity has motivated the investigation of models and techniques for dynamic self adaptive distributed software for two reasons: to enable adjustment of deployed components to previously unknown and possibly dynamically changing hosting environments, and to adapt the inter-component distributed architecture in order to improve application scalability, performance and availability. Several issues impact the quality of self-adaptation, including the degree of adaptation, programming transparency, performance, and monitoring facilities. We discuss these issues and describe two approaches to self adaptation, one focusing on intra-component adaptation and the other on inter-component adaptation. Both approaches were fully implemented in the Hadas and FARGO projects, respectively.
[BSHL01] "Hadas2001"
Israel Ben-Shaul, Ophir Holder, and Boris Lavva. Dynamic adaptation and deployment of distributed components in hadas. IEEE Transactions on Software Engineering, 27(9):769-787, 2001.
Abstract
Global network connectivity has enabled accessibility to a wide range of geographically dispersed services. By encapsulating and representing such services as components, they can be effectively composed into sophisticated wide-area applications that otherwise would be much harder to build. This paper presents a component model for encapsulating such services and a composition model for assembling encapsulated and possibly active services into new applications, while preserving the administrative autonomy of sites and individual components. The component model is dynamically- and self-adaptable, allowing for the adjustment of structure and behavior of autonomous components to changing or previously unknown contexts in which they need to operate. The composition model includes a set of protocols that enable us to dynamically deploy live components into remote sites and to dynamically reconfigure the deployment scheme through reflective stubs termed Ambassadors. The component and composition models have been fully implemented in Hadas, which also includes a host of tools for the creation, deployment, and composition of autonomous components.
[Can04] "Carlos2004:Adaptation-component-behaviour"
Carlos Canal. On the dynamic adaptation of component behaviour. In First International Workshop on Coordination and Adaptation Techniques for Software Entities (WCAT04), 2004.
[CdBS01] "Cuesta2001:Coordination"
Carlos E. Cuesta, Pablo de la Fuente, and Manuel Barrio-Solórzano. Dynamic coordination architecture through the use of reflection. In Proceedings of the 2001 ACM symposium on Applied computing, pages 134-140. ACM Press, 2001.
Abstract
In recent years, the research on Dynamic Software Architecture has received an increasing interest. The field is shifting from the description of “static” hierarchical interaction structures to the speci- fication of open, dynamic environments: a capability that has been present in Coordination Models and Languages from the start. In this report Coordination and Dynamic Architectural Description Languages are considered as a whole, and their degrees of dynamism are studied. A taxonomy of existing approaches to the description of dynamic structures (architectures) is presented, stating their different capabilities and limitations. The use of concepts from the field of Computational Reflection (which enable the building of self-modifying systems) is suggested as a way to unify and extend all those approaches. These concepts are joined in a general framework named MARMOL, where meta-levels are made explicit. Architectural interaction is specified by the definition of meta-level connectors, which provide more dynamic and compositional capabilities. To show how this can be used in a language, an ADL named $\mathcalP$i$\mathcalL$ar is briefly sketched, and a very simple example is described, to provide a first glimpse of its dynamic capabilities.
[CE00] "Czarnecki2000:Generative-Programming"
Krzysztof Czarnecki and Ulrich W. Eisenecker. Generative Programming: Methods, Tools and Applications. Addison-Wesley, 2000.
[CGS+02a] "Using-Architectural-Style"
Shang-Wen Cheng, David Garlan, Bradley Schmerl, João Pedro Sousa, Bridget Spitznagel, and Peter Steenkiste. Using architectural style as a basis for self-repair. pages 45-59. IEEE Computer Society, August 2002.
Abstract
An increasingly important requirement for software systems is the capability to adapt at run time in order to accommodate varying resources, system errors, and changing requirements. For such self-repairing systems, one of the hard problems is determining when a change is needed, and knowing what kind of adaptation is required. Recently several researchers have explored the possibility of using architectural models as a basis for run time monitoring, error detection, and repair. Each of these efforts, however, has demonstrated the feasibility of using architectural models in the context of a specific style. In this paper we show how to generalize these solutions by making architectural style a parameter in the monitoring/repair framework and its supporting infrastructure. The value of this generalization is that it allows one to tailor monitoring/ repair mechanisms to match both the properties of interest (such as performance or security), and the available operators for run time adaptation.
[CGS+02b] "LNCS:Pervasive-Systems"
Shang-Wen Cheng, David Garlan, Bradley Schmerl, João Pedro Sousa, Bridget Spitznagel, Peter Steenkiste, and Ningning Hu. Software architecture-based adaptation for pervasive systems. In Trends in Network and Pervasive Computing - ARCS 2002 : International Conference on Architecture of Computing Systems, Karlsruhe, Germany, April 8-12, 2002, volume 2299 of Lecture Notes in Computer Science (LNCS), pages 67-82. Springer-Verlag, 2002.
Abstract
An important requirement for pervasive computing systems is the ability to adapt at runtime to handle varying resources, user mobility, changing user needs, and system faults. In this paper we describe an approach in which dynamic adaptation is supported by the use of software architectural models to monitor an application and guide dynamic changes to it. The use of externalized models permits one to make reconfiguration decisions based on a global perspective of the running system, apply analytic models to determine correct repair strategies, and gauge the effectiveness of repair through continuous system monitoring. We illustrate the application of this idea to pervasive computing systems, focusing on the need to adapt based on performance-related criteria and models.
[Che03] "Cheng2003:Discussion-Summery:Autonomic-Levels"
Owen Cheng. 17-811 self-healing systems: Class discussion summary, 12. March 2003.
[CHG+04a] "Cheng2004:Architecture-Coordinating"
Shang-Wen Cheng, An-Cheng Huang, David Garlan, Bradley Schmerl, and Peter Steenkiste. An architecture for coordinating multiple self-management systems. In Proceedings of the 4th Working IEEE/IFIP Conference on Software Architectures (WICSa-4). IEEE Computer Society, 2004.
Abstract
A common approach to adding self-management capabilities to a system is to provide one or more external control modules, whose responsibility is to monitor system behavior, and adapt the system at run time to achieve various goals (configure the system, improve performance, recover from faults, etc.). An important problem arises when there is more than one such self-management module: how can one make sure that they are composed to provide consistent and complementary benefits? In this paper we describe a solution that introduces a self-management coordination architecture and infrastructure to support such composition. We focus on the problem of coordinating self-configuring and self-healing capabilities, particularly with respect to global configuration and incremental repair. We illustrate the approach in the context of a self-managing video teleconference system that composes two pre-existing adaptation modules to achieve synergistic benefits of both.
[CHG+04b] "Cheng2004:Rainbow"
Shang-Wen Cheng, An-Cheng Huang, David Garlan, Bradley Schmerl, and Peter Steenkiste. Rainbow: Architecture-based self-healing with reusable infrastructure. 19. January 2004.
[CHS01] "Chen2001:CactusAD"
Wen-Ke Chen, Matti A. Hiltunen, and Richard D. Schlichting. Constructing adaptive software in distributed systems. In The 21st International Conference on Distributed Computing Systems (ICDS'2001), pages 635-643, 2001.
Abstract
Adaptive software that can react to changes in the execution environment or user requirements by switching algorithms at runtime is powerful yet difficult to implement, especially in distributed systems. This paper describes a software architecture for constructing such adaptive software and a graceful adaptation protocol that allows adaptations to be made in a coordinated manner across hosts transparently to the application. A realization of the architecture based on Cactus, a system for constructing highly configurable distributed services and protocols, is also presented. The approach is illustrated by outlining examples of adaptive components from a group communication service.
[Cou01] "Coulson2001:What-is-reflective-middleware"
Geoff Coulson. What is reflective middleware. IEEE Distributed Systems Online, 8(2), 2001.
[COWL02] "Cobleigh2002:Containment-units"
Jamieson M. Cobleigh, Leon J. Osterweil, Alexander Wise, and Barbara Staudt Lerner. Containment units: A hierarchically composable architecture for adaptive systems. In Proceedings of the tenth ACM SIGSOFT symposium on Foundations of software engineering, pages 159-165. ACM Press, 2002.
Abstract
Software is increasingly expected to run in a variety of environments. The environments themselves are often dynamically changing when using mobile computers or embedded systems, for example. Network bandwidth, available power, or other physical conditions may change, necessitating the use of alternative algorithms within the software, and changing resource mixes to support the software. We present Containment Units as a software architecture useful for recognizing environmental changes and dynamically reconfiguring software and resource allocations to adapt to those changes. We present examples of Containment Units used within robotics along with the results of actual executions, and the application of static analysis to obtain assurances that those Containment Units can be expected to demonstrate the robustness for which they were designed.
[CSST98] "Cazzola1998"
Walter Cazzola, Andrea Savigni, Andrea Sosio, and Francesco Tisato. Architectural reflection: Bridging the gap between a running system and its architectural specification. In Proceedings of 6th Reengineering Forum (REF'98), 1998.
[DAB+03] "Bra2003:Hypermedia-architecture"
Paul De Bra, Ad Aerts, Bart Berden, Barend de Lange, Brendan Rousseau, Tomi Santic, David Smits, and Natalia Stash. Aha! the adaptive hypermedia architecture. In Proceedings of the fourteenth ACM conference on Hypertext and hypermedia, pages 81-84. ACM Press, 2003.
Abstract
AHA!, the "Adaptive Hypermedia Architecture", was originally developed to support an on-line course with some user guidance through conditional (extra) explanations and conditional link hiding. This paper describes the many extensions and tools that have turned AHA! into a versatile adaptive hypermedia platform. It also shows how AHA! can be used to add different adaptive "features" to applications such as on-line courses, museum sites, encyclopedia, etc. The architecture of AHA! is heavily inspired by the AHAM reference model.
[DC01a] "Dowling2001:K-Component"
Jim Dowling and Vinny Cahill. Dynamic software evolution and the k-component model. Technical Report TCD-CS-2001-51, Trinity College Dublin, 2001.
Abstract
There are known classes of software systems that can benefit from dynamic software evolution, including 24x7 systems that require on-line upgrades and adaptive systems that need to adapt to frequent changes in their execution environment. This paper investigates the use of dynamic software architectures and architectural reflection in building adaptive systems. We introduce the K-Component model and its architecture meta-model for building a dynamic software architecture. We address the issues of the integrity and safety of dynamic software evolution by modelling dynamic reconfiguration as graph transformations on a software architecture, and cleanly separate adaptation-specific code from functional code by encapsulating it in reflective programs called adaptation contracts. The paper also introduces the prototype implementation of our K-Component model.
[DC01b] "LNCS:K-Component"
Jim Dowling and Vinny Cahill. The k-component architecture meta-model for self-adaptive software. In Metalevel Architectures and Separation of Crosscutting Concerns : Third International Conference, REFLECTION 2001, Kyoto, Japan, September 25-28, 2001, volume 2192 of Lecture Notes in Computer Science (LNCS), pages 81-88. Springer-Verlag, 2001.
Abstract
Software architectures have recently emerged as a level of design concerned with specifying the overall structure of a system. Traditionally, software architectures only providestatic descriptions of the participants and interaction structures in a system. Dynamic softwarearchitectures, however, can be reconfigured at runtime and therefore provide support for buildingdynamically adaptable applications. Software architectures can be specified using architectural reflection. In this paper we introduce an architecture meta-model that realises a dynamic softwarearchitecture. The architecture meta-model reifies the configuration graph of the architecture and isautomatically generated from our component definitions and implementation language sourcecode.We show how graph transformations that re-write the architecture's configuration graph canbe implemented as reflective programs, called adaptation contracts. Adaptation contracts arewritten in a separate programming language, thus cleanly separating the adaptation code from thecomputational code. Adaptation contracts can even be replaced at run-time. They are deployed in arun-time meta-level architecture that addresses issues of system safety, integrity and overheadduring graph transformation. The paper also describes a prototype implementation of our modelcalled K-Components.
[DCCC04] "Dowling2004:Self-Properties"
Jim Dowling, Raymond Cunningham, Eoin Curran, and Vinny Cahill. Component and system-wide self-* properties in decentralised distributed systems. In SELF-STAR: International Workshop on Self-* Properties in Complex Information Systems, 31 May-2 June 2004, University of Bologna, 2004.
[Dey00] "Dey2000:PHD"
Anind K. Dey. Providing Architectural Support for Building Context-Aware Applications. PhD thesis, Georgia Institute of Technology, November 2000.
[Dey04a] "Dey2004:E-Mail-Interpretation-Context"
Anind K. Dey. Re: Interpretation of your context definition, 30. August 2004. E-Mail an den Autor - Message-ID <8351028360c1.8360c1835102@EECS.Berkeley.EDU>.
[Dey04b] "Dey2004:E-Mail-Ifc-no-Context"
Anind K. Dey. Re: Interpretation of your context definition, 2. September 2004. E-Mail an den Autor - Message-ID <8e09b68df307.8df3078e09b6@EECS.Berkeley.EDU>.
[Dey04c] "Dey2004:E-Mail-fuzzy-Line"
Anind K. Dey. Re: Interpretation of your context definition, 3. September 2004. E-Mail an den Autor - Message-ID <8fda718fdc7f.8fdc7f8fda71@EECS.Berkeley.EDU>.
[dF02] "Lemos2002:Architectural-support"
Rogério de Lemos and José Luiz Fiadeiro. An architectural support for self-adaptive software for treating faults. In Proceedings of the first workshop on Self-healing systems, pages 39-42. ACM Press, 2002.
Abstract
Considering the current trend of building systems from existing components that allow neither code inspection nor change, the solution for enabling dynamic adaptation of software systems should not be intrusive in the way that components should be designed. The architectural approach for treating faults described in this paper, instead of providing mechanisms and techniques at the component level, it relies on the interactions between components for obtaining flexible software structures that are nevertheless robust to the occurrence of undesirable events.
[DL01] "Limon2001:thesis"
Héctor Alejandro Durán-Limón. A Resource Management Framework for Reflective Multimedia Middleware. PhD thesis, Lancaster University, UK, October 2001.
[DL03] "david-ledoux.dais2003"
Pierre-Charles David and Thomas Ledoux. Towards a framework for self-adaptive component-based applications. In Jean-Bernard Stefani, Isabelle Demeure, and Daniel Hagimont, editors, Proceedings of Distributed Applications and Interoperable Systems 2003, the 4th IFIP WG6.1 International Conference, DAIS 2003, volume 2893 of Lecture Notes in Computer Science (LNCS), pages 1-14, Paris, November 2003. Federated Conferences, Springer-Verlag.
Abstract
Given today's fast pace of technological evolutions and diversity of computing platforms, building applications which can work in such a wide range of systems is becoming more and more challenging. To deal with this situation, applications must be \emphself-adaptive, that is adapt themselves to their environment and its evolutions. The goal of our works is to enable systematic development of self-adaptive component-based applications using the Separation of Concerns principle: we consider \emphadaptation to a specific execution context and its evolutions as a concern which should be treated separately from the rest of an application. In this paper, we first present the general approach we propose and the corresponding development framework and tools we are developing to support it. Then, in order to validate this approach, we show how a small component-based application can be made self-adaptive using our approach.
[DM02] "Dabrowski2002:Service-discovery-systems"
C. Dabrowski and K. Mills. Understanding self-healing in service-discovery systems. In Proceedings of the first workshop on Self-healing systems, pages 15-20. ACM Press, 2002.
Abstract
Service-discovery systems aim to provide consistent views of distributed components under varying network conditions. To achieve this aim, designers rely upon a variety of self-healing strategies, including: architecture and topology, failure-detection and recovery techniques, and consistency maintenance mechanisms. In previous work, we showed that various combinations of self-healing strategies lead to significant differences in the ability of service-discovery systems to maintain consistency during increasing network failure. Here, we ask whether the contribution of individual self-healing strategies can be quantified. We give results that quantify the effectiveness of selected combinations of architecture-topology and recovery techniques. Our results suggest that it should prove feasible to quantify the ability of individual self-healing strategies to overcome various failures. A full understanding of the interactions among self-healing strategies would provide designers of distributed systems with the knowledge necessary to build the most effective self-healing systems with minimum overhead.
[Dow03] "Dowling2003:Coordinating"
Jim Dowling. Coordinating self-adaptive components for emergent distributed system behaviour and structure. In 8th CaberNet Radicals Workshop, 2003.
Abstract
There are many research challenges in building complex distributed systems with selforganising behaviour and emergent structures from simple coordinating computational entities that have minimal shared and no global state. We argue that the design of such systems should be based firstly around experimentation but also can be greatly aided by the study of biological and social systems that display complex behaviour. This short paper introduces the K-Component Model and discusses how self-organising behaviour can emerge from the coordination of self-adaptive components, even though each component has no global knowledge and adapts their behaviour and structure relative to only local context information and programmer-specified goals.
[DvT02] "Dashofy:Towards-Architecture-based-self-healing"
Eric M. Dashofy, André van der Hoek, and Richard N. Taylor. Towards architecture-based self-healing systems. In Proceedings of the first workshop on Self-healing systems, pages 21-26. ACM Press, 2002.
Abstract
Our approach to creating self-healing systems is based on software architecture, where repairs are done at the level of a software system's components and connectors. In our approach, event-based software architectures are targeted because they offer significant benefits for run-time adaptation. Before an automated planning agent can decide how to repair a self-healing system, a significant infrastructure must be in place to support making the planned repair. Specifically, the self-healing system must be built using a framework that allows for run-time adaptation, there must be a language in which to express the repair plan, and there must be a reconfiguration agent that can execute the repair plan once it is created. In this paper, we present tools and methods that implement these infrastructure elements in the context of an overall architecture-based vision for building self-healing systems. The paper concludes with a gap analysis of our current infrastructure vs. the overall vision, and our plans for fulfilling that vision.
[EG02] "Engelhardtsen2002:JavaSpace"
Fritjof Boger Engelhardtsen and Tommy Gagnes. Using javaspaces to create adaptive distributed systems, 2002.
[EK00] "Eracar1998:RAACR"
Yönet A. Eracar and Mieczyslaw M. Kokar. An architecture for software that adapts to changes in requirements. Journal of Systems and Software, 50(3):209-219, 2000.
[End94] "Endler1995:Language-Generic-Dynamic-Reconfigurations"
Markus Endler. A language for implementing generic dynamic reconfigurations of distributed programs. In Proceedings of the 12th Brazilian Symposium on Computer Networks, pages 175-187, 1994.
[FA04] "Falcarin2004:SA-Evolution-Dynamic-AOP"
Paolo Falcarin and Gustavo Alonso. Software architecture evolution through dynamic aop. In First European Workshop on Software Architecture (EWSA 2004), St Andrews, Scotland, 21-22 May 04, 2004.
Abstract
Modern computing and network environments demand a high degree of adaptability from applications. At run time, an application may have to face many changes: in configuration, in protocols used, in terms of the available resources, etc. Many such changes can only be adequately addressed through dynamic evolution of the software architecture of the application. In this paper, we propose a novel approach to dynamically evolve a software architecture based on run-time aspect-oriented programming. In our framework, a system designer/administrator can control the architecture of an application by dynamically inserting and removing code extensions. It is even possible to replace a significant part of the underlying middleware infrastructure without stopping the application. The novelty of this work is that it allows for a much more flexible development strategy as it delegates issues like middleware choice and adherence to an architectural specification to a framework enhanced by dynamic code extensions.
[FDBC99] "MOST-experience"
A. Friday, N. Davies, G. Blair, and K. Cheverst. Developing adaptive applications: The most experience. Journal of Integrated Computer-Aided Engineering, 6(2):143-157, 1999.
[Fia04] "CommUnity-Homepage"
José Luiz Fiadeiro. Community, 2004.
[FL99] "Feng1999:Adaptive-Control"
Gang Feng and Rogelio Lozano, editors. Adaptive Control. Newnes, 1999.
[FPV98] "Fuggetta1998:Code-Mobility"
Alfonso Fuggetta, Gian Pietro Picco, and Giovanni Vigna. Understanding code mobility. IEEE Transactions on Software Engineering, 24(5):342-361, 1998.
Abstract
The technologies, architectures, and methodologies traditionally used to develop distributed applications exhibit a variety of limitations and drawbacks when applied to large scale distributed settings (e.g., the Internet). In particular, they fail in providing the desired degree of configurability, scalability, and customizability. To address these issues, researchers are investigating a variety of innovative approaches. The most promising and intriguing ones are those based on the ability of moving code across the nodes of a network, exploiting the notion of mobile code. As an emerging research field, code mobility is generating a growing body of scientific literature and industrial developments. Nevertheless, the field is still characterized by the lack of a sound and comprehensive body of concepts and terms. As a consequence, it is rather difficult to understand, assess, and compare the existing approaches. In turn, this limits our ability to fully exploit them in practice, and to further promote the research work on mobile code. Indeed, a significant symptom of this situation is the lack of a commonly accepted and sound definition of the term "mobile code" itself.This paper presents a conceptual framework for understanding code mobility. The framework is centered around a classification that introduces three dimensions: technologies, design paradigms, and applications. The contribution of the paper is two-fold. First, it provides a set of terms and concepts to understand and compare the approaches based on the notion of mobile code. Second, it introduces criteria and guidelines that support the developer in the identification of the classes of applications that can leverage off of mobile code, in the design of these applications, and, finally, in the selection of the most appropriate implementation technologies. The presentation of the classification is intertwined with a review of state-of-the-art in the field. Finally, the use of the classification is exemplified in a case study.
[FR04] "Fritsch2004:Mechanisms-adaptable-systems"
Claudia Fritsch and Burkhardt Renz. Four mechanisms for adaptable systems: A meta-level approach to building a software product line. In Software Product Lines: Third International Conference, SPLC 2004, Boston, MA, USA, August 30-September 2, 2004, volume 3154 of Lecture Notes in Computer Science (LNCS), pages 51-71. Springer-Verlag, 2004.
Abstract
For more than ten years we have developed and maintained a software product line of legal expert systems. They share certain functionality, such as interaction with the user by means of a graphical interface, capturing data, storing information in a database, and printing documents. They differ mainly in two points: Domain descriptions and technical infrastructure.\ When we designed the architecture for this software product line, we focused on two requirements in particular: Domain experts should be involved in development, but should not have to learn a general-purpose programming language. Changes in domain descriptions should leave technical code untouched – and vice versa.\ Using a meta-level architecture we achieved a sound decoupling: Domain descriptions are kept in the meta level. Appropriate engines included in the base level act according to these descriptions.\ We present the four meta-level mechanisms which we have developed for the design of this software product line. They separate domain descriptions from technical code in the following areas: data reference and access, input and output control, application and domain logic, and user command control.
[GBW93] "CLOS1993"
Richard P. Gabriel, Daniel G. Bobrow, and Jon L White. CLOS in Context: The Shape of the Design Space. MIT Press, 1993.
[GBZS01] "Goebel2001:Device-Independent"
Steffen Göbel, Sven Buchholz, Thomas Ziegert, and Alexander Schill. Device independent representation of web-based dialogs and contents. In Proceedings of the IEEE Youth Forum in Computer Science and Engineering (YUFORIC ´01), Valencia, Spain, November 2001.
[GC92] "Gelernter1992:Coordination-Languages"
David Gelernter and Nicholas Carriero. Coordination languages and their significance. Communications of the ACM, 35(2):97-107, 1992.
[GCS01] "LNCS:Communication-Environments"
Antônio Tadeu A. Gomes, Sérgio Colcher, and Luiz Fernando G. Soares. Towards a descriptive approach to model adaptable communication environments. In Networking - ICN 2001 : First International Conference Colmar, France, July 9-13, 2001, volume 2094 of Lecture Notes in Computer Science (LNCS), pages 867-876. Springer-Verlag, 2001.
Abstract
One of the main challenges in the telecommunication sector has been to devise communication environments that allows: (i) the integration of a multitude of different services in a single and efficient communication system, and (ii) the rapid and easy creation, modification and continuous adaptation to new demands and conditions. In this paper, we present a recursive-structuring model that gives adequate support for defining both communication environments and their adaptationmechanisms. Second, we propose the use of frameworks as powerful artifacts that can help a service designer delineate common ions that appear within any communication environment, allowing design reuse. Finally, we discuss the role of software architecture, and more precisely of ADLs, as an appropriate way to describe communication environments according to the model and frameworks mentioned above.
[GGK+01] "Gross2001:Active-Events-Model"
Philip N. Gross, Suhit Gupta, Gail E. Kaiser, Gaurav S. Kc, and Janak J. Parekh. An active events model for systems monitoring. In Working Conference on Complex and Dynamic Systems Architecture, 2001.
[GK96] "Goudarzi1996:Node-Consistency"
Kaveh Moazami Goudarzi and Jeff Kramer. Maintaining node consistency in the face of dynamic change. In Proceedings of the 3rd International Conference on Configurable Distributed Systems, pages 62-69. IEEE Computer Society, 1996.
[GMK02] "Georgiadis:Self-organising-SA-DS"
Ioannis Georgiadis, Jeff Magee, and Jeff Kramer. Self-organising software architectures for distributed systems. In Proceedings of the first workshop on Self-healing systems, pages 33-38. ACM Press, 2002.
Abstract
A self-organising software architecture is one in which components automatically configure their interaction in a way that is compatible with an overall architectural specification. The objective is to minimise the degree of explicit management necessary for construction and subsequent evolution whilst preserving the architectural properties implied by its specification. This paper examines the feasibility of using architectural constraints as the basis for the specification, design and implementation of self-organising architectures for distributed systems. Although we focus on organising the structure of systems, we show how component state can influence reconfiguration via interface attributes.
[Gou99] "Goudarzi1999:PhD"
Kaveh Moazami Goudarzi. Consistency Preserving Dynamic Reconfiguration of Distributed Systems. PhD thesis, Imperial College London, March 1999.
[GR91] "Dynamic-Weaves"
Michael M. Gorlick and Rami R. Razouk. Using weaves for software construction and analysis. In Proceedings of the 13th international conference on Software engineering, pages 23-34. IEEE Computer Society, 1991.
Abstract
Weaves are networks of concurrently executing tool fragments that communicate by passing objects. Intended as an engineering medium for systems characterized by streams of data, weaves occupy a computational niche midway between heavyweight parallel processes and fine-grain dataflow. Weaves are distinguished from other data flow styles by their emphasis on instrumentation, continuous observabfit y, and dynamic rearrangement: (1) Basic low-overhead instrument ation is inserted automatically. (2 ) Executing weaves can be observed at any time by means of sophisticated analysis agents, without degrading the performance of the weave. (3) Weaves can be dynamically snipped and spliced without interrupting the data flow; this permits novel forms of experimentation and analysis. Weaves execute efficiently on a broad spectrum of architectures and offer numerous opportunities for parallel execution. Also, it is possible to synthesize nontrivial weaves automatically from libraries of components. We discuss the architectural features of weaves, their implementation, and their use in a variety of applications.
[GS02] "Garlan2002:Model-based"
David Garlan and Bradley Schmerl. Model-based adaptation for self-healing systems. In Proceedings of the first workshop on Self-healing systems, pages 27-32. ACM Press, 2002.
Abstract
Traditional mechanisms that allow a system to detect and recover from errors are typically wired into applications at the level of code where they are hard to change, reuse, or analyze. An alternative approach is to use externalized adaptation: one or more models of a system are maintained at run time and external to the application as a basis for identifying problems and resolving them. In this paper we provide an overview of recent research in which we use architectural models as the basis for such problem diagnosis and repair. These models can be specialized to the particular style of the system, the quality of interest, and the dimensions of run time adaptation that are permitted by the running system.
[GSC01] "Garlan2001:Using-Gauges"
David Garlan, Bradley Schmerl, and Jichuan Chang. Using gauges for architecture-based monitoring and adaptation. In Working Conference on Complex and Dynamic Systems Architecture, 2001.
[GWS03] "Gajos2003:Resource-Management"
Krzysztof Gajos, Luke Weisman, and Howard Shrobe. Design principles for resource management systems for intelligent spaces. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 198-215. Springer-Verlag, 2003.
Abstract
The idea of ubiquitous computing and smart environments is no longer a dream and has long become a serious area of research and soon this technology will start entering our every day lives. There are two major obstacles that prevent this technology from spreading. First, di.erent smart spaces are equipped with very di.erent kinds of devices (e.g. a projector vs. a computer monitor, vs. a TV set). Second, multiple applications running in a space at the same time inevitably contend for those devices and other scarce resources. The underlying software in a smart space needs to provide tools for self-adaptivity in that it shields the rest of the software from the physical constraints of the space, and that it dynamically adjusts the allocation of scarce resources as the number and priorities of active tasks change.\ We argue that a resource manager can provide the necessary functionality. This paper presents a set of guiding principles for building high-level resource management tools for smart spaces. We present conclusions we arrived at after two years of exploring the topic in the Intelligent Room Project at the MIT AI Lab. The paper is based on a number of implemented and tested tools.
[HBSG99a] "ICSE99:FarGo"
Ophir Holder, Israel Ben-Shaul, and Hovav Gazit. Dynamic layout of distributed applications in fargo. In Proceedings of the 21st international conference on Software engineering (ICSE'99), pages 163-173. IEEE Computer Society, 1999.
[HBSG99b] "Holder:System-Support"
Ophir Holder, Israel Ben-Shaul, and Hovav Gazit. System support for dynamic layout of distributed applications. In Proceedings of the 19th IEEE International Conference on Distributed Computing Systems (ICDCS'99), pages 403-411. IEEE Computer Society, 1999.
[Hei98] "Heineman"
George T. Heineman. Adaptation and software architecture. In Proceedings of the third international workshop on Software architecture, pages 61-64. ACM Press, 1998.
Abstract
This paper focuses on the need to adapt software components and software architectures. Too often, examples from the literature avoid the difficult problem of constructing a software system from sets of (possibly independently constructed) software components. Consider the following example: given a set of components, an application builder attempts to construct a software system. Along the way, however, some components are adapted with new code to suit the requirements of the final application. If the components have architectural specifications, how are these adaptations reflected? In particular, changes in the component implementation (i.e., new classes, modified methods, new lines of code) must be reflected in the specification of the component (i.e., ports). Thii problem is more important than simply keeping documentation synchronized with software - the architectural description of a software system is essential in understanding the interconnections between the various software components.
[Hei03] "Heise:Krankenwagen"
Heise Newsticker. Stabiler datentransfer über wechselnde funknetze, 3. February 2003.
[Hil04] "Hiltunen2004:E-Mail-Cactus"
Matti A. Hiltunen. Re: Status of your adaptive software based on cactus, 19. July 2004. E-Mail an den Autor - Message-ID <40FC1C31.4000405@research.att.com>.
[Hin04] "Hinnelund2004:Thesis"
Patrick Hinnelund. Autonomic computing - a method for automated systems management. Master's thesis, Royal Institute of Technology, March 2004.
[HKRS02] "Hitz2002:Framework-Ubiquitous"
Martin Hitz, Gerti Kappel, Werner Retschitzegger, and Wieland Schwinger. Ein uml-basiertes framework zur modellierung ubiquitärer web-anwendungen. Wirtschaftsinformatik, 44(3):225-235, 2002.
Abstract
Electronic Commerce (E-Commerce) und Mobile Commerce (M-Commerce) führen zu einem vermehrten Bedarf an Diensten, die einen ubiquitären Zugriff ermöglichen. Ubiquitäre Web-Anwendungen stellen Dienste kontextbezogen zur Verfügung, d.\,h. personalisiert, zu jeder Zeit, an jedem Ort, über ein beliebiges Medium. Die Entwicklung ubiquitärer Web-Anwendungen gestaltet sich jedoch sehr komplex und verlangt eine entsprechende methodische Unterstützung. Existierende Methoden zur Modellierung von Web-Anwendungen werden den Anforderungen, die sich aus dem ubiquitären Charakter dieser Anwendungen ergeben, nur zu einem kleinen Teil gerecht. Dieser Beitrag stellt daher ein UML-basiertes Framework zur Modellierung ubiquitärer Web-Anwendungen vor. Kern des Frameworks stellt die Unterstützung der Anpassungsmodellierung dar. Dabei wird sowohl die Modellierung des Kontextes der ubiquitären Web-Anwendung unterstützt, indem ein physisches und ein logisches Kontextmodell zur Verfügung gestellt werden, als auch die Modellierung der eigentlichen Anpassung. Letztere erfolgt durch ein Regelmodell, das zum einen die dynamische Überwachung von Kontextänderungen und zum anderen die Aktivierung entsprechender Anpassungsoperationen erlaubt. Die Trennung einer Web-Anwendung in einen stabilen und damit kontextunabhängigen Teil und einen variablen, d.\,h.\ kontextabhängigen Teil, der die Anpassungsoperation zur Verfügung stellt, fördert Wiederverwendbarkeit und Änderungslokalität.
[HL95] "Huersch1995:SoC"
Walter Hürsch and Cristina Videira Lopes. Separation of concerns. Technical Report NU-CCS-95-03, Northeastern University, Boston, MA, 1995.
Abstract
This paper identifies and analyzes the emergence of a new paradigm in software engineering, called separation of concerns, which tries to formally separate the basic algorithm from special purpose concerns such as synchronization, real-time constraints, and location control. This separation allows for the locality of different kinds of information in the programs, making them easier to write, understand, reuse, and modify. We identify the major concerns existing in today's software applications, and analyze recent proposals in the literature that address separation of single concerns. Furthermore, we study the commonalities of these proposals and discuss how they can be used to achieve separation of concerns in general. Finally, we address the problem of composition of several separated concerns.
[Hor01] "IBM2001:AC-Manifest"
Paul Horn. Autonomic computing: Ibm's perspective on the state of information technology, October 2001. Manifest der Autonomic Computing Initiative.
[HS03] "Heinisch2003:Software-Download"
Cornelia Heinisch and Martin Simons. Adaptierbare software-architektur für den software-download in kfz-steuergeräte. In INFORMATIK 2003: Innovative Informatikanwendungen, volume 1 of Beiträge der 33. Jahrestagung der Gesellschaft für Informatik e.V. (GI), pages 320-324, 2003.
[IBM03a] "IBM2003:AC-Vision-Wirklichkeit"
IBM. Autonomic computing: Die vision wird wirklichkeit, 16. January 2003.
[IBM03b] "IBM2003:Systems-Journal-42-1"
IBM. Ibm systems journal, vol. 42, nr. 1, 2003, special issue on autonomic computing, 2003.
[IBM04] "IBM2004:AC-Products"
IBM. Ibm autonomic computing product and services, 2004.
[IW95] "Inverardi1995:CHAM"
Paola Inverardi and Alexander L. Wolf. Formal specification and analysis of software architectures using the chemical abstract machine model. IEEE Transactions on Software Engineering, 21(4):373-386, April 1995.
Abstract
We are exploring an approach to formally specifying and analyzing software architectures that is based on viewing software systems as chemicals whose reactions are controlled by explicitly stated rules. This powerful metaphor was devised in the domain of theoretical computer science by Ban\^ atre and Le Mtayer and then reformulated as the Chemical Abstract Machine, or CHAM, by Berry and Boudol. The CHAM formalism provides a framework for developing operational specifications that does not bias the described system toward any particular computational model. It also encourages the construction and use of modular specifications at different levels of detail. We illustrate the use of the CHAM for architectural description and analysis by applying it to two different architectures for a simple, but familiar, software system, the multiphase compiler.
[Jac02] "Jackson:Alloy"
Daniel Jackson. Alloy: a lightweight object modelling notation. ACM Transactions on Software Engineering Methodology, 11(2):256-290, 2002.
Abstract
Alloy is a little language for describing structural properties. It offers a declaration syntax compatible with graphical object models, and a set-based formula syntax powerful enough to express complex constraints and yet amenable to a fully automatic semantic analysis. Its meaning is given by translation to an even smaller (formally defined) kernel. This paper presents the language in its entirety, and explains its motivation, contributions and deficiencies.
[Jen00] "Jennings2000:Agent-based-SE"
Nicholas R. Jennings. On agent-based software engineering. Artif. Intell., 117(2):277-296, 2000.
[Kad04a] "Kadner2004:E-Mail-Fehler-Tesaband"
Kay Kadner. Re: Kontext bla von mir beurteilen, 18. August 2004. E-Mail an den Autor - Message-ID <46735.192.35.17.21.1092831123.squirrel@www.inf.tu-dresden.de>.
[Kad04b] "Kadner2004:E-Mail-Schnittstelle-variabel"
Kay Kadner. Re: Kontext bla von mir beurteilen, 24. August 2004. E-Mail an den Autor - Message-ID <36352.192.35.17.21.1093347059.squirrel@192.35.17.21>.
[KBC02] "Ketfi2002:Issues-Component-Adaptation"
Abdelmadjid Ketfi, Noureddine Belkhatir, and Pierre-Yves Cunin. Automatic adaptation of component-based software: Issues and experiences. In Proceedings of the International Conference on Parallel and Distributed Processing Techniques and Applications, PDPTA '02, June 24-27, 2002, Las Vegas, Nevada, USA, Volume 3, pages 1365-1371. CSREA Press, 2002.
Abstract
This paper deals with the dynamic adaptation problem. By Dynamic, we mean the ability to introduce modifications in an application at run-time. A component-based application is a set of interconnected units. Adapting one or more of its components can enhance such an application. In general, adapting a component means disconnecting it from the application and connecting a new version. The aim of this paper is to highlight the reasons of performing an adaptation, to identify and to classify its different types, and to define the problems and the complexity raised by each type. Dynamic adaptation is not a new problem, the first works go back to 1976[1]. We first introduce a short background of the adaptation problem, followed by the presentation of the different adaptation reasons, types and how to evaluate an adaptation approach. The remainder of the paper presents et evaluates the evolution of the adaptation approach from a large spectrum covering the classical approaches to the recent ones.
[KBE99] "IEEE:Kokar:Control-Theory"
Mieczyslaw M. Kokar, Kenneth Baclawski, and Yonet A. Eracar. Control theory-based foundations of self-controlling software. IEEE Intelligent Systems, 14(3):37-45, 1999.
[KC03] "IEEE:Autonomic"
Jeffrey O. Keffart and David M. Chess. The vision of autonomic computing. Computer Magazine, 36(1):41-50, 2003.
[KCBC02] "Kon2002:Reflective-middleware"
Fabio Kon, Fabio Costa, Gordon Blair, and Roy H. Campbell. The case for reflective middleware. Communications of the ACM, 45(6):33-38, 2002.
Abstract
It's flexible and reconfigurable yet simple for programmers to use, notably for building dynamic distributed applications operating on the Net.
[KLM+97] "Kiczales1997:AOP"
Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Videira Lopes, Jean-Marc Loingtier, and John Irwin. Aspect-oriented programming. In ECOOP '97 - Object-Oriented Programming: 11th European Conference, Jyväskylä, Finnland, volume 1241 of Lecture Notes in Computer Science (LNCS), pages 220-242. Springer-Verlag, 1997.
Abstract
We have found many programming problems for which neither procedural nor object-oriented programming techniques are sufficient to clearly capture some of the important design decisions the program must implement. This forces the implementation of those design decisions to be scattered throughout the code, resulting in “tangled” code that is excessively difficult to develop and maintain. We present an analysis of why certain design decisions have been so difficult to clearly capture in actual code. We call the properties these decisions address aspects, and show that the reason they have been hard to capture is that they cross-cut the system's basic functionality. We present the basis for a new programming technique, called aspect-oriented programming, that makes it possible to clearly express programs involving such aspects, including appropriate isolation, composition and reuse of the aspect code. The discussion is rooted in systems we have built using aspect-oriented programming.
[KLS+03] "Karsai2003:Supervisory-Control"
Gabor Karsai, Akos Ledeczi, Janos Sztipanovits, Gabor Peceli, Gyula Simon, and Tamas Kovacshazy. An approach to self-adaptive software based on supervisory control. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 24-38. Springer-Verlag, 2003.
Abstract
Self-adaptive software systems use observations of their own behavior, and that of their environment, to select and enact adaptations in accordance with some objective(s). This adaptation is a higher-level system function that performs optimizations, manages faults, or otherwise supports achieving an objective via changes in the running system. In this paper, we show how this capability can be realized using techniques found in hierarchical control systems, and we discuss interrelated issues of stability, assurance, and implementation.
[KM85] "Kramer1985:Dynamic-Configuration-DS"
Jeff Kramer and Jeff Magee. Dynamic configuration for distributed systems. IEEE Transactions on Software Engineering, 11(4):424-436, 1985.
[KM90] "Kramer1990:Dynamic-Change-Management"
Jeff Kramer and Jeff Magee. The evolving philosophers problem: Dynamic change management. IEEE Transactions on Software Engineering, 16(11):1293-1306, November 1990.
[KM98] "Kramer1998:Dynamic-Change"
Jeff Kramer and Jeff Magee. Analysing dynamic change in distributed software architectures. IEE Proceedings - Software, 145(5):146-154, October 1998.
[KM04] "Kasten2004:Perimorph"
Eric P. Kasten and Philip K. McKinley. Perimorph: Run-time composition and state management for adaptive systems. In Proceedings of the 24th International Conference on Distributed Computing Systems Workshops - W7: EC (ICDCSW'04), pages 332-337. IEEE Computer Society, 2004.
[Kon00] "Kon2000:Thesis"
Fabio Kon. Automatic Configuration of Component-Based Distributed Systems. PhD thesis, Department of Computer Science, University of Illinois at Urbana-Champaign, May 2000.
[KRL+00] "dynamicTAO"
Fabio Kon, Manuel Román, Ping Liu, Jina Mao, Tomonori Yamane, Luiz Claudio Magalhães, and Roy H. Campbell. Monitoring, security, and dynamic configuration with the dynamictao reflective orb. In Middleware 2000: IFIP/ACM International Conference on Distributed Systems Platforms, New York, NY, USA, April 2000, volume 1795 of Lecture Notes in Computer Science (LNCS), pages 121-143. Springer-Verlag, 2000.
Abstract
Conventional middleware systems fail to address important issues related to dynamism. Modern computer systems have to deal not only with heterogeneity in the underlying hardware and software platforms but also with highly dynamic environments. Mobile and distributed applications are greatly affected by dynamic changes of the environment characteristics such as security constraints and resource availability. Existing middleware is not prepared to react to these changes.\ In many cases, application developers know when adaptive changes in communication and security strategies would improve system performance. But often, they are not able to benefit from it because the middleware lacks the mechanisms to support monitoring (to detect when adaptation should take place) and on-the-fly reconfiguration.\ dynamicTAO is a CORBA-compliant reflective ORB that supports dynamic configuration. It maintains an explicit representation of its own internal structure and uses it to carry out runtime customization safely.\ After describing dynamicTAO's design and implementation, we discuss our experience on the development of two systems benefiting from the reflective nature of our ORB: a flexible monitoring system for distributed objects and a mechanism for enforcing access control based on dynamic security policies.
[KS99] "IEEE:Model-based"
Gabor Karsai and Janos Sztipanovits. A model-based approach to self-adaptive software. IEEE Intelligent Systems, 14(3):46-52, 1999.
[KVK99] "Kaiser1999:Workflow"
Gail Kaiser, Giuseppe Valetto, and Gaurav S. Kc. A mobile agent approach to lightweight process workflow. In Proceedings of the International Process Technology Workshop, Villard de Lans, France, 1.-3. September 1999.
[Lad97] "DARPA:SAS"
Robert Laddaga. Self-adaptive software, December 1997. DARPA SOL BAA 98-12, Original-URL nur noch zu erreichen über den Web-Archivierungsdienst \empharchive.org: \urlhttp://web.archive.org/web/19990221110757/http://www.darpa.mil/ito/Solicitations/CBD_9812.html.
[Lad99] "IEEE:Laddaga:Robust-Software"
Robert Laddaga. Creating robust software through self-adaptation. IEEE Intelligent Systems, 14(3):26-29, 1999.
[Lad01] "Laddaga2001:Active-Software"
Robert Laddaga. Active software. In Self-Adaptive Software: First International Workshop, IWSAS 2000, Oxford, UK, April 2000, volume 1936 of Lecture Notes in Computer Science (LNCS), pages 11-26. Springer-Verlag, 2001.
Abstract
The chief problems that software engineering will face over at least the next two decades are increasing application complexity, and the need for autonomy and serious application robustness. In other words, how do we actually get to declare success when trying to build applications one or two orders of magnitude more complex than today’s applications? And, having declared success when building, how do we keep them from absorbing all our productivity to keep them patched together and running with more than just a vague semblance of doing what we want? The sources of increasing application complexity are: 1. simple growth in problem size, as a result of success at previous problem sizes and increased hardware capacity; 2. the fact that many applications are now more closely tethered to the real world, actively utilizing sensors and actuators, or being required to respond in real-time; 3. the enmeshed nature of today’s applications – such as enterprise requirements to link all the elements of business process where it is useful to do so.
[LB03] "LNCS:2614:Landauer:Self-modeling"
Christopher Landauer and Kirstie L. Bellman. Self-modeling systems. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 238-256. Springer-Verlag, 2003.
Abstract
This paper is about systems with complete models of themselves (down to some very low level of detail). We explain how to build such a system (using careful system engineering, and our Wrapping approach to flexible integration infrastructures for Constructed Complex Systems), and why we want to do so (it is at least interesting, and we believe it is essential for effective autonomy). The long-term goal is the use of these models to understand modeling processes, so that computing systems can be built that can do their own modeling and construct their own abstractions, which we believe is important for computational intelligence.
[LBS+98] "Loyall1998:QoS-Aspect-Languages"
Joseph P. Loyall, David E. Bakken, Richard E. Schantz, John A. Zinky, David A. Karr, Rodrigo Vanegas, and Kenneth R. Anderson. Qos aspect languages and their runtime integration. In Languages, Compilers, and Run-Time Systems for Scalable Computers: 4th International Workshop, LCR'98, Pittsburgh, PA, USA, May 1998, volume 1511 of Lecture Notes in Computer Science (LNCS), pages 303-318. Springer-Verlag, 1998. Online in SpringerLink seit: Juni 2003.
Abstract
Distributed object middleware, such as CORBA, hides system- and network-specific characteristics of objects behind functional interface specifications. This simplifies development and maintenance of distributed objects, contributing to their growing acceptance. Critical applications have Quality of Service (QoS) requirements, however, such as real-time performance, dependability, or security, that are hidden by middleware. Because of this, application developers often bypass distributed object systems, thus gaining little or no advantage from the middleware. We have developed Quality Objects (QuO), a framework for developing distributed applications with QoS requirements. QuO provides a set of aspect languages, called Quality Description Languages (QDL), for specifying possible QoS states, the system resources and mechanisms for measuring and controlling QoS, and behavior for adapting to changing levels of available QoS at runtime. This paper describes QuO's aspect languages, their usage, and how they interact with the QuO runtime system to form the QuO framework.
[Le98] "Metayer1998:Graph-Grammars"
Daniel Le Métayer. Describing software architecture styles using graph grammars. IEEE Transactions on Software Engineering, 24(7):521-533, 1998.
Abstract
We believe that software architectures should provide an appropriate basis for the proof of properties of large software. This goal can be achieved through a clearcut separation between computation and communication and a formal definition of the interactions between individual components. We present a formalism for the definition of software architectures in terms of graphs. Nodes represent the individual agents and edges define their interconnection. Individual agents can communicate only along the links specified by the architecture. The dynamic evolution of an architecture is defined independently by a "coordinator." An architecture style is a class of architectures specified by a graph grammar. The class characterizes a set of architectures sharing a common communication pattern. The rules of the coordinator are statically checked to ensure that they preserve the constraints imposed by the architecture style.
[LFW02] "Lopes2002:Distribution-and-mobility"
Antónia Lopes, José Luiz Fiadeiro, and Michel Wermelinger. Architectural primitives for distribution and mobility. SIGSOFT Software Engineering Notes, 27(6):41-50, 2002.
Abstract
In this paper, we address the integration of a distribution dimension in an architectural approach to system development and evolution based on the separation between coordination and computation. This third dimension allows us to separate key concerns raised by mobility, thus contributing to our ability to handle the complexity that is inherent to systems required to operate in "Internet time and space".
[LH01] "Ludwig2001:Metaprogramming-Large"
Andreas Ludwig and Dirk Heuzeroth. Metaprogramming in the large. In Generative and Component-Based Software Engineering : Second International Symposium, GCSE 2000, volume 2177 of Lecture Notes in Computer Science (LNCS), pages 178-187. Springer-Verlag, 2001.
Abstract
Software evolution demands continuous adaptation of software systems to continuously changing requirements. Our goal is to cope with software evolution by automating program transformation and system reconfiguration. We show that this can be achieved with a static metaprogramming facility and a library of suitable metaprograms. We show that former approaches of program transformations are not sufficient for large object oriented systems and outline two base transformations that fill the gap.
[Lie95] "Lieberherr1995:Adaptive-OO-Software"
Karl Lieberherr. Adaptive Object-Oriented Software: The Demeter Method. PWS Publishing Company, 1995.
[Lie98] "Lieberherr:93-94-Research-Report"
Karl Lieberherr. Adaptive software: 93/94 research report, 29. October 1998.
[LL95] "Workshop-Texas"
Karl Lieberherr and Cristina Videira Lopes. Workshop on adaptable and adaptive software. pages 149-154, 1995. Addendum to the Proceedings of the 10th Annual Conference on Object-Oriented Programming Systems, Languages and Applications, Oct. 15-19, 1995, Austin, TX, USA.
[LL02] "Lemlouma2002:Content-Adaptation"
Tayeb Lemlouma and Nabil Layaïda. Content adaptation and generation principles for heterogeneous clients. In W3C Workshop on Device Independent Authoring Techniques, 25-26 September 2002, SAP University, St. Leon-Rot, Germany, 2002.
Abstract
In this paper, we propose a general framework for device independent authoring and presentation. Our approach relies on negotiated adaptation and generation techniques. These techniques allow the creation of customized presentations for different clients starting from a single and more abstract content representation. We focus on some key aspects of this framework through the learned lessons from an experimental system called NAC (Negotiation and Adaptation Core) under development in our project. A particular attention is given to the document model, the document transformation and media adaptation process. The role of the proxy in such a framework is also discussed.
[LLM97] "Landau1997:Adaptive-Control"
Ioan Doré Landau, Rogelio Lozano, and Mohammed M'Saad. Adaptive Control. Springer-Verlag, 1997.
[LLP04] "Li2004:Autonomic-Self-managing-Grid-Applications"
Z. Li, H. Liu, and M. Parashar. Enabling autonomic, self-managing grid applications. In SELF-STAR: International Workshop on Self-* Properties in Complex Information Systems, 31 May-2 June 2004, University of Bologna, 2004.
[LO99] "Lange1999:Reasons-Mobile-Agents"
Danny B. Lange and Mitsuru Oshima. Seven good reasons for mobile agents. Communications of the ACM, 42(3):88-89, 1999.
[LP02] "Langdon2002:Foundations-Genetic-Programming"
William B. Langdon and Riccardo Poli. Foundations of genetic programming. Springer-Verlag, 2002.
[LR04] "Laddaga2004:SAS"
Robert Laddaga and Paul Robertson. Self adaptive software: A position paper. In SELF-STAR: International Workshop on Self-* Properties in Complex Information Systems, 31 May-2 June 2004, University of Bologna, 2004.
[LRS01] "LNCS:1936:results"
Robert Laddaga, Paul Robertson, and Howie Shrobe. Results of the first international workshop on self-adaptive software. In Self-Adaptive Software: First International Workshop, IWSAS 2000, Oxford, UK, April 2000, volume 1936 of Lecture Notes in Computer Science (LNCS), pages 242-247. Springer-Verlag, 2001.
Abstract
We began the workshop with three goals in addition to hearing and commenting on each other’s papers. Those goals were to define self adaptive software, to point out some useful research directions, and to attempt to categorize and partition the space of interesting applications of self adaptive software. We addressed the first goal rather well, and the second to the degree that some research directions are clear, given the elaboration of the definition of self adaptive software. We were not able to cover the third goal in the time we had. In this concluding paper, we present the findings of the workshop concerning the how self adaptive software can be defined and researched.
[LRS03a] "LNCS:2614:results"
Robert Laddaga, Paul Robertson, and Howie Shrobe. Results of the second international workshop on self-adaptive software. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 281-290. Springer-Verlag, 2003.
[LRS03b] "Laddaga2003:Probabilistic-DDA"
Robertson Laddaga, Paul Robertson, and Howie Shrobe. Probabilistic dispatch, dynamic domain architecture, and self-adaptive software. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 227-237. Springer-Verlag, 2003.
Abstract
In this paper we report on a beginning effort in the self adaptive software research area of improving function or method dispatch. We extend type-signature based method dispatch in a dynamic object oriented programming language with probabilistic dispatch, where the choice of method to use is determined by statistical means. This research direction is part of a larger self adaptive software effort at the MIT Artificial Intelligence Laboratory, called Dynamic Domain Architectures.
[LRS03c] "LNCS:2614"
Robertson Laddaga, Paul Robertson, and Howie Shrobe, editors. Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS). Springer-Verlag, 2003.
[LS04] "Lieberman2002:Out-of-Context"
Henry Lieberman and Ted Selker. Out of context: Computer systems that adapt to, and learn from, context, 2004. Media Laboratory, Massachusetts Institute of Technology.
[LSLL00] "Loques2000:Integration-CP-MLP"
Orlando Loques, Alexandre Sztajnberg, Julius Leite, and Marcelo Lobosco. On the integration of configuration and meta-level programming approaches. In Reflection and Software Engineering, volume 1826 of Lecture Notes in Computer Science (LNCS), pages 189-208. Springer-Verlag, 2000.
Abstract
Configuration Programming, based on Architecture Descrip- tion Languages, and Meta-Level Programming are considered promising approaches in the software engineering field. This paper shows that there is an immediate correspondence between some key concepts of Config- uration and Meta-Level Programming approaches and that some of the main issues to be solved for their deployment in real systems are quite similar. The main result is that the integration of both approaches in a single configuration programming framework can assist in employing meta-level programming in order to achieve separation of concerns and improve software reuse. In addition, the capability of supporting dynamic configuration and flexibility on component programming language choice are potentially improved. A prototype of a configuration programming centered environment and some application examples are presented in order to demonstrate the useful features of the combined approach.
[LTBWR03] "LNCS:2614:Wetware"
A. G. Laws, A. Taleb-Bendiab, S. J. Wade, and D. Reilly. From wetware to software: A cybernetic perspective of self-adaptive software. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 257-280. Springer-Verlag, 2003.
Abstract
The development and application of software engineering practices over the last thirty years have undoubtedly resulted in the production of significantly improved software. However, the majority of modern software systems remain intrinsically fragile and highly vulnerable to environmental change and require continuing and problematic manual adaptation. In this paper and given the problems inherent in manual software adaptation, the authors argue that imbuing the software system with the ability to self-adapt offers a potentially profitable route forward. For support of this claim, the authors draw on the emerging discipline of self-adaptive software, which seeks to devolve some of the responsibility for maintenance activity to the software itself. Realizing such auto-adaptive capability proves to be a challenging problem. The authors contend that many of the themes, problems and goals currently identified in the field of self-adaptive software bear a striking resemblance to problems that have long formed the basis of enquiry in the well-established field of cybernetics. Classical cybernetics, drawing on mathematical models of the adaptive processes of biological organisms, seeks to identify the general principles of control and communication required for organisms to survive in a changing environment. Consequently, cybernetics appears to offer the potential to apply naturally developed adaptation strategies to software artifacts. Therefore, after discussing these theoretical foundations, this paper reports their practical application by presenting the initial findings from the development of an experimental, agent based, adaptive In-Vehicle Telematics System (IVTS) for use by the Emergency Services.
[LV92] "Lynch1992:Timed-Automata"
Nancy Lynch and Frits Vaandrager. Forward and backward simulations for timing-based systems. In Proceedings of Real-Time: Theory in Practice, volume 600 of Lecture Notes in Computer Science (LNCS), pages 397-446. Springer-Verlag, 1992.
Abstract
A general automaton model for timing-based systems is presented and is used as the context for developing a variety of simulation proof techniques for such systems. As a first step, a comprehensive overview of simulation techniques for simple untimed automata is given. In particular, soundness and completeness results for (1) refinements, (2) forward and backward simulations, (3) forward-backward and backward-forward simulations, and (4) history and prophecy relations are given. History and prophecy relations are new and are abstractions of the history variables of Owicki and Gries and the prophecy variables of Abadi and Lamport, respectively. As a subsequent step, it is shown how most of the results for untimed automata can be carried over to the setting of timed automata. In fact, many of the results for the timed case are obtained as consequences of the analogous results for the untimed case.
[LV95] "Dynamic-Rapide"
D. Luckham and J. Vera. An event-based architectural definition language. IEEE Transactions on Software Engineering, 21(9):717-734, 1995.
[LWF03] "Lopes2003:High-order-connectors"
Antónia Lopes, Michel Wermelinger, and José Luiz Fiadeiro. Higher-order architectural connectors. ACM Transactions on Software Engineering Methodology, 12(1):64-104, 2003.
Abstract
We develop a notion of higher-order connector towards supporting the systematic construction of architectural connectors for software design. A higher-order connector takes connectors as parameters and allows for services such as security protocols and fault-tolerance mechanisms to be superposed over the interactions that are handled by the connectors passed as actual arguments. The notion is first illustrated over CommUnity, a parallel program design language that we have been using for formalizing aspects of architectural design. A formal, algebraic semantics is then presented which is independent of any Architectural Description Language. Finally, we discuss how our results can impact software design methods and tools.
[MAD00] "Morse2000:What-who-bla-Context"
David R. Morse, Stephen Armstrong, and Anind K. Dey. The what, who, where, when, why and how of context-awareness. In CHI '00 extended abstracts on Human factors in computing systems, pages 371-371. ACM Press, 2000.
Abstract
When humans talk with humans, they are able to use implicit situational information, or context, to increase the conversational bandwidth. This ability to use contextual information does not transfer well to human-computer interaction. Part of the problem is the impoverished mechanisms for providing input to computers. Another aspect of the problem is that often we don't know what contextual information is relevant, useful, or even how to use it. However, by improving the computer's access to its context, we can increase the richness of communication in human-computer interaction and make it possible to produce more useful computational services.
[Mae87] "Maes1987:Paper:Computational-Reflection"
Pattie Maes. Concepts and experiments in computational reflection. In Conference proceedings on Object-oriented programming systems, languages and applications, pages 147-155. ACM Press, 1987. Paper zur gleichnamigen Dissertation.
Abstract
This paper brings some perspective to various concepts in computational reflection. A definition of computational reflection is presented, the importance of computational reflection is discussed and the architecture of languages that support reflection is studied. Further, this paper presents a survey of some experiments in reflection which have been performed. Examples of existing procedural, logic-based and rule-based languages with an architecture for reflection are briefly presented. The main part of the paper describes an original experiment to introduce a reflective architecture in an object-oriented language. It stresses the contributions of this language to the field of object-oriented programming and illustrates the new programming style made possible. The examples show that a lot of programming problems that were previously handled on an ad hoc basis, can in a reflective architecture be solved more elegantly.
[MB04] "Moreira2004:FORMAware"
Rui S. Moreira and Gordon S. Blair. Supporting adaptable distributed systems with formaware. In Proceedings of the 24th International Conference on Distributed Computing Systems Workshops - W7: EC (ICDCSW'04), pages 320-325. IEEE Computer Society, 2004.
[MC02] "McGurren2002:X-Adapt"
Finnbar McGurren and Damien Conroy. X-adapt: An architecture for dynamic systems, June 2002.
[Med96] "C2-Dynamic-AML"
Nenad Medvidovic. Adls and dynamic architecture changes. In Joint proceedings of the second international software architecture workshop (ISAW-2) and international workshop on multiple perspectives in software development (Viewpoints '96) on SIGSOFT '96 workshops, pages 24-27. ACM Press, 1996.
Abstract
Existing ADLs typically support only static architecture specification and do not provide facilities for the support of dynamically changing architectures. This paper presents a possible solution to this problem: in order to adequately support dynamic architecture changes, ADLs can leverage techniques used in dynamic program- ming languages. In particular, changes to ADL specifications should be interpreted. To enable interpretation, an ADL should have an architecture construction component that supports explicit and incremental specification of architectural changes, in addition to the traditional architecture description facilities. This will allow software architects to specify the changes to an architecture after it has been built. The paper expands upon the results from an ongoing project - building a development environment for CZstyle architectures.
[Men01] "LNCS:1936:Meng:Evaluating"
Alex C. Meng. On evaluating self-adapive software. In Self-Adaptive Software: First International Workshop, IWSAS 2000, Oxford, UK, April 2000, volume 1936 of Lecture Notes in Computer Science (LNCS), pages 65-74. Springer-Verlag, 2001.
Abstract
This article attempts to address the issues of evaluating self-adaptive software systems, an emerging discipline. Since the field is in its early phase and has not produced enough mature systems for consideration, we try to approach the evaluation issue by considering a descriptive model of self-adaptive software based on control systems. Taking inspirations and using the vocabularies from the feedforward and feedback control paradigms, this article will illustrate the analogous properties in self-adaptive software and its evaluation consideration such as stability and robustness. Existing approaches to self-adaptive software take different aspects, ranging from viewing it as new programming paradigm, new architecture style, new modeling paradigm to a new software engineering principle. This article tries to elicit the evaluation consideration from these different aspects
[MK96a] "Dynamic-Darwin"
Jeff Magee and Jeff Kramer. Dynamic structure in software architectures. In Proceedings of the 4th ACM SIGSOFT symposium on Foundations of software engineering, pages 3-14. ACM Press, 1996.
Abstract
Much of the recent work on Architecture Description Languages (ADL) has concentrated on specifying organisations of components and connectors which are static. When the ADL specification is used to drive system construction, then the structure of the resulting system in terms of its component instances and their interconnection is fixed. This paper examines ADL features which permit the description of dynamic software architectures in which the organisation of components and connectors may change during system execution.The paper outlines examples of language features which support dynamic structure. These examples are taken from Darwin, a language used to describe distributed system structure. An operational semantics for these features is presented in the $π$-calculus, together with a discussion of their advantages and limitations. The paper discusses some general approaches to dynamic architecture description suggested by these examples.
[MK96b] "Magee1996:Self-organising-SA"
Jeff Magee and Jeff Kramer. Self organising software architectures. In Joint proceedings of the second international software architecture workshop (ISAW-2) and international workshop on multiple perspectives in software development (Viewpoints '96) on SIGSOFT '96 workshops, pages 35-38. ACM Press, 1996.
[MMÖB03] "Montresor2003:Toward-Self-organizing"
Alberto Montresor, Hein Meling, and Özalp Babaoglu. Toward self-organizing, self-repairing and resilient distributed systems. In Future Directions in Distributed Computing, volume 2584 of Lecture Notes in Computer Science (LNCS), pages 119-123. Springer-Verlag, 2003.
Abstract
As access to networked applications become omnipresent through PC's, hand-held and wireless devices, an increasing number of interactions in our day-to-day life with significant economical, social and cultural consequences depend on the reliability, availability and security of distributed systems. Not surprisingly, the increased demand that is being placed by users on networked services can only be met by distributed infrastructures with greater complexity and larger scale. And the extreme dynamism that is often present in different forms in modern systems further aggravates our ability to reason formally about their behavior.
[Mon01] "Monroe2001:Armani"
Robert T. Monroe. Capturing software architecture design expertise with armani. Technical Report CMU-CS-98-163, January 2001. revised Version.
Abstract
Armani is a language for capturing software architecture design expertise and specifying software architecture designs. This document describes the Armani language in detail with specifications for the language syntax and semantics, as well as examples illustrating common usage.
[Mor01] "Moreira2001"
Rui S. Moreira. A reflective component-based & architecture aware framework to manage architecture composition. In Proceedings of the Third International Symposium on Distributed Objects and Applications, pages 187-196. IEEE Computer Society, 2001.
Abstract
Large scale distributed systems are typically evolving environments that have to deal with interoperability, scalability, mobility and QoS adaptability requirements. Generically, these systems need adaptation mechanisms to cope with short-term (cf. programmed reconfiguration) and long-term requirements (cf. evolutionary reconfiguration). In this paper we propose a reflective component-based framework with architecture style awareness for managing architecture composition and constraining adaptation. Specifically, this framework provides the necessary tools to generate and manipulate the programming model abstractions (i.e. components, connectors and respective properties and interfaces). The framework offers a principled way to deal with both introspection and adaptation of basic and composite components. It provides the developers with the ability to choose, extend and modify architecture style managers. These managers are responsible to represent and check architecture constraints both at development and deployment time, i.e. before any architectural reconfiguration may be committed.
[Mor03] "Moreira2003:Thesis"
Rui S. Moreira. FORMAware: Framework of Reflective Components for Managing Architecture Adaptation. PhD thesis, Lancaster University, October 2003.
[Mot03] "Motuzenko2003:Adaptive-domain-model"
Pavel Motuzenko. Adaptive domain model: dealing with multiple attributes of self-managing distributed object systems. In Proceedings of the 1st international symposium on Information and communication technologies (ISICT'03), pages 549-554. Trinity College Dublin, 2003.
Abstract
Self-managing software has emerged as modern systems have become more complex. Some of the distributed object systems may contain thousands of objects deployed on tens or even hundreds hosts. Development and support of such systems often costs a lot. To solve this issue the systems, which are capable supporting multiple self-managing attributes, should be created. In the paper, the Adaptive domain concept is introduced as an extension to the basic domain concept to support a generic adaptation environment for building distributed object systems with multiple self-managing attributes.
[MP92] "Manna1992:Temporal-Logic-Reactive-Concurrent-Systems"
Zohar Manna and Amir Pnueli. The temporal logic of reactive and concurrent systems. Springer-Verlag New York, Inc., 1992.
[MQR95] "Moriconi1995:Architecture-Refinement"
Mark Moriconi, Xiaolei Qian, and R. A. Riemenschneider. Correct architecture refinement. IEEE Transactions on Software Engineering, 21(4):356-3, 1995.
Abstract
A method is presented for the stepwise refinement of an abstract architecture into a relatively correct lower level architecture that is intended to implement it. A refinement step involves the application of a predefined refinement pattern that provides a routine solution to a standard architectural design problem. A pattern contains an abstract architecture schema and a more detailed schema intended to implement it. The two schemas usually contain very different architectural concepts (from different architectural styles). Once a refinement pattern is proven correct, instances of it can be used without proof in developing specific architectures. Individual refinements are compositional, permitting incremental development and local reasoning. A special correctness criterion is defined for the domain of software architecture, as well as an accompanying proof technique. A useful syntactic form of correct composition is defined. The main points are illustrated by means of familiar architectures for a compiler. A prototype implementation of the method has been used successfully in a real application.
[MRMM02] "Mikic-Rakic2002:Architectural-style-requirements"
Marija Mikic-Rakic, Nikunj Mehta, and Nenad Medvidovic. Architectural style requirements for self-healing systems. In Proceedings of the first workshop on Self-healing systems, pages 49-54. ACM Press, 2002.
Abstract
This paper argues for a set of requirements that an architectural style for self-healing systems should satisfy: adaptability, dynamicity, awareness, autonomy, robustness, distributability, mobility, and traceability. Support for these requirements is discussed along five dimensions we have identified as distinguishing characteristics of architectural styles: external structure, topology rules, behavior, interaction, and data flow. As an illustration, these requirements are used to assess an existing architectural style. While this initial formulation of the requirements appears to have utility, much further work remains to be done in order to apply it in evaluating and comparing architectural styles for self-healing systems.
[NM98] "Niemelae98:Dynamic-Configuration"
Eila Niemelä and Juha Marjeta. Dynamic configuration of distributed software components. In Third International Workshop on Component-Oriented Programming (WCOP'98), 1998.
Abstract
Dynamic configuration, implying the ability to add, delete and replace software components, needs to be used in conjunction with configuration data and adaptable interfaces to develop flexible distributed systems. Software adaptability and reusability often generate contradictory requirements, which have to be balanced against those that emerge from the application domain and product features. In our approach, software reconfiguration is based on a layered software architecture and mediumgrained components implemented as distributed agents. Software flexibility is achieved by Distributed Presentation Abstraction Control (DPAC) agents communicating through a two-level Configurable Module Interface (COMI) which supports broadcast and multicast asynchronous message passing. The COMI interface developed here is a set of object classes providing run-time configuration support and intended for use by a configuration manager and a connection manager, which create another part of the configuration support.
[o.] "UIML:Homepage"
o. V. Uiml.org.
[Obj02] "Objs2002:ProbeMeister"
Object Services & Consulting, Inc. Probemeister, 2002.
[OGT+99] "Oreizy1999:Architecture-SAS"
Peyman Oreizy, Michael M. Gorlick, Richard N. Taylor, Dennis Heimbigner, Gregory Johnson, Nenad Medvidovic, Alex Quilici, David S. Rosenblum, and Alexander L. Wolf. An architecture-based approach to self-adaptive software. IEEE Intelligent Systems, 14(3):54-62, 1999.
[OHT00] "Ossher2000:SE-roadmap"
Harold Ossher, William Harrison, and Peri Tarr. Software engineering tools and environments: a roadmap. In Proceedings of the conference on The future of Software engineering, pages 261-277. ACM Press, 2000.
Abstract
The term distributed computing conjures the image of a xed network structure whose nodes support the execution of processes that communicate with each other via messages traveling along links. Peer-to-peer communication is feasible but client-server relationships dominate. More recently, servers have been augmented with brokerage capabilities to facilitate discovery of available services. Stability is the ideal mode of operation; changes are relatively slow; even in the case of failure, nodes and links are expected eventually to come back up. By contrast, mobility represents a total meltdown of all the stability assumptions (explicit or implicit) associated with distributed computing. The network structure is no longer xed, nodes may come and go, processes may move among nodes, and even programs (the code executed by processes) may evolve and change structure. The challenges and opportunities associated with this computational melee form the main subject of this paper. We seek to sort out this chaotic form of computing by focusing our attention on the formulation of a simple framework for viewing mobility, on precise definition of terms, and on research issues mobility poses for the software engineering community.
[OMT98] "Oreizy1998:Architecture-Based-SW-Evolution"
Peyman Oreizy, Nenad Medvidovic, and Richard N. Taylor. Architecture-based runtime software evolution. In Proceedings of the 20th international conference on Software engineering, pages 177-186. IEEE Computer Society, 1998.
[Ore96] "Oreizy:Runtime-Modification"
Peyman Oreizy. Issues in the runtime modification of software architectures. Technical Report UCI-ICS-TR-96-35, August 1996.
Abstract
Existing software architecture research has focused on static architectures, where the system architecture is not expected to change during system execution. We argue that the architectures of many systems, especially long running or mission critical systems, evolve during execution, and thus cannot be accurately modeled and analyzed using static architectures. To overcome these problems, we propose the use of dynamic architectures, where the system architecture may change during execution. In this paper, we identify the issues involved in supporting dynamic architectures. Although some of these issues may be addressed by augmenting current models (i.e., adding constructs that support dynamism to existing architectural description languages), many are new to dynamic architectures (i.e., runtime support for modifying architectures). We describe an initial implementation of our tool, ArchShell, that supports the runtime modification of C2-style software architectures.
[PAG03] "Popovici2003:AOP-Dynamic-Weaving-Java"
Andrei Popovici, Gustavo Alonso, and Thomas Gross. Just-in-time aspects: Efficient dynamic weaving for java. In Proceedings of the 2nd international conference on Aspect-oriented software development, pages 100-109. ACM Press, 2003.
Abstract
Recent developments in service architectures suggest that run-time adaptations could be implemented with dynamic AOP. In this paper we discuss application requirements on run-time AOP support and present a system that addresses these requirements. We provide basic support for weaving using the Just-In-Time compiler, while the AOP system is treated as an exchangeable module on top of the basic support. This approach allows us to provide low run-time overhead, AOP system flexibility, and secure weaving. We provide an extensive empirical evaluation and discuss the tradeoffs resulting from using the JIT compiler and a modularized architecture.
[Par] "jenz"
Jenz & Partner. Eine anwendungsarchitektur für adaptive systeme.
[Pol03] "Poladian2003:Discussion-Summary:Control"
Vahe Poladian. 17-811 self-healing systems: Class discussion summary, 17. March 2003.
[Pom93] "Pomerleau1993:Neural-network-perception"
Dean Pomerleau. Neural network perception for mobile robot guidance. Kluwer Academic Publishing, July 1993.
[PTK01] "LNCS:Agent-Integration"
David V. Pynadath, Milind Tambe, and Gal A. Kaminka. Adaptive infrastructures for agent integration. In Infrastructure for Agents, volume 1887 of Lecture Notes in Computer Science (LNCS), pages 80-93. Springer-Verlag, 2001.
Abstract
With the proliferation of software agents and smart hardware devices there is a growing realization that large-scale problems can be addressed by integration of such stand-alone systems. This has led to an increasing interest in integration infrastructures that enable a heterogeneous variety of agents and humans to work together. In our work, this infrastructure has taken the form of an integration architecture called Teamcore. We have deployed Teamcore to facilitate/enable collaboration between different agents and humans that differ in their capabilities, preferences, the level of autonomy they are willing to grant the integration architecture, their information requirements and performance. This paper first provides a brief overview of the Teamcore architecture and its current applications. The paper then discusses some of the research challenges we have focused on. In particular, the Teamcore architecture is based on general purpose teamwork coordination capabilities. However, it is important for this architecture to adapt to meet the needs and requirements of specific individuals. We describe the different techniques of architectural adaptation, and present initial experimental results.
[Rad04] "CZ:OC"
Rochus Rademacher. It-architektur à la nature. Computer Zeitung, 10(1):1, 6, 1. March 2004.
[RB99] "Robertson1999:Adaptive-Image-Analysis"
Paul Robertson and J. Michael Brady. Adaptive image analysis for aerial surveillance. IEEE Intelligent Systems, 14(3):30-36, 1999.
[Ree01] "Reece2001:Multi-sensor-Systems"
Steven Reece. Self-adaptive multi-sensor systems. In Self-Adaptive Software: First International Workshop, IWSAS 2000, Oxford, UK, April 2000, volume 1936 of Lecture Notes in Computer Science (LNCS), pages 224-241. Springer-Verlag, 2001.
Abstract
Our ability to devise safe, reliable multi-sensor systems is critical in an age where sensor platforms are increasingly complex. The difficulties inherent in the design and verification of complex systems necessitates intelligent reconfiguration of sensors and their signal processing tools online. This paper introduces a self-adaptive (i.e. deliberative) approach to flexible model-based image understanding. The methods described in this paper use qualitative reasoning to maintain probabilistic models of qualitative sensor-centred scene descriptors.
[Rit00] "Ritter2000:Dipl"
Thorsten Ritter. Entwurf und implementierung eines rahmenwerks für persistente objekte. Diplomarbeit, Fernuniversität Hagen, 2000.
[RLS01] "LNCS1936introduction"
Paul Robertson, Robert Laddaga, and Howie Shrobe. Introduction: The first international workshop on self-adaptive software. In Self-Adaptive Software: First International Workshop, IWSAS 2000, Oxford, UK, April 2000, volume 1936 of Lecture Notes in Computer Science (LNCS), pages 1-10. Springer-Verlag, 2001.
Abstract
This collection of papers was presented at the international workshop on self adaptive software (IWSAS2000) held at Lady Margaret Hall at the University of Oxford between April 17th and April 19th 2000. They represent the state of the art in a new evolving field of research that attempts to build software systems that are more robust to unpredictable and sometimes hostile environments than we have managed to produce by conventional means.

As we try to solve increasingly difficult problems with computer software we develop new architectures and structures to help support our aggressive endeavors. It is in this light that the need for and the potential benefits of “Self-Adaptive Software” have become apparent.

[Rob01] "Robertson2001:Architecture-Self-Adaptation"
Paul Robertson. An architecture for self-adaptation and its application to aerial image understanding. In Self-Adaptive Software: First International Workshop, IWSAS 2000, Oxford, UK, April 2000, volume 1936 of Lecture Notes in Computer Science (LNCS), pages 199-223. Springer-Verlag, 2001.
Abstract
Certain problems in which the environment is not well constrained do not lend themselves to a conventional open loop solution. Image understanding is such a problem domain. Image analysis programs are notoriously brittle. By using a self-adaptive approach for these problem domains we may be able to produce more robust and useful behavior. We describe an architecture that uses reflection to provide a mechanism for self-monitoring and self-modification and uses code synthesis as a means of modifying code dynamically in the face of changing assumptions about the environment of the computation.
[Rob03] "LNCS:2614:Robertson:Confidence"
Paul Robertson. Confidence from self-knowledge and domain knowledge. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 84-105. Springer-Verlag, 2003.
Abstract
The GRAVA architecture supports building self-adaptive applications. An overview of the GRAVA architecture, its agent language and its reflective protocol are presented with illustrations from the aerial image interpretation domain.
[RSL01] "LNCS:1936"
Paul Robertson, Howie Shrobe, and Robert Laddaga, editors. Self-Adaptive Software: First International Workshop (IWSAS 2000), volume 1936 of Lecture Notes in Computer Science (LNCS). Springer-Verlag, 2001.
[RTBLB02] "Reilly2002:WOSS"
D. Reilly, A. Taleb-Bendiab, A. Laws, and N. Badr. An instrumentation and control-based approach for distributed application management and adaptation. In Proceedings of the first workshop on Self-healing systems, pages 61-66. ACM Press, 2002.
[RZ03] "Roettger2003:CQML+"
Simone Röttger and Steffen Zschaler. Cqml$^+$: Enhancements to cqml. In Proceedings 1st International Workshop on Quality of Service in Component-Based Software Engineering, Toulouse, France, pages 43-56. Cépaduès- Éditions, June 2003.
[SAA03] "SAACS2003"
SAACS. 1st international workshop on autonomic computing systems, prague, czech republic, september 1-5, 2003.
[SAA04] "SAACS2004"
SAACS. 2nd international workshop on self-adaptive and autonomic computing systems (saacs 04), zaragoza, spain, august 30-september 4th, 2004.
[Sal04] "DASADA2004"
John Salisan. Dynamic assembly for systems adaptability, dependability, and assurance (dasada), 2004.
[SAT+99] "Schmidt99:Advanced-Context"
Albrecht Schmidt, Kofi Asante Aidoo, Antti Takaluoma, Urpo Tuomela, Kristof Van Laerhoven, and Walter Van de Velde. Advanced interaction in context. In Handheld and Ubiquitous Computing: First International Symposium, HUC'99, Karlsruhe, Germany, September 1999, volume 1707 of Lecture Notes in Computer Science (LNCS), pages 89-101. Springer-Verlag, 1999.
Abstract
Mobile information appliances are increasingly used in numerous different situations and locations, setting new requirements to their interaction methods. When the user's situation, place or activity changes, the functionality of the device should adapt to these changes. In this work we propose a layered real-time architecture for this kind of context-aware adaptation based on redundant collections of low-level sensors. Two kinds of sensors are distinguished: physical and logical sensors, which give cues from environment parameters and host information. A prototype board that consists of eight sensors was built for experimentation. The contexts are derived from cues using real-time recognition software, which was constructed after experiments with Kohonen's Self-Organizing Maps and its variants. A personal digital assistant (PDA) and a mobile phone were used with the prototype to demonstrate situational awareness. On the PDA font size and backlight were changed depending on the demonstrated contexts while in mobile phone the active user profile was changed. The experiments have shown that it is feasible to recognize contexts using sensors and that context information can be used to create new interaction metaphors.
[SBG99] "There-is-more-to-context"
Albrecht Schmidt, Michael Beigl, and Hans-W. Gellersen. There is more to context than location. Computers and Graphics, 23(6):893-901, 1999.
[SC94] "sanders94"
Joc Sanders and Eugene Curran. Software Quality: A Framework for Success in Software Development and Support. 1994.
[SC02a] "Adaptability:NFR-Approach"
Nary Subramanian and Lawrence Chung. Software architecture adaptability: an nfr approach. In Proceedings of the 4th international workshop on Principles of software evolution, pages 52-61. ACM Press, 2002.
Abstract
Adaptation of software systems is almost an inevitable process, due to the change in customer requirements, needs for faster development of new, or maintenance of existing, software systems, etc. No doubt numerous techniques have been developed to deal with adaptation of software systems. In this paper we present an overview of some of these techniques. As the first step in the development of software solution it is our opinion that software architecture should itself be adaptable for the final software system to be adaptable. In order to systematically support adaptation at the architectural level, this paper adapts the NFR (Non-Functional Requirements) Framework and treats software adaptability requirement as a goal to be achieved during development. Through this adaptation, then, consideration of design alternatives, analysis of tradeoffs and rationalization of design decisions are all carried out in relation to the stated goals, and captured in historical records. This NFR approach can also be adapted to a knowledge-based approach for (semi-)automatically generating architectures for adaptable software systems and we also discuss how this can be achieved.
[SC02b] "Subramanian2002:Tool-Support-adaptability"
Nary Subramanian and Lawrence Chung. Tool support for engineering adaptability into software architecture. In Proceedings of the international workshop on Principles of software evolution, pages 86-96. ACM Press, 2002.
Abstract
Development of adaptable software has been receiving much attention recently, as such software could better accommodate changes in user requirements as well as in needs of the developing organization. This paper considers software adaptability as a key non-functional requirement (NFR) for evolving systems. One of the major problems in developing adaptable software is the lack of systematic methods to ensure adaptability in the software during the process of software development. One framework to handle such non-functional requirements is the NFR Framework. In this paper we describe a tool called the SA$^3$ (Software Architecture Adaptability Assistant) that helps develop (semi-)automatically adaptable architectures. An adaptable architecture will help to ensure that the final system is adaptable as well. SA$^3$ uses the NFR Framework to develop the architectures, in particular the knowledge base properties of the Framework. Although preliminary, we also show the use of the current version of this tool in developing architectures for embedded systems.
[Sch04] "Schmeck2004:Praesi"
Hartmut Schmeck. Organic computing: Selbstorganisation, 27. April 2004.
[Sel04] "Self-Star2004"
Self-$*$. Self-star: International workshop on self-* properties in complex information systems, 31 may-2 june 2004, university of bologna, 2004.
[SG02] "Schmerl2002:Exploiting-architectural-design-knowledge"
Bradley Schmerl and David Garlan. Exploiting architectural design knowledge to support self-repairing systems. In Proceedings of the 14th international conference on Software engineering and knowledge engineering, pages 241-248. ACM Press, 2002.
Abstract
In an increasing number of domains software is now required to be self-adapting and self-healing. While in the past such abilities were incorporated into software on a per system basis, proliferation of such systems calls for more generalized mechanisms to manage dynamic adaptation. General mechanisms have the advantage that they can be reused in numerous systems, analyzed separately from the system being adapted, and easily changed to incorporate new adaptations. Moreover, they provide a natural home for encoding the expertise of system designers and implementers about adaptation strategies and policies. In this paper, we show how current software architecture tools can be extended to provide such generalized dynamic adaptation mechanisms.
[Sha96] "Shamma1996:Reconfigurable-Control"
Jeff S. Shamma. Linearization and Gain-Scheduling, chapter 20.3, pages 388-398. The electrical engineering handbook series. 1996.
[SHH+00] "Schill2000:Erstantrag-Comquad"
Alexander Schill, Herrmann Härtig, Heinrich Hußmann, Klaus Meißner, Klaus Meyer-Wegener, and Andreas Pfitzmann. Antrag auf sachbeihilfe zur einrichtung einer forschergruppe an der technischen universität dresden, August 2000. Erstantrag \textscComquad.
[SK03a] "LNCS:2614:SSCS"
Deepak Seth and Mieczyslaw M. Kokar. Sscs: A smart spell checker system implementation. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 187-197. Springer-Verlag, 2003.
Abstract
The subject of this paper is a Smart Spell Checker System (SSCS) that can adapt to a particular user by using the user's feedback for adjusting its behavior. The result of the adjustment is manifested in a different ordering of the suggestions to the user on how a particular spelling mistake should be corrected. The SSCS uses the Adaptive Software Architecture (ASA). The ASA consists of a hierarchy of layers, each containing a number of components calledKnowledge Sources. The layers are connected by a software bus called Domain. External elements include User and Initiator(s). Initiators supply input data to the system. The system also includes an Evaluator that generates feedback. Each Knowledge Source is responsible for generating suggestions for correcting a specific type of error. Feedback is propagated to Knowledge Sources after the user makes a selection of the correction. In response to feedback, Knowledge Sources adjust their algorithms. In this paper we present the results of the evaluation of the adaptability of the SSCS.
[SK03b] "LNCS:2614:Agent-based-State-Estimation"
Alvaro Soto and Pradeep Khosla. Adaptive agent based system for state estimation using dynamic multidimensional information sources. In Self-Adaptive Software - Applications: Second International Workshop (IWSAS 2001), volume 2614 of Lecture Notes in Computer Science (LNCS), pages 66-83. Springer-Verlag, 2003.
Abstract
This paper describes a new approach for the creation of an adaptive system able to selectively combine dynamic multidimensional information sources to perform state estimation. The system proposed is based on an intelligent agent paradigm. Each information source is implemented as an agent that is able to adapt its behavior according to the relevant task and environment constraints. The adaptation is provided by a local self-evaluation function on each agent. Cooperation among the agents is given by a probabilistic scheme that integrates the evidential information provided by them. The proposed system aims to achieve two highly desirable attributes of an engineering system: robustness and efficiency. By combining the outputs of multiple vision modules the assumptions and constrains of each module can be factored out to result in a more robust system overall. Efficiency is still kept through the on-line selection and specialization of the agents. An initial implementation for the case of visual information demonstrates the advantages of the approach for two frequent problems faced by a mobile robot: dynamic target tracking and obstacle detection.
[SL04] "Seifert2004:Farbsehtest"
Julia Seifert and Christiane Lammersen. Modellierung der farbsehfähigkeiten, 4. March 2004.
[SMAF00] "Shen2000:High-performance-adaptive-middleware"
E-Kai Shen, Shikharesh Majumdar, and Istabrak Abdul-Fatah. High performance adaptive middleware for corba-based systems. In Proceedings of the nineteenth annual ACM symposium on Principles of distributed computing, pages 199-207. ACM Press, 2000.
Abstract
Middleware provides inter-operability and transparent location of servers in a heterogeneous distributed environment. A careful design of the middleware software is required however for achieving high performance. This research proposes an adaptive middleware architecture for CORBA-based systems. The adaptive middleware agent that maps an object name to the object reference has two modes of operations. In the handle-driven mode it returns a reference for the requested object to the client that uses this reference to re-send the request for the desired operation to the server whereas in the forwarding mode it forwards the entire client request to the server. The server upon invocation performs the desired operation and returns the results to the client. An adaptive ORB dynamically switches between these two modes depending on the current system load. Using a commercial middleware product called Orbix-MT we have implemented a skeletal performance prototype for the adaptive ORB. Based on measurements made on a network of workstations and a synthetic workload we observe that the adaptive ORB can produce a substantial benefit in performance in comparison to a pure handle-driven or a pure forwarding ORB. Our measurements provide valuable insights into system behavior and performance.
[Smi82] "Smith1982:PHD"
Brian Cantwell Smith. Reflection and Semantics in a Procedural Language. PhD thesis, MIT Laboratory for Computer Science, Cambridge, MA, 1982.
[Spr04] "Springer2004:Thesis"
Thomas Springer. Ein komponentenbasiertes Meta-Modell kontextabhängiger Adaptionsgraphen für mobile und ubiquitäre Anwendungen. PhD thesis, Technische Universität Dresden, March 2004.
[Ste03a] "What-u-need-to-know-Autonomic-Computing1"
Daniel H. Steinberg. What you need to know about autonomic computing, part 1: An introduction and overview, August 2003.
[Ste03b] "What-u-need-to-know-Autonomic-Computing2"
Daniel H. Steinberg. What you need to know about autonomic computing, part 2: The infrastructure, August 2003.
[TA96] "Workshop-Linz"
Bedir Tekinerdogan and Mehmet Aksit. Adaptability in object-oriented software development workshop report, 1996. 10th European Conference on Object-Oriented Programming, July 8-12, 1996, Linz, Austria.
[Ten00] "Tennenhouse2000:Proactive-Computing"
David Tennenhouse. Proactive computing. Communications of the ACM, 43(5):43-50, 2000.
[TSCS01] "Tisato2001:Architectural-Reflection"
Francesco Tisato, Andrea Savigni, Walter Cazzola, and Andrea Sosio. Architectural reflection: Realising software architectures via reflective activities. In Engineering Distributed Objects: Second International Workshop (EDO 2000), volume 1999 of Lecture Notes in Computer Science (LNCS), pages 102-115. Springer-Verlag, 2001.
Abstract
Architectural reflection is the computation performed by a software system about its own software architecture. Building on previous research and on practical experience in industrial projects, in this paper we expand the approach and show a practical (albeit very simple) example of application of architectural reflection. The example shows how one can express, thanks to reflection, both functional and non-functional requirements in terms of object-oriented concepts, and how a clean separation of concerns between application domain level and architectural level activities can be enforced.
[TT04] "Taylor2004:Control-Theory"
Richard Taylor and Chris Tofts. Self managed systems: A control theory perspective. In SELF-STAR: International Workshop on Self-* Properties in Complex Information Systems, 31 May-2 June 2004, University of Bologna, 2004.
[VDB04] "taxonomy-resource-discovery"
Koen Vanthournout, Geert Deconinck, and Ronnie Belmans. A taxonomy for resource discovery. In Organic and Pervasive Computing - ARCS 2004: International Conference on Architecture of Computing Systems, Augsburg, Germany, March 23-26, 2004, volume 2981 of Lecture Notes in Computer Science (LNCS), pages 78-91. Springer-Verlag, 2004.
Abstract
Resource discovery systems become more and more important as distributed systems grow and as their pool of resources becomes more variable. As such, an increasing amount of networked systems provide a discovery service. This paper provides a taxonomy for resource discovery systems by defining their design aspects. This allows comparison of the designs of the deployed discovery services and is intended as an aid to system designers when selecting an appropriate mechanism. The surveyed systems are divided into four classes that are separately described. Finally, we identify a hiatus in the design space and point out genuinely distributed resource discovery systems that support dynamic and mobile resources and use attribute-based naming as a main direction for future research in this area.
[VDE03] "OC-Paper"
VDE/ITG/GI. Organic computing: Computer- und systemarchitektur im jahr 2010, July 2003. Positionspapier der Organic-Computing-Initiative.
[VHT00] "Vallecillo2000:Issues-Interoperability"
Antonio Vallecillo, Juan Hernández, and José M. Troya. New issues in object interoperability. In Object-Oriented Technology: ECOOP 2000 Workshop Reader, volume 1964 of Lecture Notes in Computer Science (LNCS), pages 256-269. Springer-Verlag, 2000.
Abstract
This report summarizes the presentations, discussions, and outcomes of the ECOOP'2000 Workshop on Object Interoperability, held in Sophia Antipolis, France, on Monday, June 12, 2000. Divided into four main sessions, the workshop covered some of the most important issues related to object interoperability at different levels (such as protocols or semantics). This report has two main goals. First, it tries to provide a snapshot of some of the current research being carried out within the object-oriented community in these areas. And second, it summarizes some of the open questions and issues related to object interoperability, in order to set the basis for further research activities.
[VK02a] "Valetto:Case-Study-SA"
Giuseppe Valetto and Gail Kaiser. A case study in software adaptation. In Proceedings of the first workshop on Self-healing systems, pages 73-78. ACM Press, 2002.
Abstract
We attach a feedback-control-loop infrastructure to an existing target system, to continually monitor and dynamically adapt its activities and performance. (This approach could also be applied to \myquotenew systems, as an alternative to \myquotebuilding in adaptation facilities, but we do not address that here.) Our infrastructure consists of multiple layers, with the objectives of 1. probing, measuring and reporting of activity and state during the execution of the target system among its components and connectors; 2. gauging, analysis and interpretation of the reported events; and 3. whenever necessary, feedback onto the probes and gauges, to focus them (e.g., drill deeper), or onto the running target system, to direct its automatic adjustment and reconfiguration. We report on our successful experience using this approach in the dynamic adaptation of a large-scale commercial application requiring both coarse and fine-grained modifications.
[VK02b] "Valetto2002:Workflakes"
Giuseppe Valetto and Gail Kaiser. Combining mobile agents and process-based coordination to achieve software adaptation. Technical Report CUCS-007-02, March 2002.
Abstract
We have developed a model and a platform for end-to-end run-time monitoring, behavior and performance analysis, and consequent dynamic adaptation of distributed applications. This paper concentrates on how we coordinate and actuate the potentially multi-part adaptation, operating externally to the target systems, that is, without requiring any a priori built-in adaptation facilities on the part of said target systems. The actual changes are performed on the fly onto the target by communities of mobile software agents, coordinated by a decentralized process engine. These changes can be coarse-grained, such as replacing entire components or rearranging the connections among components, or fine-grained, such as changing the operational parameters, internal state and functioning logic of individual components. We discuss our successful experience using our approach in dynamic adaptation of a large-scale commercial application, which requires both coarse and fine grained modifications.
[VK03] "Valetto2003:Process-technology"
Giuseppe Valetto and Gail Kaiser. Using process technology to control and coordinate software adaptation. In Proceedings of the 25th international conference on Software engineering, pages 262-272. IEEE Computer Society, 2003.
Abstract
We have developed an infrastructure for end-to-end run-time monitoring, behavior/performance analysis, and dynamic adaptation of distributed software. This infrastructure is primarily targeted to pre-existing systems and thus operates outside the target application, without making assumptions about the target's implementation, internal communication computation mechanisms, source code availability, etc. This paper assumes the existence of the monitoring and analysis components, presented elsewhere, and focuses on the mechanisms used to control and coordinate possibly complex repairs/reconfigurations to the target system. These mechanisms require lower- level effectors somehow attached to the target system, so we briefly sketch one such facility (elaborated elsewhere). Our main contribution is the model, architecture, and implementation of Workflakes, the decentralized process engine we use to tailor, control, coordinate, etc. a cohort of such effectors. We have validated the Workflakes approach with case studies in several application domains. Due to space restrictions we concentrate primarily on one case study, briefly discuss a second, and only sketch others.
[VKK01] "LNCS:Process-Based"
Giuseppe Valetto, Gail Kaiser, and Gaurav S. Kc. A mobile agent approach to process-based dynamic adaptation of complex software systems. In Software Process Technology: 8th European Workshop, EWSPT 2001, Witten, Germany, June 19-21, 2001, volume 2077 of Lecture Notes in Computer Science (LNCS), pages 102-116. Springer-Verlag, 2001.
Abstract
We describe an approach based upon software process technology to on-the-fly monitoring, redeployment, reconfiguration, and in general dynamic adaptation of distributed software applications. We choose the term dynamic adaptation to refer to modifications in structure and behavior that can be made to individual components, as well as sets thereof, or the overall target system configuration, such as adding, removing or substituting components, while the system is running and without bringing it down. The goal of dynamic adaptation is manifold: supporting run-time software composition, enforcing adherence to requirements, ensuring uptime and quality of service of mission-critical systems, recovering from and preventing faults, seamless system upgrading, etc. Our approach involves dispatching and coordinating software agents - named Worklets - via a process engine, since successful dynamic adaptation of a complex distributed software system often requires the concerted action of multiple agents on multiple components. The dynamic adaptation process must incorporate and decide upon knowledge about the specifications and architecture of the target software, as well as Worklets capabilities. Dynamic adaptation is correlated to a variety of other software processes - such as configuration management, deployment, validation and evolution - and allows addressing at run time a number of related concerns that are normally dealt with only at development time.
[vOvdLKM00] "Koala"
Rob van Ommering, Frank van der Linden, Jeff Kramer, and Jeff Magee. The koala component model for consumer electronics software. IEEE Computer, 33(3):78-85, 2000.
Abstract
A component-oriented approach is an ideal way to handle the diversity of software in consumer electronics. The Koala model, used for embedded software in TV sets, allows late binding of reusable components with no additional overhead.
[vv02] "Understanding-Arch-Change"
Chris van der Westhuizen and André van der Hoek. Understanding and propagating architectural change. In Proceedings of the Working IEEE/IFIP Conference on Software Architecture 2002 (WICSA 3), August 2002, 2002.
Abstract
Like source code, architectures change. The use of product line architectures provides a particularly rich source of changes: new products are introduced, existing products are enhanced and modified, and old products are retired. Methods exist that record these kinds of changes by maintaining explicit representations of the evolution of a product line architecture. Despite the availability of such representations, it still is difficult to quickly gain an understanding of the exact changes that define the difference between two products. Furthermore, it is difficult to automatically propagate such changes to yet another, third product in the product line. This paper aims to fill this void and contributes a set of algorithms and an associated representation for understanding and propagating architectural changes within a product line architecture. The approach is based on xADL 2.0, an extensible representation for product line architectures, and adapts well-known differencing and merging algorithms from the field of configuration management to the domain of software architecture.
[VÖU04] "Voruganti2004:Adaptive-Data-shipping"
Kaladhar Voruganti, M. Tamer Özsu, and Ronald C. Unrau. An adaptive data-shipping architecture for client caching data management systems. Distributed Parallel Databases, 15(2):137-177, 2004.
Abstract
Data-shipping is an important form of data distribution architecture where data objects are retrieved from the server, and are cached and operated upon at the client nodes. This architecture reduces network latency and increases resource utilization at the client. Object database management systems (ODBMS), file-systems, mobile data management systems, multi-tiered Web-server systems and hybrid query-shipping/data-shipping architectures all use some variant of the data-shipping. Despite a decade of research, there is still a lack of consensus amongst the proponents of ODBMSs as to the type of data shipping architectures and algorithms that should be used. The absence of both robust (with respect to performance) algorithms, and a comprehensive performance study comparing the competing algorithms are the key reasons for this lack of agreement. In this paper we address both of these problems. We first present an adaptive data-shipping architecture which utilizes adaptive data transfer, cache consistency and recovery algorithms to improve the robustness (with respect to performance) of a data-shipping ODBMS. We then present a comprehensive performance study which evaluates the competing client-server architectures and algorithms. The study verifies the robustness of the new adaptive data-shipping architecture, provides new insights into the performance of the different competing algorithms, and helps to overturn some existing notions about some of the algorithms.
[Wer99] "Wermelinger:PhD"
Miguel Alexandre Wermelinger. Specification of Software Architecture Reconfiguration. PhD thesis, Universidade Nova de Lisboa, September 1999.
Abstract
In the past years, Software Architecture has attracted increased attention by academia and industry as the unifying concept to structure the design of complex systems. One particular research area deals with the possibility of reconfiguring architectures to adapt the systems they describe to new requirements. Reconfiguration amounts to adding and removing components and connections, and may have to occur without stopping the execution of the system being reconfigured. This work contributes to the formal description of such a process. Taking as a premise that a single formalism hardly ever satisfies all requirements in every situation, we present three approaches, each one with its own assumptions about the systems it can be applied to and with different advantages and disadvantages. Each approach is based on work of other researchers and has the aesthetic concern of changing as little as possible the original formalism, keeping its spirit. The first approach shows how a given reconfiguration can be specified in the same manner as the system it is applied to and in a way to be efficiently executed. The second approach explores the Chemical Abstract Machine, a formalism for rewriting multisets of terms, to describe architectures, computations, and reconfigurations in a uniform way. The last approach uses a UNITY-like parallel programming design language to describe computations, represents architectures by diagrams in the sense of Category Theory, and specifies reconfigurations by graph transformation rules.
[Wil01a] "Wile2001:Residual-Requirements"
Residual requirements and architectural residues. In Fifth IEEE International Symposium on Requirements Engineering (RE '01), pages 194-201. IEEE, 2001.
Abstract
Monitoring running systems is a useful technique available to requirements engineers, to ensure that systems meet their requirements and in some cases to ensure that they obey the assumptions under which they were created. This report studies relationships between the original requirements and the monitoring infrastructure. Here we postulate that the monitored requirements are in fact just compilations of original requirements, called "residual" requirements. Dynamic architectural models have become important tools for expressing requirements on modern distributed systems. Monitoring residual requirements will be seen to involve "architectural residues," skeletal run-time images of the original logical architecture. An example sales support system is used to illustrate the issues involved, employing modest extensions to the Acme architecture description language to reason about architectural dynamism.
[Wil01b] "Wile2001:AML"
David S. Wile. Modeling architecture description languages using aml. Automated Software Engineering(8):63-88, 2001.
Abstract
The language AML was designed to specify the semantics of architecture description languages, ADLs, especially ADLs describing architectures wherein the architecture itself evolves over time. Dynamic evolution concerns arise with considerable variation in time scale. One may constrain how a system may evolve by monitoring its development lifecycle. Another approach to such concerns involves limiting systems’ construction primitives to those from appropriate styles. One may wish to constrain what implementations are appropriate; concerns for interface compatibility are then germane. And finally, one may want to constrain the ability of the architecture to be modified as it is running. AML attempts to circumscribe architectures in such a way that one may express all of these constraints without committing to which time scale will be used to enforce them. Example AML specifications of the C2 style and Acme are presented.
[Wil01c] "Using-Dynamic-ACME"
David S. Wile. Using dynamic acme. In Proceedings of a Working Conference on Complex and Dynamic Systems Architecture. Brisbane, Australia. Dec. 2001., 2001.
Abstract
Dynamic architectural models have become important tools for expressing requirements on modern distributed systems. I previously identified “architectural residues,” skeletal run-time images of the original logical architecture, as important reflective models to be maintained in monitoring that running systems meet dynamic requirements. Several years ago I proposed modest extensions to the Acme architecture description language to express aspects of, and reason about, architectural dynamism. Herein these extensions are made more precise; an example illustrates role use in inserting probes and gauges into systems.
[Wil02] "Wile2002:dynamic-architecture-event-languages"
David S. Wile. Towards a synthesis of dynamic architecture event languages. In Proceedings of the first workshop on Self-healing systems, pages 79-84. ACM Press, 2002.
Abstract
Self-healing systems generally require reflective models of their own operation to determine what aspects of themselves they can change to effect repair. Architecture models are examples of rather simple models to which health information can be attached and reasoned about, e.g. attaching system state to a process or tracking events across connectors. These models are especially useful when the architecture of the system varies while the system is running, in so-called "dynamic architectures."DARPA's DASADA program is developing an architecture-based infrastructure for self-healing, self-adapting systems. Herein several protocols for dynamic architecture change notification from that program are examined in search of a community standard for such a protocol. Desirable properties of such protocols are suggested based in part on how much constraint checking will be used to proscribe dynamic architecture building activity. Points for discussion are raised.
[WLF01] "Wermelinger:Graph-based-language"
Michel Wermelinger, Antónia Lopes, and José Luiz Fiadeiro. A graph based architectural (re)configuration language. In Proceedings of the 8th European software engineering conference held jointly with 9th ACM SIGSOFT international symposium on Foundations of software engineering, pages 21-32. ACM Press, 2001.
Abstract
For several different reasons, such as changes in the business or technological environment, the configuration of a system may need to evolve during execution. Support for such evolution can be conceived in terms of a language for specifying the dynamic reconfiguration of systems. In this paper, continuing our work on the development of a formal platform for architectural design, we present a high-level language to describe architectures and for operating changes over a configuration (i.e., an architecture instance), such as adding, removing or substituting components or interconnectons. The language follows an imperative style and builds on a semantic domain established in previous work. Therein, we model architectures through categorical diagrams and dynamic reconfiguration through algebraic graph rewriting.
[Wor04] "Worden2004:Autonomic-maturity-levels"
Daniel Worden. Understand autonomic maturity levels, 2004.
[WPT03] "Want2003:Comparing-autonomic-and-proactive-computing"
Roy Want, Trevor Pering, and David Tennenhouse. Comparing autonomic and proactive computing. IBM Systems Journal, 42(1):129-135, 2003.
[YBJ01] "Yoder2001:Adaptive-object-models"
Joseph W. Yoder, Federico Balaguer, and Ralph Johnson. Architecture and design of adaptive object-models. SIGPLAN Not., 36(12):50-60, 2001.
Abstract
Many object-oriented information systems share an architectural style that emphasizes flexibility and run-time adaptability. Business rules are stored externally to the program such as in a database or XML files instead of in code. The object model that the user cares about is part of the database, and the object model of the code is just an interpreter of the users' object model. We call these systems "Adaptive Object-Models", because the users' object model is interpreted at runtime and can be changed with immediate (but controlled) effects on the system interpreting it. The real power in Adaptive Object-Models is that they have a definition of a domain model and rules for its integrity and can be configured by domain experts external to the execution of the program. This paper describes the Adaptive Object-Model architecture along with its strengths and weaknesses. It illustrates the Adaptive Object-Model architectural style by describing a framework for Medical Observations (following Fowler's Analysis Patterns) that we built.
[YCS+02] "Yang2002:Aspect-oriented-adaptation"
Z. Yang, B. H. C. Cheng, R. E. K. Stirewalt, J. Sowell, S. M. Sadjadi, and P. K. McKinley. An aspect-oriented approach to dynamic adaptation. In Proceedings of the first workshop on Self-healing systems, pages 85-92. ACM Press, 2002.
Abstract
This paper presents an aspect-oriented approach to dynamic adaptation. A systematic process for defining where, when, and how an adaptation is to be incorporated into an application is presented. Specifically, the paper presents a two-phase approach to dynamic adaptation, where the first phase prepares a non-adaptive program for adaptation, and the second phase implements the adaptation at run time. This approach is illustrated with a distributed conferencing application.
[YTL04] "Yahiaoui2004:Classification-Adaptable-Platforms"
Nesrine Yahiaoui, Bruno Traverson, and Nicole Levy. Classification and comparison of adaptable platforms. In First International Workshop on Coordination and Adaptation Techniques for Software Entities (WCAT04), 2004.
[ZGJ04] "LNCS:Aspect-based"
Arturo Zambrano, Silvia Gordillo, and Ignacio Jaureguiberry. Aspect-based adaptation for ubiquitous software. In Mobile and Ubiquitous Information Access: Mobile HCI 2003 International Workshop, Udine, Italy, September 8, 2003, volume 2954 of Lecture Notes in Computer Science (LNCS), pages 215-226. Springer-Verlag, 2004.
Abstract
Information should be available everytime and everywhere in the ubiquitous computing world. Environment conditions such as bandwidth, server availability, physical resources, etc. are volatile and require sophisticated adaptive capabilities. Designing this kind of systems is a complex task, since a lot of concerns could get mixed with the applications core functionality. Aspect-Oriented Programming (AOP) [1] arises as a promising tool in order to design and develop ubiquitous applications, because of its ability to separate cross-cutting concerns. In this paper we propose an AOP-based architecture to decouple the several concerns that ubiquitous software comprises.
[ZLS02] "Zinky2002:Runtime-Performance-Modeling"
John Zinky, Joseph Loyall, and Richard Shapiro. Runtime performance modeling and measurement of adaptive distributed object applications. In On the Move to Meaningful Internet Systems 2002: CoopIS, DOA, and ODBASE: Confederated International Conferences CoopIS, DOA, and ODBASE 2002, volume 2519 of Lecture Notes in Computer Science (LNCS), pages 755-772. Springer-Verlag, 2002. Online in SpringerLink seit: Juni 2003.
Abstract
Distributed applications that can adapt at runtime to changing quality of service (QoS) require a model of the expected QoS and of the possible application adaptations. QoS models in turn require runtime measurements, both in-band and out-of-band, from across the application's components. As the comprehensiveness of the model increases, so does the quality of adaptation. But eventually the increasing comprehensiveness becomes too complex for the QoS Designer to deal with effectively. In addition, performance models of any complexity are expensive to create and maintain at runtime. The QoS Designer therefore needs a set of distributed-QoS tools to assist in the construction of models, the handling of quality vs. complexity tradeoffs, and the efficient maintenance of models at runtime. This paper describes the Quality Objects (QuO) middleware support that provides for developing a performance model; collecting and organizing run-time measurements of a system, both in-band and out-of-band; and maintaining the model at runtime in an efficient way.