[AAM99] "ADL:Springer:09"
Marwan Abi-Antoun and Nenad Medvidovic. Enabling the refinement of a software architecture into a design. In \myquoteUML '99 - The Unified Modeling Language: Beyond the Standard, Second International Conference, Fort Collins, CO, USA, October 1999, volume 1723 of Lecture Notes in Computer Science, pages 17-31. Springer-Verlag, 1999.
Abstract
Software architecture research has thus far mainly addressed formal specification and analysis of coarse-grained software models. The formality of architectural descriptions, their lack of support for downstream development activities, and their poor integration with mainstream approaches have made them unattractive to a large segment of the development community. This paper demonstrates how a mainstream design notation, the Unified Modeling Language (UML), can help address these concerns. We describe a semi-automated approach developed to assist in refining a high-level architecture specified in an architecture description language (ADL) into a design described with UML. To this end, we have integrated DRADEL, an environment for architecture modeling and analysis, with Rational RoseR, a commercial off-the-shelf (COTS) UML modeling tool. We have defined a set of rules to transform an architectural representation into an initial UML model that can then be further refined. We believe this approach to be easily adaptable to different ADLs, to the changes in our understanding of UML, and to the changes in UML itself.
[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.
[ABC+02] "GI-Fachkomponenten"
Jörg Ackermann, Frank Brinkop, Stefan Conrad, Peter Fettke, Andreas Frick, Elke Glistau, Holger Jaekel, Otto Kotlar, Peter Loos, Heike Mrech, Erich Ortner, Ulrich Raape, Sven Overhage, Stephan Sahm, Andreas Schmietendorf, Thorsten Teschke, and Klaus Turowski. Vereinheitlichte Spezifikation von Fachkomponenten. Arbeitskreis 5.10.3 der Gesellschaft für Informatik (GI), February 2002. Memorandum, Website: \urlhttp://www.fachkomponenten.de.
[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.
[Ams72] "Amsterdam1972:Mirror-self"
B. K. Amsterdam. Mirror self-image reactions before age two. Developemental Psychology, (5):297-305, 1972.
[And03] "Andresen"
Andreas Andresen. Komponentenbasierte Softwareentwicklung mit MDA, UML und XML. Carl Hanser Verlag, 2003.
Abstract
Damit Softwaresysteme flexibel, erweiterbar, wiederverwendbar und sicher sind, werden sie in der Regel aus Komponenten zusammengesetzt. Dieser Praxisleitfaden stellt ein Vorgehensmodell für die komponenten-basierte Softwareentwicklung vor. Er beschreibt die Modellierung, Entwicklung und Einbindung von Komponenten in bestehende oder neu zu entwickelnde Systeme. Zahlreiche Praxistipps helfen bei der Umsetzung. Ein durchgängiges Beispiel und eine Roadmap zeigen, wie das Vorgehensmodell erfolgreich anzuwenden ist. Die Themen Entwicklung und Architektur von Komponenten Spezifikation von Komponenten und Systemen Interaktion und Kommunikation von Komponenten Einbindung bestehender Systeme und Komponenten Architektonische Sichten für alle Phasen eines Entwicklungsprozesses Komponenten-Standards (EJB, CCM, COM+, .NET) Qualitätssicherung und Wiederverwendung Rollen, Skills und effiziente Projektorganisation.
[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.
[Apa03a] "Woody"
Apache Cocoon Project. Cocoonwiki: Woody, 2003.
[Apa03b] "Apache-Control-Flow"
Apache Cocoon Project. Control flow, 2003.
[Apa03c] "JXForms"
Apache Cocoon Project. Jxforms, 2003.
[Apa04] "Apache2:MPM"
Apache Software Foundation (ASF). Multi-processing modules (mpms) - apache http server, 2004.
[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.
[Bal96a] "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.
[Bal96b] "Balzert1996:Lehrbuch-ST-1"
Helmut Balzert. Lehrbuch der Software-Technologie: Software-Entwicklung, volume 1. Spektrum-Verlag, 1996.
[BB95] "i-tcp"
Ajay Bakre and B. R. Badrinath. I-TCP: Indirect TCP for mobile hosts. 15th International Conference on Distributed Computing Systems, 1995.
[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.
[BCK03] "SA-Practice"
Len Bass, Paul Clements, and Rick Kazman. Software architecture in practice. Addison-Wesley, 2 edition, 2003.
[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.
[Bie57] "Devils-Dictionary1957"
Ambrose Bierce. The Devil's Dictionary. Sagamore Press Inc., New York, 1957.
[Bie89] "Enlarged-Devils-Dictionary1989"
Ambrose Bierce. The Enlarged Devil's Dictionary. Penguin Books, 1989.
[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.
[Bla02] "Blasche:Adaption"
Alexander Blasche. Möglichkeiten zur adaption des datenaustausches an die eigenschaften heterogener ausführungsumgebung. Bakkalaureatsarbeit, Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden, 24. July 2002.
[BLFM98] "RFC-URI"
T. Berners-Lee, R. Fielding, and L. Masinter. Uniform resource identifiers (uri): Generic syntax, August 1998.
[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.
[BMR+96] "POSA1-Wiley"
Frank Buschmann, Regine Meunier, Hans Rohnert, Peter Sommerlad, and Michael Stal. Pattern-oriented software architecture - a system of patterns, volume 1. John Wiley & Sons, 1996.
[BMR+98] "POSA1deutsch"
Frank Buschmann, Regine Meunier, Hans Rohnert, Peter Sommerlad, and Michael Stal. Pattern-orientierte Software-Architektur - Ein Pattern-System. Addison-Wesley, 1998. Deutsche Übersetzung von Christiane Löckenhoff.
[Boe86] "Boehm1986:Spiralmodell"
Barry Boehm. A spiral model of software development and enhancement. SIGSOFT Software Engineering Notes, 11(4):14-24, 1986.
[Boe88] "Boehm1988:Spiralmodell"
Barry Boehm. A spiral model of software development and enhancement. IEEE Computer Magazine, 21(5):61-72, May 1988.
[BPSMM00] "XML"
Tim Bray, Jean Paoli, C. M. Sperberg-McQueen, and Eve Maler. Extensible markup language (xml) 1.0 (second edition), 6. October 2000. W3C Recommendation.
[BR03] "Bohsung2003:Diplomarbeit:Spezifikationsmethoden-UI"
Catherine Bohsung and D\vzims Rilko. Komparative analyse von spezifikationsmethoden zur entwicklung adaptiver benutzerschnittstellen in pervasive computing architekturen. Diplomarbeit, FH Kaiserslautern in Zusammenarbeit mit DaimlerChrysler, 27. October 2003.
[Bri02] "Bridges2002:PhD"
Patrick G. Bridges. Composing and Coordinating Adaptations in Cholla. PhD thesis, University of Arizona, 2002. Zusand per Mail.
[Broa] "Brockhaus17"
Brockhaus, editor. Brockhaus-Enzyklopädie: in 20 Bänden. Brockhaus, Mannheim, 17 edition.
[Brob] "Brockhaus19"
Brockhaus, editor. Brockhaus-Enzyklopädie: in 24 Bänden. Brockhaus, Mannheim, 19 edition.
[Bro02] "SAX2-Buch"
David Brownell. SAX2. O'Reilly & Associates, 2002.
[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.
[Car98] "ACME:Homepage"
Carnegie Mellon University. The acme architectural description language, 1998.
[CBB+02] "Clements2002:Documenting-SA-Views-Beyond"
Paul Clements, Felix Bachmann, Len Bass, David Garlan, James Ivers, Reed Little, Robert Nord, and Judith Stafford. Documenting Software Architectures: Views and Beyond. Addison-Wesley, 2002.
[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.
[CDK02] "Coulouris"
George Coulouris, Jean Dollimore, and Tim Kindberg. Verteilte Systeme - Konzepte und Design. Addison-Wesley, 3 edition, 2002.
[CdlFBSB02] "ADL:Springer:03"
Carlos E. Cuesta, Pablo de la Fuente, Manuel Barrio-Solórzano, and Encarnación Beato. Coordination in a reflective architecture description language. In Coordination Models and Languages: 5th International Conference, COORDINATION 2002, YORK, UK, volume 2315 of Lecture Notes in Computer Science, pages 141-148. Springer-Verlag, April 2002.
Abstract
Software Architecture studies the structure of software systems, as described by Architecture Description Languages (ADL s). When these capture structures of change, they are comparable to Coordination Languages. Previous work suggests that the combination with Reflection concepts renders a general framework for the description of such evolving structures. This paper describes a reflective ADL named $\mathcalP$i$\mathcalL$ar, designed to provide such a framework. It consists of a structural part, which describes the static skeleton, and a dynamic part, which defines patterns of change. The major novelty is the reification relationship, which structures a description in several meta-layers, such that the architecture is able to reason and act upon itself. The paper includes a complete $\mathcalP$i$\mathcalL$ar example, to show the language's use and some of its most relevant features. It describes a Tuple Space model, illustrating the analogy with existing Coordination Models. We conclude by emphasizing $\mathcalP$i$\mathcalL$ar's generality and applicability.
[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.
[Din03] "Dingler2003:PDA"
Thomas Dingler. Architektur für verteilte pda-anwendungen. Technical report, DaimlerChrysler, RIC/SA, July 2003.
[Din04] "Dingler2004:AVS"
Thomas Dingler. Adaptive verteilte systeme. Technical report, DaimlerChrysler, RIC/SA, 18. January 2004.
[Dis] "DSRG:publications"
Distributed Systems Research Group. Diverse Publikationen zu Software-/Komponenten-Architekturen.
[Dit04] "Dittert2004:SA-Mythen"
Kerstin Dittert. Softwarearchitektur: Mythen und legenden. OBJEKTspektrum, (3):34-39, 2004.
[DJ04a] "Dostal2004:Semantik-SOA"
Wolfgang Dostal and Mario Jeckle. Semantik, odem einer service-orientierten architektur. JavaSPEKTRUM, (1), 2004.
[DJ04b] "Dostal2004:Semantik-Web-Service"
Wolfgang Dostal and Mario Jeckle. Semantik und web services. JavaSPEKTRUM, (4), 2004.
Abstract
Die Forderung nach Aufnahme semantischer Aussagen in maschinenverwertbare Dienstbeschreibungen stellt den wesentlichen Schritt im Zusammenwachsen von Semantic-Web-Techniken und der Web-Service-Welt dar. Die konkrete technische Umsetzung der Integration semantischer Information in die verschiedenen Elemente einer Service-orientierten Architektur ist jedoch noch weitestgehend ungeklärt.
[DJK04] "Dostal2004:Web-Service-Ontologien"
Wolfgang Dostal, Mario Jeckle, and Werner Kriechbaum. Semantik und web-services: Vokabulare und ontologien. JavaSPEKTRUM, (3), 2004.
Abstract
Bedeutung zu transportieren ist das grundlegende Ziel einer Kommunikation. Dabei hat jeder schon erleben müssen, dass die eigenen gedanklichen Verknüpfungen zwischen den verwendeten Worten und den damit einhergehenden Vorstellungen beim Kommunikationspartner nicht notwendigerweise reproduzierbar sind. Daher entsteht häufig ein nicht unerheblicher Aufwand, um die Vokabulare und die dahinterstehende Bedeutung gegeneinander abzugleichen. In Alltagssituationen, wie dem überqueren einer Ampelkreuzung oder vergleichbar stark reglementierten Vorgängen, besteht kaum noch Klärungsbedarf über die Bedeutung von Zeichen bzw. Vokabeln. Das heißt jedoch nicht, dass es keinen Aufwand für den Abgleich gab. Vielmehr wurde er von den meisten schon in der Kindheit erbracht.
[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.
[dPB02] "ADL:Springer:04"
Virgínia C. C. de Paula and Thais V. Batista. Mapping an adl to a component-based application development environment. In Fundamental Approaches to Software Engineering: 5th International Conference, FASE 2002, held as Part of the Joint European Conferences on Theory and Practice of Software, volume 2306 of Lecture Notes in Computer Science, pages 128-142. Springer-Verlag, April 2002.
Abstract
In this paper we discuss the mapping of an Architecture Description Language, ZCL, to an environment for configuring distributed application using CORBA components, LuaSpace. We focus on the mapping of the structural properties of ZCL and LuaSpace. In order to deal with compatibility issues, we propose an extension to ZCL. The result of this work is an integrated environment that combines the flexibility and execution platform provided by LuaSpace with a tool for design and for consistency checking - ZCL. The experience in combining an ADL with a configuration based environment can give clues on how integrating the activities of design and implementation during the lifetime of a software system. Keywords: Software architecture, configuration, component, CORBA, ADL, scripting language, dynamic reconfiguration.
[Dud90] "DudenOxford"
Dudenredaktion und Oxford University Press, editor. Duden-Oxford Großwörterbuch Englisch. Dudenverlag, 1990.
[DvdHT01] "xADL-WICSA2001"
Eric M. Dashofy, André van der Hoek, and Richard N. Taylor. A highly-extensible, xml-based architecture description language. In Proceedings of The Working IEEE/IFIP Conference on Software Architecture, pages 103-112. IEEE Computer Society Press, 2001.
Abstract
Software architecture research focuses on models of software architectures as specified in architecture description languages (ADLs). As research progresses in specific areas of software architectures, more and more architectural information is created. Ideally, this information can be stored in the model. An extensible modeling language is crucial to experimenting with and building tools for novel modeling constructs that arise from evolving research. Traditional ADLs typically support a small set of modeling constructs very well, but adapt to others poorly. XML provides an ideal platform upon which to develop an extensible modeling language for software architectures. Previous XML-based ADLs successfully leveraged XML's large base of off-the-shelf tool support, but did not take advantage of its extensibility. To give software architecture researchers more freedom to explore new possibilities and modeling techniques, while maximizing reuse of tools and modeling constructs, we have developed xADL 2.0, a highly extensible XML-based ADL. xADL 2.0 supports run-time and design time modeling, architecture configuration management and model-based system instantiation. Additionally, xADL 2.0 has a set of extensible infrastructure tools that support the creation, manipulation, and sharing of xADL 2.0 documents
[DvdHT02] "581374"
Eric M. Dashofy, André van der Hoek, and Richard N. Taylor. An infrastructure for the rapid development of xml-based architecture description languages. In Proceedings of the 24th international conference on Software engineering, pages 266-276. ACM Press, 2002.
Abstract
Research and experimentation in software architectures over the past decade have yielded a plethora of software architecture description languages (ADLs). Continuing innovation indicates that it is reasonable to expect more new ADLs, or at least ADL features. This research process is impeded by the difficulty and cost associated with developing new notations. An architect in need of a unique set of modeling features must either develop a new architecture description language from scratch or undertake the daunting task of modifying an existing language. In either case, it is unavoidable that a significant effort will be expended in building or adapting tools to support the language. To remedy this situation, we have developed an infrastructure for the rapid development of new architecture description languages. Key aspects of the infrastructure are its XML-based modular extension mechanism, its base set of reusable and customizable architectural modeling constructs, and its equally important set of flexible support tools. This paper introduces the infrastructure and demonstrates its value in the context of several real-world applications.
[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.
[EL02] "eikemeier"
Claus Eikemeier and Ulrike Lechner. Peer-to-peer - eine verteilte technologie auf der suche nach einem \myquotezentralen verständnis, 2002.
[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.
[FBLL02] "Filman2002:Inserting-Ilities"
Robert E. Filman, Stuart Barrett, Diana D. Lee, and Ted Linden. Inserting ilities by controlling communications. Communications of the ACM, 45(1):116-122, 2002.
[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.
[Fer88] "62673"
E. S.T. Fernandes. Microarchitecture modelling through adl. In Proceedings of the 21st annual workshop on Microprogramming and microarchitecture, pages 100-104. IEEE Computer Society Press, 1988.
Abstract
ADL is an Architecture Description Language that has been developed to model computer architectures at different levels of detail, as for instance, at the microarchitecture level. Target architectures described in ADL are processed by the support system of the language which generates an interpreter program related to the description of the target machine. The interpreter reproduces the behavior of the architecture being modeled, including the interpretation of the target code. In addition to a brief review of the language and the implementation details of its support system, this paper also shows some methods to deal with target machine parallelism, and the modeling of two microprogrammable machines.
[Fia04] "CommUnity-Homepage"
José Luiz Fiadeiro. Community, 2004.
[FKNT02] "Foster2002:OGSA"
Ian Foster, Carl Kesselman, Jeffrey M. Nick, and Steven Tuecke. The physiology of the grid - an open grid services architecture for distributed systems integration, June 2002.
[FL99] "Feng1999:Adaptive-Control"
Gang Feng and Rogelio Lozano, editors. Adaptive Control. Newnes, 1999.
[FM95] "Fiadeiro1995:Interconnecting-formalisms"
José Luiz Fiadeiro and Tom Maibaum. Interconnecting formalisms: Supporting modularity, reuse and incrementality. In Proceedings of the 3rd ACM SIGSOFT symposium on Foundations of software engineering, pages 72-80. ACM Press, 1995.
[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.
[Fra01] "Franke:Adaption"
Gregor Franke. Möglichkeiten der adaption des mobilen webzugriffs an die eigenschaften der ausführungsumgebung. Großer beleg, Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden, 31. October 2001.
[GA03] "Large-Scale-SA"
Jeff Garland and Richard Anthony. Large-Scale Software Architecture: A Practical Guide using UML. John Wiley & Sons, Ltd, 2003.
[GAO94] "195404"
David Garlan, Robert Allen, and John Ockerbloom. Exploiting style in architectural design environments. In Proceedings of the 2nd ACM SIGSOFT symposium on Foundations of software engineering, pages 175-188. ACM Press, 1994.
Abstract
As the design of software architectures emerges as a discipline within software engineering, it will become increasingly important to support architectural description and analysis with tools and environments. In this paper we describe a system for developing architectural design environments that exploit architectural styles to guide software architects in producing specific systems. The primary contributions of this research are: (a) a generic object model for representing architectural designs; (b) the characterization of architectural styles as specializations of this object model; and (c) a toolkit for creating an open architectural design environment from a description of a specific architectural style. We use our experience in implementing these concepts to illustrate how style-oriented architectural design raises new challenges for software support environments.
[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.
[Ge03] "Gap-ACME-UML"
Miguel Goulão and Fernando Brito e Abreu. Bridging the gap between acme and uml 2.0 for cbd. In Specification and Verification of Component-Based Systems (SAVCBS'2003), Helsinki, Finland, September 2003.
Abstract
Architecture Description Languages (ADLs) such as Acme (a mainstream second generation ADL which contains the most common ADL constructs) provide formality in the description of software architectures, but are not easily reconciled with day-today development concerns, thus hampering their adoption by a larger community. UML, on the other hand, has become the de facto standard notation for design modeling, both in industry and in academia. In this paper we map Acme modeling abstractions into UML 2.0, using its new component modeling constructs, its lightweight extension mechanisms and OCL well-formedness rules. The feasibility of this mapping is demonstrated through several examples. This mapping bridges the gap between architectural specification with Acme and UML, namely allowing the transition from architecture to implementation, using UML design models as a middle tier abstraction.
[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.
[GHJtV96] "GoF-deutsch"
Erich Gamma, Richard Helm, Ralph Johnson, and John (\textscGang of Four) Vlissides. Entwurfsmuster - Elemente wiederverwendbarer objektorientierter Software. Addison-Wesley, 1996. Deutsche Übersetzung von Dirk Riehle.
[GJM91] "Ghezzi1991:Fundamentals-SE"
Carlo Ghezii, Mehdi Jazayeri, and Dino Mandrioli. Fundamentals of Software Engineering. Prentice Hall, 1991.
[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.
[GK00] "ADL:Springer:08"
David Garlan and Andrew J. Kompanek. Reconciling the needs of architectural description with object-modeling notations. In \myquoteUML 2000 - The Unified Modeling Language. Advancing the Standard: Third International Conference, York, UK, October 2000, volume 1939 of Lecture Notes in Computer Science, pages 498-512. Springer-Verlag, 2000.
Abstract
Complex software systems require expressive notations for representing their software architectures. Two competing paths have emerged. One is to use a specialized notation for architecture - or architecture description language (ADL). The other is to adapt a general-purpose modeling notation, such as UML. The latter has a number of benefits, including familiarity to developers, close mapping to implementations, and commercial tool support. However, it remains an open question as to how best to use object-oriented notations for architectural description, and, indeed, whether they are sufficiently expressive, as currently defined. In this paper we take a systematic look at these questions, examining the space of possible mappings from ADLs into object notations. Specifically, we describe (a) the principle strategies for representing architectural structure in UML; (b) the benefits and limitations of each strategy; and (c) aspects of architectural description that are intrinsically difficult to model in UML using the strategies.
[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.
[GMW97] "GMW97:ACME"
David Garlan, Robert Monroe, and David Wile. Acme: an architecture description interchange language. In Proceedings of the 1997 conference of the Centre for Advanced Studies on Collaborative research, page 7. IBM Press, 1997.
Abstract
Numerous architectural description languages (ADLs) have been developed, each providing complementary capabilities for architectural development and analysis. Unfortunately, each ADL and supporting toolset operates in isolation, making it difficult to integrate those tools and share architectural descriptions. Acme is being developed as a joint effort of the software architecture research community as a common interchange format for architecture design tools. Acme provides a structural framework for characterizing architectures, together with annotation facilities for additional ADL-specific information. This scheme permits subsets of ADL tools to share architectural information that is jointly understood, while tolerating the presence of information that falls outside their common vocabulary. In this paper we describe Acme's key features, rationale, and technical innovations.
[Gos01] "Goslar2001:Kontext"
Kevin Goslar. Gewinnung, darstellung und verwaltung von kontextinformationen - personalisierung. Diplomarbeit, Lehrstühle für Rechnernetze sowie Wirtschaftsinformatik, TU Dresden, 2001.
[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.
[Gri98] "Griffel98:Componentware"
Frank Griffel. Componentware - Konzepte und Techniken eines Softwareparadigmas. dpunkt.verlag, 1998.
[GS02a] "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.
[GS02b] "GS02"
Steffen Göbel and Thomas Springer. Adaption von web-basierten anwendungen. Technical report, Lehrstuhl Rechnernetze,Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden, 23. April 2002.
[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.
[GW99] "ADL:Springer:10"
David Garlan and Zhenyu Wang. Acme-based software architecture interchange. In Coordination Languages and Models: Third International Conference, COORDINATION '99, Amsterdam, The Netherlands, April 1999, volume 1594 of Lecture Notes in Computer Science, pages 340-354. Springer-Verlag, 1999.
Abstract
An important issue for the specification and design of software architectures is how to combine the analysis capabilities of multiple architectural definition languages (ADLs) and their supporting toolsets. In this paper, we describe our experience of integrating three ADLs: Wright, Rapide, and Aesop. We discovered that it is possible to achieve interoperability in ADL tools for a non-trivial subset of the systems describable by these languages, even though the languages have different views about architectural structure and semantics. To carry out the integration we used the Acme architectural interchange language and its supporting tools.
[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.
[Hal01] "core-servlets"
Marty Hall. Core Servlets und JavaServer Pages. Markt+Technik Verlag, 2001. Deutsche Übersetzung des bei SUN Microsystem Press erschienenen Buchs.
[Har03] "Processing-XML"
Elliotte Rusty Harold. Processing XML with Java - A Guide to SAX, DOM, JDOM, JAXP, and TrAX. Addison-Wesley, 2003.
[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.
[HK03] "Hitz2003:UML-at-Work"
Martin Hitz and Gerti Kappel. UML\,@\,Work. dpunkt.verlag, 2 edition, November 2003.
[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.
[HMP03] "Pozewaunig2003:Architektur-Annotationen"
Elke Hochmüller, Roland Mittermeir, and Heinz Pozewaunig. Architektur: Stellenwerte, ziele, inhalt, grundformen, 2003.
[HNS00] "Hofmeister2000:Applied-SA"
Christine Hofmeister, Robert Nord, and Dilip Soni. Applied Software Architecture. Addison-Wesley, 2000.
[Hor01] "IBM2001:AC-Manifest"
Paul Horn. Autonomic computing: Ibm's perspective on the state of information technology, October 2001. Manifest der Autonomic Computing Initiative.
[HS02] "Heise2002:Englisch-Online-Uebersetzer"
Herbert Hasenbein and Cecilia Schreiber. Online-Übersetzer: Englisch-wörterbücher im netz. c't - magazin für computer technik, (13):170-175, 2002.
[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.
[HSS+03] "PDWINF"
Gerald Hübsch, Thomas Springer, Alexander Schill, Axel Spriestersbach, and Thomas Ziegert. Systemlösungen für die entwicklung adaptiver anwendungen für mobile und ubiquitäre infrastrukturen. HMD: Praxis der Wirtschaftsinformatik, 229:42-55, February 2003.
[Hüb01] "Hue:Adaption"
Gerald Hübsch. Adaption von dialogen an mobile endgeräte. Großer beleg, Technische Universität Dresden, 2001.
[Hüb02] "Hue:Mobility-Portal"
Gerald Hübsch. Corporate mobility portal - sicherer und adaptiver zugang zu intranet und backend-diensten. Diplomarbeit, Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden, 2002.
[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.
[IBM40] "IBM:TPublisher:Architecture"
IBM Software. Websphere transcoding publisher - architecture, 4.0.
[IBM45] "IBM:WBI:Architecture"
IBM Research. Wbi development kit - wbi architecture, 4.5.
[IEE] "IEEE-1471-AWG-Website"
IEEE Architecture Working Group (AWG). Ieee recommended practice for architectural description of software-intensive systems (ieee std 1471). Website der AWG.
[Ins02] "xADL:Homepage"
Institute for Software Research, University of California. xadl 2.0 - a highly extensible, xarch-based architecture description language, November 2002.
[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.
[JBo] "JBoss-Homepage"
JBoss Inc. Jboss :: Professional open source.
[Jen00] "Jennings2000:Agent-based-SE"
Nicholas R. Jennings. On agent-based software engineering. Artif. Intell., 117(2):277-296, 2000.
[JRH+03] "Jeckle2003:UML2-glasklar"
Mario Jeckle, Chris Rupp, Jürgen Hahn, Barbara Zengler, and Stefan Queins. UML 2 glasklar. Carl Hanser Verlag, November 2003.
[Kad03] "Kadner2004:Konzeption-Kontext-verteilt"
Kay Kadner. Konzeption eines verteilten dienstes zur unterstützung von context-awareness. Großer beleg, Technische Universität Dresden, 19. December 2003.
[Kad04a] "Kadner2004:Kontext-ad-hoc"
Kay Kadner. Erweitung eines verteilten kontextdienstes um konzepte zur unterstützung von ad hoc szenarien. Diplomarbeit, Technische Universität Dresden, 31. August 2004.
[Kad04b] "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>.
[Kad04c] "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>.
[Kar00] "Karl:Vorlesung-VS-Kap1"
Holger Karl. Kapitel 1: Einsatzgebiete und charakteristika verteilter systeme, 2000.
[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.
[KCSS02] "ADL:Springer:02"
Mohamed Mancona Kandé, Valentin Crettaz, Alfred Strohmeier, and Shane Sendall. Bridging the gap between ieee 1471, an architecture description language, and uml. Software and Systems Modeling, 1(2):113-129, December 2002.
Abstract
A lot of attention has been paid to software architecture issues in academia, industrial research and standardization organizations working in the software area. The software architecture research community has focused on the creation and improvement of special-purpose languages: architecture description languages (ADLs). However, ADLs lack adequate support for separating various kinds of stakeholders’ concerns along different viewpoints. But also, they do not address the difference between the architecture of a software system and its representations. In contrast, ANSI/IEEE-Std-1471 makes a clear distinction between the architecture and the architectural description of a software system. In this paper, we propose ConcernBASE, a UML-based approach to software architecture, which instantiates the conceptual framework defined in ANSI/IEEE-Std-1471 and complements the ions and mechanisms found in current ADLs. ConcernBASE provides a viewpoint for structural descriptions of software architectures that supports key concepts of ADLs and defines a UML profile as a viewpoint language. We validate this profile through a mapping between a representative ADL, called Structural ADL (SADL), and the new profile and by providing a UML-based tool prototype, called ConcernBASE Modeler, which integrates with SADL tools.
[Kla04] "Klamar2004:Beleg"
Sebastian Klamar. Komponentenbasierte architektur zur adaption web-basierter anwendungen. Großer beleg, Technische Universität Dresden, 28. January 2004.
[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.
[Kre01] "Kreger2001:WSCA"
Heather Kreger. Web services conceptual architecture, May 2001.
[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.
[Kru95] "kruchten95"
Phillip Kruchten. Architectural blueprints - the \myquote4+1 view model of software architecture. IEEE Software, 12(6):42-50, November 1995.
[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.
[KS00] "ADL:Springer:07"
Mohamed Mancona Kandé and Alfred Strohmeier. Towards a uml profile for software architecture descriptions. In \myquoteUML 2000 - The Unified Modeling Language. Advancing the Standard: Third International Conference, York, UK, October 2000, volume 1939 of Lecture Notes in Computer Science, pages 513-527. Springer-Verlag, 2000.
Abstract
To formally describe architectures of software systems, specific languages called Architecture Description Languages (ADLs) have been developed by academic institutions and research labs. However, more and more research and industrial projects are using the standard Unified Modeling Language (UML) for representing software architectures of systems. In this paper, we focus on how to extend the UML by incorporating some key ions found in current ADLs, such as connectors, components and configurations, and how the UML can be used for modeling architectural viewpoints. Our approach is demonstrated by the software architecture of a video surveillance system. It is therefore the purpose of the paper to show that a UML profile for software architecture abstractions is needed.
[KT02] "ADL:Springer:05"
Tomá\us Kalibera and Petr T\ruma. Distributed component system based on architecture description: The sofa experience. In On the Move to Meaningful Internet Systems 2002: CoopIS, DOA, and ODBASE: Confederated International Conferences CoopIS, DOA, and ODBASE, volume 2519 of Lecture Notes in Computer Science, pages 981-994. Springer-Verlag, 2002.
Abstract
In this paper, the authors share their experience gathered during the design and implementation of a runtime environment for the SOFA component system. The authors focus on the issues of mapping the SOFA component definition language into the C++ language and the integration of a CORBA middleware into the SOFA component system, aiming to support transparently distributed applications in a real-life environment. The experience highlights general problems related to the type system of architecture description languages and middleware implementations, the mapping of the type system into the implementation language, and the support for dynamic changes of the application architecture.
[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.
[Lan89] "Langenscheid-Fremdwoerterbuch1989"
Langenscheidt, editor. Langenscheidts Fremdwörterbuch.. Langenscheidt, 1989.
[Lar98] "Larman1998:Applying-UML-Patterns"
Craig Larman. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design. Prentice Hall, 1998.
[Lar02] "Larman2002:Applying-UML-Patterns"
Craig Larman. Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process. Prentice Hall, 2002.
[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.
[Leh03] "Leh:Fragmentierung"
Falk Lehmann. Fragmentierung von dokumenten zur adaption von web-basierten diensten an die beschränkten ressourcen mobiler endgeräte. Diplomarbeit, Lehrstuhl Rechnernetze,Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden, 31. March 2003.
[Lew03] "Lewandowski:SA"
Rudolf Lewandowski. Software-architektur i, 2003. Vorlesungsskript zur gleichnamigen Vorlesung an der TU Wien.
[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.
[Lös02] "Loeschau2002:Kontext"
Frank Löschau. Realisierung kontextsensitiver anwendungen auf basis eines frameworks zur kontextverarbeitung und -verwaltung. Diplomarbeit, Lehrstühle für Rechnernetze sowie Wirtschaftsinformatik, TU Dresden, 9. October 2002.
[MA02] "Cocoon-DevBook"
Lajos Moczar and Jeremy Aston. Cocoon Developer's Handbook. Sams Publishing, December 2002.
[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.
[MCWF02] "ADL:Springer:01"
Hong Mei, Feng Chen, Qianxiang Wang, and Yaodong Feng. Abc/adl: An adl supporting component composition. In Formal Methods and Software Engineering: 4th International Conference on Formal Engineering Methods, ICFEM 2002 Shanghai, China, volume 2495 of Lecture Notes in Computer Science, pages 38-47. Springer-Verlag, October 2002.
Abstract
Architecture Description Language (ADL) is one of the keys to software architecture research, but most attention was paid to the description of software structure and high-level analysis of some system properties, while the ability to support refinement and implementation of Software Architecture (SA) models was ignored. In this paper, we present the ABC/ADL, an ADL supporting component composition. Besides the capability of architecting software systems, it provides support to the automated application generation based on SA model via mapping rules and customizable connectors.
[MDN01] "500061"
Prabhat Mishra, Nikil Dutt, and Alex Nicolau. Functional abstraction driven design space exploration of heterogeneous programmable architectures. In Proceedings of the 14th international symposium on Systems synthesis, pages 256-261. ACM Press, 2001.
Abstract
Rapid Design Space Exploration (DSE) of a programmable architecture is feasible using an automatic toolkit (compiler, simulator, assembler) generation methodology driven by an Architecture Description Language (ADL). While many contemporary ADLs can effectively capture one class of architecture, they are typically unable to capture a wide spectrum of processor and memory features present in DSP, VLIW, EPIC and Superscalar processors. The main bottleneck has been the lack of an abstraction underlying the ADL (covering a diverse set of architectural features) that permits reuse of the abstraction primitives to compose the heterogeneous architectures. We present in this paper the functional abstraction needed to capture such wide variety of programmable architectures. We illustrate the usefulness of this approach by specifying two very different architectures using functional abstraction. Our DSE results demonstrate the power of reuse in composing heterogeneous architectures using functional abstraction primitives allowing for a reduction in the time for specification and exploration by at least an order of magnitude.
[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.
[Men98] "mencl98-CDL"
Vladimír Mencl. Component definition language. Master's thesis, Charles University, 1998.
Abstract
FROM THE INTRODUCTION: In the area of software engineering, the need to reuse existing software forces the developers to seek new approaches to the application development process. One of these approaches is component oriented programming, which provides better future for reuse. Existing techniques usually require the developer to make changes to the part being reused, which makes two disadvantages in one (covered for example in [Bosch97b]). First, it takes extra time and effort of the developer to adopt that part, and, second, when the original part gets modified, updating the adopted version can be diffcult and may require human effort and interaction. Component oriented programming provides an easier way for reuse. A component is an autonomous unit of code, having an exactly defined interface, and being a black-box to the user. The user can ignore the component's implemen- tation, and focus on the component's interface only, which usually consists of some provisions and requirements. Provisions are service provided by the component. The form, in which they are specified, can vary, they can be either function calls, object interfaces, or message slots, there are many ADLs (architecture description languages), but all of them have a way to provide and require services. Requirements are services required by the component to be able to operate and serve the services it provides. They again might take quite any form, usually, in an ADL, the form of requirements matches the form of provisions. A discussion of existing ADLs will be given in chapter 2. When a component is defined by its interface, the user can use it with true black-box approach. The user has only to provide the requirements the component needs, and can use the services provided by the component without spending time to understand the internal structure of the component. Software can be developed without even knowing, which version of the com- ponent shall be used, and from which provider shall the component be. And, if the binding process is automated enough, software can be easily updated by replacing only those components, which are to be updated. The SOFA (SOFtware Appliances) project run by the CORBA and Dis- tributed Systems Research Group at the Department of Software Engineering, Faculty of Mathematics and Physics, Charles University in Prague, is pursuing this target. The goal of SOFA is to create an framework for an electronic mar- ket, which would allow buying software components, downloading them and using them to update existing applications. One of the special approaches of SOFA is, that it should be possible to update applications at run-time. For very large systems, it is impossible to shutdown the whole system only because of a minor update. DCUP (Dynamic Component UPdating), a project ran as a part of the SOFA project, presents a framework for updating parts of an application (components) while the ap- plication is running. To be able to reach this target, the application has to be developed accord- ing to several rules, the most important one is, that object-references crossing component boundaries have to be passed using special proxy-objects called wrappers. These wrappers-objects must be created as a part of the application, and there has to be one wrapper-object class for each interface type used for passing references. Also, for each component type, a component builder and a component manager has to be created. The code for all wrappers classes and all component builders and component managers is very similar, and therefore a code generator would be suitable. Also, it is nearly-necessary to have an architecture verification tool. That is, why CDL is to be created. The goal of this thesis is to propose an Component Definition Language (CDL), which would serve for the purposes of describing components and applications built of these components. The language should be implemented in a compiler program, which would both verify the architecture and components described in a CDL source, and generate code for as much of the control part objects as possible. The compiler should be able to generate code into any programming lan- guage, under which DCUP is implemented, currently, only java will be included. The language should be strong enough to be allow support for future ad- vances of DCUP, including proper versioning, and selection of components by the triplet (component type, provider, version). This way, descriptions of com- ponent written in CDL will allow storing of different versions of components from different providers, and will make possible component management bases like template repositories [PBJ98a].
[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
[MG01] "ADL:Springer:11"
Florin Muscutariu and Marie-Pierre Gervais. On the modeling of mobile agent-based systems. In Mobile Agents for Telecommunication Applications: Third International Workshop, MATA 2001, Montreal, Canada, August 14-16, 2001, volume 2164 of Lecture Notes in Computer Science, pages 219-233. Springer-Verlag, 2001.
Abstract
The mobile agent technology provides facilities that enable to reduce the complexity of telecommunication services development. However the major part of this development is still devoted to the code production. In order to optimize the development of services, this production should be reduced while the main part must become an upstream activity, i.e., the elaboration of specifications. This paper introduces an Architecture Description Language (ADL) devoted to the design of mobile agent systems to be implemented in a MASIF compliant platform. The ADL is defined as a UML profile called the MASIF-DESIGN profile. It enables the designer to describe the platform he/she uses, to locate the agents in the platform and to define the elements required from the platform for the achievement of the distribution transparencies.
[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.
[MM03] "MDA-Guide"
Joaquin Miller and Jishnu Mukerji. Mda guide version 1.0.1, 12. June 2003.
[MMP00] "Taxonomy-Connectors"
Nikunj R. Mehta, Nenad Medvidovic, and Sandeep Phadke. Towards a taxonomy of software connectors. In Proceedings of the 22nd international conference on Software engineering, pages 178-187. ACM Press, 2000.
Abstract
Software systems of today are frequently composed from prefabricated, heterogeneous components that provide complex functionality and engage in complex interactions. Existing research on component-based development has mostly focused on component structure, interfaces, and functionality. Recently, software architecture has emerged as an area that also places significant importance on component interactions, embodied in the notion of software connectors. However, the current level of understanding and support for connectors has been insufficient. This has resulted in their inconsistent treatment and a notable lack of understanding of what the fundamental building blocks of software interaction are and how they can be composed into more complex interactions. This paper attempts to address this problem. It presents a comprehensive classification framework and taxonomy of software connectors. The taxonomy is obtained through an extensive analysis of existing component interactions. The taxonomy is used both to understand existing software connectors and to suggest new, unprecedented connectors. We demonstrate the use of the taxonomy on the architecture of a large, existing system.
[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.
[Moc87] "RFC-DNS"
P. Mockapetris. Domain names - implementation and specification, November 1987.
[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.
[MORT96] "Medvidovic1996:C2"
Nenad Medvidovic, Peyman Oreizy, Jason E. Robbins, and Richard N. Taylor. Using object-oriented typing to support architectural design in the c2 style. In Proceedings of the 4th ACM SIGSOFT symposium on Foundations of software engineering, pages 24-32. ACM Press, 1996.
Abstract
Sotware architectures enable large-scale software development. Component reuse and substitutability, two key aspects of large-scale development, must be planned for during software design. Object-oriented (OO) type theory supports reuse by structuring inter-component relationships and verifying those relationships through type checking in an architecture definition language (ADL). In this paper, we identify the issues and discuss the ramifications of applying OO type theory to the C2 architectural style. This work stems from a series of experiments that were conducted to investigate component reuse and substitutability in C2. We also discuss the limits of applicability of OO typing to C2 and how we addressed them in the C2 ADL.
[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.
[MRRR02] "MRRR02"
Nenad Medvidovic, David S. Rosenblum, David F. Redmiles, and Jason E. Robbins. Modeling software architectures in the unified modeling language. ACM Transactions on Software Engineering and Methodology (TOSEM), 11(1):2-57, 2002.
Abstract
The Unified Modeling Language (UML) is a family of design notations that is rapidly becoming a de facto standard software design language. UML provides a variety of useful capabilities to the software designer, including multiple, interrelated design views, a semiformal semantics expressed as a UML meta model, and an associated language for expressing formal logic constraints on design elements. The primary goal of this work is an assessment of UML's expressive power for modeling software architectures in the manner in which a number of existing software architecture description languages (ADLs) model architectures. This paper presents two strategies for supporting architectural concerns within UML. One strategy involves using UML "as is," while the other incorporates useful features of existing ADLs as UML extensions. We discuss the applicability, strengths, and weaknesses of the two strategies. The strategies are applied on three ADLs that, as a whole, represent a broad cross-section of present-day ADL capabilities. One conclusion of our work is that UML currently lacks support for capturing and exploiting certain architectural concerns whose importance has been demonstrated through the research and practice of software architectures. In particular, UML lacks direct support for modeling and exploiting architectural styles, explicit software connectors, and local and global architectural constraints.
[MSS01] "502195"
Débora Christina Muchaluat-Saade and Luiz Fernando Gomes Soares. Towards the convergence between hypermedia authoring languages and architecture description languages. In Proceedings of the 2001 ACM Symposium on Document engineering, pages 48-57. ACM Press, 2001.
Abstract
This paper presents a detailed comparison between the structural elements and definitions provided by Hypermedia Authoring Languages and Architecture Description Languages (ADL). ADLs are formal languages that can be used for representing a software architecture. Although it may look trivial to make a direct correspondence between ADL and hypermedia structural entities, such as components to nodes and connectors to links, interesting differences can be identified when observing them more closely. Based on the comparison results, a structural meta-model that can be specialized for use in both domains is proposed. Furthermore, the paper also presents an example of how the meta-model can be used for describing hypermedia document structures, showing how some features found in ADLs can be applied to hypermedia authoring languages. Our final goal is to integrate the contributions of document engineering and software architecture engineering and take advantage of the advances of one area in the other one. The current paper is the first step towards this direction.
[MT97] "MT97"
Nenad Medvidovic and Richard N. Taylor. A framework for classifying and comparing architecture description languages. In Proceedings of the 6th European conference held jointly with the 5th ACM SIGSOFT international symposium on Foundations of software engineering, pages 60-76. Springer-Verlag New York, Inc., 1997.
Abstract
Software architectures shift developer’s focus from lines-of-code to coarser-grained architectural elements and their interconnection structure. Architecture description languages (ADLs) have been proposed as modeling notations to support architecture-based development. There is, however, little consensus in the research community on what is an ADL, what aspects of an architecture should be modeled in an ADL, and which ADL is best suited for a particular problem. Furthermore, the distinction is rarely made between ADLs on one hand and formal specification, module interconnection, simulation, and programming languages on the other. This paper attempts to provide an answer to these questions. It motivates and presents a definition and a classification framework for ADLs. The utility of the definition is demonstrated by using it to differentiate ADLs from other modcling notations. The framework is used to classify and compare several existing ADLs.
[MT00] "MT00"
Nenad Medvidovic and Richard N. Taylor. A classification and comparison framework for software architecture description languages. IEEE Transactions on Software Engineering, 26(1):70-93, January 2000.
Abstract
Software architectures shift the focus of developers from lines-of-code to coarser-grained architectural elements and their overall interconnection structure. Architecture description languages (ADLs) have been proposed as modeling notations to support architecture-based development. There is, however, little consensus in the research community on what is an ADL, what aspects of an architecture should be modeled in an ADL, and which of several possible ADLs is best suited for a particular problem. Furthermore, the distinction is rarely made between ADLs on one hand and formal specification, module interconnection, simulation and programming languages on the other. This paper attempts to provide an answer to these questions. It motivates and presents a definition and a classification framework for ADLs. The utility of the definition is demonstrated by using it to differentiate ADLs from other modeling notations. The framework is used to classify and compare several existing ADLs, enabling us, in the process, to identify key properties of ADLs. The comparison highlights areas where existing ADLs provide extensive support and those in which they are deficient, suggesting a research agenda for the future.
[Mül01a] "Muelle2001:Dyn-Gebauede"
Jutta Mülle. Dynamische gebäude - verteilte systeme und middleware, 19. February 2001.
[Mül01b] "Mue:Sessionmanagement"
Jan Müller. Untersuchungen zum sessionmanagement und zur datenvalidierung in einem transcoding framework. Diplomarbeit, Institut für Betriebssysteme, Datenbanken und Rechnernetze,Fakultät Informatik,Technische Universität Dresden, 29. November 2001.
[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.a] "Jini-Homepage"
o. V. Jini.org - domain home page.
[o.b] "JXTA-Homepage"
o. V. jxta.org.
[o.c] "UIML:Homepage"
o. V. Uiml.org.
[o.04] "Sueddeutsche:Fehler-Feuerwehr"
o. V. Einsatz für die fehler-feuerwehr. Süddeutsche Zeitung, (73), 27. March 2004.
[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.
[Org] "UDDI:Website"
Organization for the Advancement of Structured Information Standards (OASIS). Universal description, discovery and integration.
[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.
[Pol49] "Polya1949:How-to-solve-problems"
George Polya. How to solve problems. Princeton University Press, 1949.
[Pol95] "Polya1995:How-to-solve-problems:deutsch"
George Polya. Schule des Denkens: Vom Lösen mathematischer Probleme. Francke Verlag, 4 edition, 1995. Deutsche Übersetzung von \citepPolya1949:How-to-solve-problems durch Elisabeth Behnke.
[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.
[Pro03] "JXTA-Guide"
Project JXTA. Programmer's guide, May 2003.
[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.
[PW92] "Perry1992:Foundations-SA"
Dewayne E. Perry and Alexander L. Wolf. Foundations for the study of software architecture. SIGSOFT Software Engineering Notes, 17(4):40-52, 1992.
Abstract
The purpose of this paper is to build the foundation for software architecture. We first develop an intuition for software architecture by appealing to several well-established architectural disciplines. On the basis of this intuition, we present a model of software architecture that consists of three components: elements, form, and rationale. Elements are either processing, data, or connecting elements. Form is defined in terms of the properties of, and the relationships among, the elements - that is, the constraints on the elements. The rationale provides the underlying basis for the architecture in terms of the system constraints, which most often derive from the system requirements. We discuss the components of the model in the context of both architectures and architectural styles and present an extended example to illustrate some important architecture and style considerations. We conclude by presenting some of the benefits of our approach to software architecture, summarizing our contributions, and relating our approach to other current work
[QBL02] "quema02application"
V. Quéma, L. Bellissard, and P. Laumay. Application-driven customization of message-oriented middleware for consumer devices. In Proceedings of the Workshop on Software Infrastructures for Component-Based Applications on Consumer Devices, in association with EDOC'02, Lausanne, Switzerland, September 2002.
Abstract
There is a growing trend in developing applications on distributed heterogeneous devices. Message-Oriented Middleware (MOM) technology provides many solutions allowing to hide the management of the distribution of services and computations to the developers. On the other hand the middleware configuration becomes more and more complex. We propose to ease the configuration process using the configuration capability of a component-based MOM (the ScalAgent MOM). Our solution uses the application description (into an extended Architecture Description Language) to determine the set of middleware components required and their attributes to ensure non-functional properties required by the application. The customization process is controled by a customization algorithm that tries to minimize some nonfunctional property management costs. Our performance measurements clearly show the customization advantages.
[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.
[Red02] "PONS:Englisch-Deutsch"
Redaktion PONS Wörterbücher. PONS Großwörterbuch für Experten und Universität Englisch. Ernst Klett Sprachen GmbH, Stuttgart, 1 edition, 2002.
[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.

[RMRR98] "302184"
Jason E. Robbins, Nenad Medvidovic, David F. Redmiles, and David S. Rosenblum. Integrating architecture description languages with a standard design method. In Proceedings of the 20th international conference on Software engineering, pages 209-218. IEEE Computer Society Press, 1998.
Abstract
Software architecture descriptions are high-level models of software systems. Some researchers have proposed special-purpose architectural notations that have a great deal of expressive power but are not well integrated with common development methods. Others have used mainstream development methods that are accessible to developers, but lack semantics needed for extensive analysis. We describe an approach to combining the advantages of these two ways of modeling architectures. We present two examples of extending UML, an emerging standard design notation, for use with two architecture description languages, C2 and Wright. Our approach suggests a practical strategy for bringing architectural modeling into wider use, namely by incorporating substantial elements of architectural models into a standard design method.
[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.
[Sch04a] "Schill:Vorlesung-VS:Objektmigration"
Alexander Schill. Objektmigration, 2004. Skript zur Vorlesung \myquoteVerteilte Systeme an der TU Dresden.
[Sch04b] "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.
[SG96] "Shaw1996:SA"
Mary Shaw and David Garlan. Software Architecture: Perspectives on an Emerging Discipline. Prentice Hall, New Jersey, 1996.
[SG02a] "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.
[SG02b] "SG02:Proxy-Adaption"
Thomas Springer and Steffen Göbel. A modular adaption framework for single source publishing. Technical report, Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden, 29. July 2002.
[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.
[SM03] "Heise2003:Internet-Gedaechtnisschwund"
Wolfgang Stieler and Hans-Arthur Marsiske. Internet mit gedächtnisschwund. c't - magazin für computer technik, (25):57, 2003.
[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.
[Sof04a] "SEI:Architecture-Reconstruction"
Software Engineering Institute (SEI). Architecture reconstruction, 15. June 2004.
[Sof04b] "SEI:SA-Definitions"
Software Engineering Institute (SEI). How do you define software architecture, 20. August 2004.
[Sou03] "STX-Homepage"
Sourceforge Projekt. Streaming transformations for xml (stx), 2003.
[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.
[SSC00] "ADL:Springer:06"
Douglas Stuart, Wonhee Sull, and T. W. Cook. Dependency navigation in product lines using xml. In Software Architectures for Product Families: 7th International Workshop on Database Programming Languages, volume 1951 of Lecture Notes in Computer Science, pages 82-93. Springer-Verlag, 2000.
Abstract
MCC's Software and Systems Engineering Productivity (SSEP) Project brings together emerging software engineering technology in architecture definition, analysis and generation, product family engineering, and rationale capture to enable organizations to achieve unprecedented levels of productivity and reuse. One of the central requirements for architecture-based product line development is the capability to efficiently and effectively navigate between related artifacts. This involves navigation both between product line artifacts and application artifacts, and between artifacts associated with successive development phases at each level. This navigation supports automated identification, selection and generation of artifacts, as well as manual development activities. This paper describes the Architecture Description Language (ADL) and toolset used by the SSEP project, and its support for linking and navigation in a product line development environment.
[SSRB02] "POSA2-deutsch"
Douglas Schmidt, Michael Stal, Hans Rohnert, and Frank Buschmann. Pattern-oriente Software-Architektur - Muster für nebenläufige und vernetzte Objekte, volume 2. dpunkt.verlag, 2002.
[Sta02] "Starke02"
Gernot Starke. Effektive-Softwarearchitekturen: Ein praktischer Leitfaden. Carl Hanser Verlag, 2002.
[Sta03] "Stal-Editorial"
Michael Stal. Der stein der weisen (editorial). 2:3, 2003.
[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.
[Szy02] "Szyperski2002:Component-Software"
Clemens Szyperski. Component Software - Beyond Object-Oriented Programming. Component Software Series. Addison-Wesley, zweite auflage edition, 2002.
[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.
[TMA+96] "Taylor1996:C2"
Richard N. Taylor, Nenad Medvidovic, Kenneth M. Anderson, E. James Whitehead, Jr., Jason E. Robbins, Kari A. Nies, Peyman Oreizy, and Deborah L. Dubrow. A component- and message-based architectural style for gui software. IEEE Transactions on Software Engineering, 22(6):390-406, 1996.
[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.
[uGL03] "Burkhard2003:SOA"
Bärbel Burkhard und Guido Laures. Soa - wertstiftendes architektur-paradigma. OBJEKTspektrum, (6), 2003.
[Ull04] "Ullmann2004:Buzzword-SOA"
Andreas Ullmann. Buzzword soa: Was verbirgt sich hinter serviceorientierten architekturen?. Javamagazin, (10):55-61, 2004.
[Ult04] "Ultsch2004:Datenbionik"
A. Ultsch. Ag datenbionik, 2004.
[VBDT95] "vermeulen95pipeline"
Allan Vermeulen, Gabe Beged-Dov, and Patrick Thompson. The pipeline design pattern. In OOPSLA '95 Workshop on Design Patterns for Concurrent, Parallel and Distributed Object-Oriented Systems, 1995.
[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.
[VFH+04] "Voegler2004:Transcoding"
Gabriel Vögler, Thomas Flor, Bernhard Hohlfeld, Klaus Grimm, and Wolfgang Merker. Multi-client-architekturen für pervasive computing. Technical report, DaimlerChrysler, RIC/SA, 5. February 2004.
[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.
[Vra01] "Denny:SA"
Zdenko Denny Vrandecic. Was ist software architektur, 2001. Ausarbeitung zum Hauptseminar Software Architektur.
[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.
[W3C03] "XInclude"
W3C XML Core Working Group. Xml inclusions (xinclude) version 1.0, 10. November 2003. W3C Working Draft.
[Wal04] "Docbook"
Norman Walsh. Docbook, 2004.
[Web98] "VS-Weber"
Michael Weber. Verteilte Systeme. Spektrum Akademischer Verlag, 1998.
[Web01] "Web:Dialogfluesse"
Sebastian Weber. Entwicklung einer methode zur spezifikation generischer dialogflüsse. Diplomarbeit, Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden, 6. February 2001.
[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.
[Win03] "winkler:XForms"
Matthias Winkler. Xforms und xforms processing. Bakkalaureatsarbeit, Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden, 1. October 2003.
[WKKRSS01] "Duden22"
M. Wermke, A. Klosa, K. Kunkel-Razum, and W. Scholze-Stubenrecht, editors. Duden: Die deutsche Rechtschreibung, volume 1. Mannheim, Dudenverlag, 22 edition, 2001.
[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.
[Wor99] "XML-Namespace"
World Wide Web Consortium. Namespaces in xml, 14. January 1999. W3C Recommendation.
[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.
[Wu] "Jiangtao-Wu"
Jiangtao Wu. Performanceanalyse und -optimierung des java-basierten adaptation frameworks. in Bearbeitung befindliche Belegarbeit amLehrstuhl Rechnernetze,Institut für Systemarchitektur,Fakultät Informatik,Technische Universität Dresden.
[XML01a] "XLink"
XML Linking Working Group. Xml linking language (xlink) version 1.0, 27. June 2001. W3C Recommendation.
[XML01b] "XMLSchema-Primer"
XML Schema Working Group. Xml schema part 0: Primer, 2. May 2001. W3C Recommendation.
[XML01c] "XMLSchema-Structures"
XML Schema Working Group. Xml schema part 1: Structures, 2. May 2001. W3C Recommendation.
[XML01d] "XMLSchema-Datatypes"
XML Schema Working Group. Xml schema part 2: Datatypes, 2. May 2001. W3C Recommendation.
[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.
[ZJ97] "Zave1997:Requirements-Engineering"
Pamela Zave and Michael Jackson. Four dark corners of requirements engineering. ACM Transactions Software Engineering Methodology, 6(1):1-30, 1997.
Abstract
Research in requirements engineering has produced an extensive body of knowledge, but there are four areas in which the foundation of the discipline seems weak or obscure. This article shines some light in the “four dark corners,” exposing problems and proposing solutions. We show that all descriptions involved in requirements engineering should be descriptions of the environment. We show that certain control information is necessary for sound requirements engineering, and we explain the close association between domain knowledge and refinement of requirements. Together these conclusions explain the precise nature of requirements, specifications, and domain knowledge, as well as the precise nature of the relationships among them. They establish minimum standards for what information should be represented in a requirements language. They also make it possible to determine exactly what it means for requirements and engineering to be successfully completed.
[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.