Publications

An Aspect-Oriented and Model-Driven Approach for Managing Dynamic Variability

BriceMorin — 2008-09-25T17:49:39Z

Constructing and executing distributed systems that can adapt to their operating context in order to sustain provided services and the service qualities are complex tasks. Managing adaptation of multiple, interacting services is particularly difficult since these services tend to be distributed across the system, interdependent and sometimes tangled with other services. Furthermore, the exponential growth of the number of potential system configurations derived from the variabilities of each service need to be handled. Current practices of writing low-level reconfiguration scripts as part of the system code to handle run time adaptation are both error prone and time consuming and make adaptive systems difficult to validate and evolve. In this paper, we propose to combine model driven and aspect oriented techniques to better cope with the complexities of adaptive systems construction and execution, and to handle the problem of exponential growth of the number of possible configurations. Combining these techniques allows us to use high level domain abstractions, simplify the representation of variants and limit the problem pertaining to the combinatorial explosion of possible configurations. In our approach we also use models at runtime to generate the adaptation logic by comparing the current configuration of the system to a composed model representing the configuration we want to reach.

Improving Maintenance in AOP Through an Interaction Specification Framework

FreddyMunoz — 2008-10-14T17:18:58Z

The invasiveness of aspects is beneficial to modularize crosscutting concerns that require the modification of the data or control flow. However, it introduces subtle errors that are hard to locate and fix in case of evolution. In this paper we illustrate this issue by evolving a program implemented using aspects. Interaction issues, between aspects and the program, emerge from this evolution. We locate them through manual inspection and test execution. This tedious process motivates the need for an abstract specification of intended interactions. To tackle this issue, we propose a framework for specifying the types of invasiveness pattern that are allowed of forbidden in the program. We have also implemented a tool that automatically checks whether the specification is satisfied by the aspects.

Modeling and Validating Dynamic Adaptation

VegardDehlen — 2008-10-08T13:24:09Z

This paper discusses preliminary work on modeling and validating dynamic adaptation. The proposed approach is on the use of aspect-oriented modeling (AOM) and models at runtime. Our approach covers design and runtime phases. At design-time, a base model and different variant architecture models are designed and the adaptation model is built. Crucially, the adaptation model invludes invariant properties and contraints that allow the validation of the adaptation rules before execution. During runtime, the adaptation model is processed to produce a correct system configuration that can be executed.

K@RT: An Aspect-Oriented and Model-Oriented Framework for Dynamic Software Product Lines

BriceMorin — 2008-10-14T14:21:39Z

Software systems should often provide continuous services and cannot easily be stopped. However, in order to meet new requirements from the user
or the marketing, systems should be able to evolve in order to provide new services or modify existing ones. Adapting software systems at runtime is not an easy task and should be realized with attention. In this paper, we present K@RT, our generic and extensible framework for managing dynamic software product lines. K@RT is composed of three parts: i) a generic and extensible metamodel for describing running systems at a high-level of abstraction, ii) a set of metaaspects that extends the generic metamodel with constraint checking, supervising and connections with execution platforms iii) some platform-specific causal connections that allow us to supervise systems running on different execution platforms.

Validation challenges in model composition: The case of adaptive systems

DirkBalfanz — 2008-10-14T17:11:32Z

Model Driven Engineering helps dealing with complexity by promoting models as abstraction units. Aspect Oriented Modeling helps separating concerns that crosscut across different models. MDE and AOM have well identified challenges that need to be addressed. However, there are new challenges that appear when combining both techniques. In this paper we present the challenges that appear when validating the model composition in the context of MDE and AOM applied to adaptive systems

Modeling the Variability Space of Self-Adaptive Applications

DirkBalfanz — 2009-02-13T18:57:45Z

Modeling self-adaptive applications is a difficult task due to the complex relationships they have with their environments. Designers of such applications strive to model accurately a few (re)-configuration possibilities deemed to be the most relevant with respect to environmental changes. This deliberate restriction of the variability space is cumbersome and may unnecessarily reject interesting (re)-configuration possibilities. We employ software productline techniques to properly cover the whole variability space of a self-adaptive application. This variability space is partitioned across three dimensions. Functional variability is modeled through a feature diagram whose features are realized by a set of components to be deployed on a platform. Topological variability is modeled via an UML collaboration excluding irrelevant configurations. Platform variability is modeled through constraints to be satisfied by configurations. For each dimension, we exhibit properties capturing the environment. Our modeling approach is illustrated on a web-server example.

Dynamically Adaptive Systems are Product Lines too: Using Model-Driven Techniques to Capture Dynamic Variability of Adaptive Systems

NellyBencomo — 2009-02-05T14:44:05Z

Engineering Complex Adaptations in Highly Heterogeneous Distributed Systems

NellyBencomo — 2009-02-05T14:45:54Z

Supporting the Modelling and Generation of Reflective Middleware Families and Applications using Dynamic Variability

NellyBencomo — 2009-02-05T14:54:29Z

This thesis explores how synergies between system family engineering, model driven engineering, and generative software development help to produce new development paradigms to support design, programming, testing, deployment, and execution of reflective middleware families and their applications. The thesis proposes Genie, an approach that guides the development and operation of reflective middleware platforms and their applications. Genie oers management of dynamic variability during development and allows the systematic generation of middleware related artefacts from high level descriptions (models). To this end, two kinds of dynamic variability are identied, namely structural variability and environment and context variability. As a validation of the approach, a prototype called the Genie tool has been developed. The Genie tool supports the speci cation, validation and generation of artefacts for component-based reflective middleware using domain specic modelling languages (DSMLs). The approach has also been used to support the development and operation of Gridkit, one of the dynamically congurable middleware families that have been developed at Lancaster University.

Using Architecture Models to Support the Generation and Operation of Component-based Adaptive Systems

NellyBencomo — 2009-02-05T15:01:20Z

Chapter in Book on Software Engineering for Self-Adaptive Systems (SEfSAS Book) LNCS Hot Topics on Software Engineering for Self-Adaptive Systems, 2009 Betty H. C. Cheng, Rogerio de Lemos, Holger Giese, Paola Inverardi, Jeff Magee (Editors)

Comparitive Study of Variability Management in Software Product Lines and Runtime Adaptable Systems

NellyBencomo — 2009-02-05T15:04:14Z

Taming Dynamically Adaptive Systems Using Models and Aspects

BriceMorin — 2009-02-10T19:47:39Z

Since software systems need to be continuously available under varying conditions, their ability to evolve at runtime is increasingly seen as one key issue. Modern programming frameworks already provide support for dynamic adaptations. However the high-variability of features in Dynamic Adaptive Systems (DAS) introduces an explosion of possible runtime system configurations (often called modes) and mode transitions. Designing these configurations and their transitions is tedious and error-prone, making the system feature evolution difficult. While Aspect-Oriented Modeling (AOM) was introduced to improve the modularity of software, this paper presents how an AOM approach can be used to tame the combinatorial explosion of DAS modes. Using AOM techniques, we derive a wide range of modes by weaving aspects into an explicit model reflecting the runtime system. We use these generated modes to automatically adapt the system. We validate our approach on an adaptive middleware for home-automation currently deployed in Rennes metropolis.

Managing Variability Complexity in Aspect-Oriented Modeling

BriceMorin — 2009-04-15T18:56:40Z

Aspect-Oriented Modeling (AOM) approaches propose to model reusable aspects that can be composed in dierent systems at a model level. To improve the reusability, several contributions have pointed out the needs of variability in the AOM approaches. Nevertheless, the support of variability makes more complex the aspect design and the introduction of several dimensions of variability (advice, pointcut and weaving) creates a combinatorial explosion of variants and a risk of inconsistency in the aspect model. As the integration of an aspect model may be complex, it is essential that the AOM framework ensures the consistency of the resulting model. This paper presents an approach describing how to ensure that an aspect model with variability can be safely integrated into an existing model. The verications include static checking of aspect models consistency and dynamic checking through testing with a focus on the parts of the model that are impacted by the aspect.

A Formal Approach to Semantic Composition of Aspect-Oriented Requirements

RuzannaChitchyan — 2009-04-17T15:42:20Z

The goal of Aspect-Oriented Requirements Engineering (AORE) is to identify possible crosscutting concerns, and to develop composition specifications around those concerns. These compositions can be used to reason about potential conflicts in the requirements and to relate requirements to architecture in semantically meaningful ways. Recent work in AORE has moved from a syntactic approach to composition, which leads to fragile compositions and increased coupling between aspect and base concerns, to a semantic composition approach, based on semantics of the natural language itself. However, such compositions are at present only informally specified, and as such formal reasoning about the requirements and the subsequent derivations are difficult. We present a formal approach to these semantic-based compositions which facilitates this reasoning. We show that the approach especially lends itself to identifying conflicts between requirements and mapping compositions to a derived architecture.

On the Use of Software Models during Software Execution

NellyBencomo — 2009-06-04T14:24:59Z

Increasingly software systems are required to survive variations in their execution environment without or with only little human intervention. Such systems are called "eternal software systems". In contrast to the traditional view of development and execution as separate cycles, these modern software systems should not present such a separation. Research in MDE has been primarily concerned with the use of models during the first cycle or development (i.e. during the design, implementation, and deployment) and has shown excellent results. In this paper the author argues that an eternal software system must have a first-class representation of itself available to enable change. These runtime representations (or runtime models) will depend on the kind of dynamic changes that we want to make available during execution or on the kind of analysis we want the system to support. Hence, different models can be conceived. Self-representation inevitably implies the use of reflection. In this paper the author briefly summarizes research that supports the use of runtime models, and points out different issues and research questions.