GSpace: An Architectural Approach for Self-Managing Extra-Functional Concerns Giovanni Russello Department of Computing Imperial College London g.russello@imperial.ac.uk Naranker Dulay Department of Computing Imperial College London n.dulay@imperial.ac.uk Michel Chaudron LIACS Universiteit Leiden chaudron@liacs.nl Maarten van Steen Dept. of Computer Science Vrije Universiteit steen@cs.vu.nl ABSTRACT Middleware-based solutions for self-managing systems pro- vide a degree of separation between the mechanisms that govern the adaptability of a system and application func- tionality. Systems become in this way more flexible, de- pendable and robust to changes. However, it is possible to achieve another degree of separation by separating from the application logic the different extra-functional concerns (such as availability, performance, and security). This sep- aration, known as Separation of Concerns principle, helps in generating software artifacts that are more maintainable and reusable. In this paper, we propose an architectural model for a middleware-based solution where the self-managing princi- ple is applied to extra-functional concerns. Our middleware, based on the Shared Data Space model, is capable of dynam- ically adapt extra-functional concerns to the actual needs of the applications. 1. INTRODUCTION There is a general consensus in the research community that self-managing systems enable software engineers gen- erating applications that are more flexible, dependable and robust to changes in the environment. A self-managing sys- tem provides means to adapt the application to changes in the environments and requirements with minimal human in- tervention. Several proposed approaches indicate that viable solutions for achieving self-adaptation are those where self- managing mechanisms are separated from the application functionality. In this context, middleware-based solutions have proven to be suitable for achieving such separation. Another degree of separation is that suggested by the Sep- Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. CSTST 2008 October 27-31, 2008, Cergy-Pontoise, France Copyright 2008 ACM 978-1-60558-046-3/08/0003 ...$5.00. aration of Concerns (SoC) principle [2, 9]. According to SoC, the application logic should be separated from con- cerns that are not directly involved with its basic function- ality. Performance, availability and security represent typ- ical extra-functional concerns that should be isolated and externalised from the application functionality. Applying the SoC principle positively affects the following properties of applications: • Application evolution: because the units of abstraction match with the different concerns changing one specific concern does not affect other modules. • Reusability of concerns: as the code dealing with the application logic can be reused, the same holds for code that deals with extra-functional concerns. • Concern traceability: traceability among different con- cerns is increased since each concern is clearly sepa- rated from the others. As discussed by Filman et al. in [3], the SoC principle is essential for developing applications that strongly depend on their environment and that need to continuously evolve and adapt in the course of time. In this paper, we introduce an architecture for a middleware-based approach in which the evolution and adaptation of extra-functional concerns are self-managed. In particular, in our approach application components implement the basic functionality of an applica- tion. Our middleware provides the composition abstraction for gluing together application components. Moreover, it provides the necessary mechanisms for self-managing extra- functional concerns. In line with the adaptation methodology discussed in [8], our middleware supports the management of the evolution and adaptation of extra-functional concerns. Our middle- ware architecture is based on the shared data space model introduced with the coordination language Linda [4]. The main reason for choosing the shared data space model comes from the fact that this model supports naturally the sepa- ration of the computational part of an application form its coordination part. The architecture that we propose in this paper extends the basic model for supporting several extra- functional concerns transparently to the applications. Cur-