Recent Results

D3.1: Survey and evaluation of approaches for runtime variability management — by Brice Morin — last modified 2009-06-30 23:05

 

A Formal Approach to Semantic Composition of Aspect-Oriented Requirements — by Ruzanna Chitchyan — last modified 2009-04-17 19:42

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.

Managing Variability Complexity in Aspect-Oriented Modeling — by Brice Morin — last modified 2009-04-15 22:56

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 verications 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.

Taming Dynamically Adaptive Systems Using Models and Aspects — by Brice Morin — last modified 2009-02-10 21:47

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.

Comparitive Study of Variability Management in Software Product Lines and Runtime Adaptable Systems — by Nelly Bencomo — last modified 2009-02-05 17:04

 

Using Architecture Models to Support the Generation and Operation of Component-based Adaptive Systems — by Nelly Bencomo — last modified 2009-02-05 17:01

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)

Supporting the Modelling and Generation of Reflective Middleware Families and Applications using Dynamic Variability — by Nelly Bencomo — last modified 2009-02-05 16:54

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 identied, 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 specic modelling languages (DSMLs). The approach has also been used to support the development and operation of Gridkit, one of the dynamically congurable middleware families that have been developed at Lancaster University.

Engineering Complex Adaptations in Highly Heterogeneous Distributed Systems — by Nelly Bencomo — last modified 2009-02-05 16:45

 

Dynamically Adaptive Systems are Product Lines too: Using Model-Driven Techniques to Capture Dynamic Variability of Adaptive Systems — by Nelly Bencomo — last modified 2009-02-05 16:44

 

Modeling the Variability Space of Self-Adaptive Applications — by Dirk Balfanz — last modified 2009-02-13 20:57

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.

Validation challenges in model composition: The case of adaptive systems — by Dirk Balfanz — last modified 2008-10-14 21:11

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

K@RT: An Aspect-Oriented and Model-Oriented Framework for Dynamic Software Product Lines — by Brice Morin — last modified 2008-10-14 18:21

Software systems should often provide continuous services and cannot easily be stopped. However, in order to meet new requirements from the user<br />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.

Modeling and Validating Dynamic Adaptation — by Vegard Dehlen — last modified 2008-10-08 17:24

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.

Improving Maintenance in AOP Through an Interaction Specification Framework — by Freddy Muñoz — last modified 2008-10-14 21:18

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.

An Aspect-Oriented and Model-Driven Approach for Managing Dynamic Variability — by Brice Morin — last modified 2008-09-25 21:49

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.