Recent Results

D6.1 Case Study Specification and Requirements — by Dhouha Ayed — last modified 2010-02-11 15:24

 

D1.2 Framework for Identifying and Modelling of Dynamic Variability in Requirements — by Ruzanna Chitchyan — last modified 2010-02-09 15:30

In the present document we present the first part of the DiVA RE approach which mainly focuses on answering the question on what (requirements, their justification and context) to model, as well as touches on the issue of how to restrict the proliferation of variants in requirements models. To address these questions, the DiVA RE approach proposes to: • construct a feature tree from the input requirements text, thus identifying specific requirements that need to be modelled, and refining this tree with variations and adaptation points; • recover the hard- and soft-goals related to the given requirements to provide a justification for them, and also to use a single goal-model for modelling the large set of potential variations; • analyse the resultant goal/feature tree to extract the relevant context and related variability and constraints which restricts the set of potential configurations. URL: http://www.ict-diva.eu/DiVA/docs/D1.2%20Framework%20for%20Identifying%20and%20Modelling%20of%20Dynamic%20Variability.pdf

D1.1: Survey and Evaluation Document of the Requirements Engineering for Dynamic Variability — by Ruzanna Chitchyan — last modified 2010-02-09 15:20

Up till now the main body of Requirements Engineering work has been concerned with static elicitation, representation, and analysis of requirements [31, 53, 70]. However, with the recent emergence of a number of continuously dynamically changing mobile and ubiquitous systems as well as the complex dynamic system composition (such as crisis handling systems, or system construction via dynamic service acquisition) the need for consideration of dynamic change at requirements level has also emerged. In this report we primarily consider the requirements and dynamic change from two perspectives: 1. Identifying the characteristics that are necessary to support dynamic change at requirements level; 2. Surveying present-day Requirements Engineering approaches to uncover the mechanisms via which they could handle dynamic change at the requirements level. The report also reviews the activities needed for supporting requirements configuration management, since these are an essential component for a transparent and controllable change management. The results of this survey will be used to develop the DiVA Requirements Engineering approach for addressing challenges pertaining to analysis of dynamic variability (DiVA deliverables D1.2-D1.4). The preliminary outline of this approach is also sketched in this report. URL:http://www.ict-diva.eu/DiVA/docs/D1.1%20Survey%20and%20Evaluation%20Document%20of%20Requirements%20Engineering%20for%20Dynamic%20Variability.pdf

D3.2: Reference Architecture — by Brice Morin — last modified 2010-02-09 10:59

This deliverable presents the first version of the reference architecture to support the dynamic variability using model-driven engineering techniques and aspect models. The purpose of the document is to provide an overview of the reference architecture, to detail some important parts of this reference architecture and give some implementation details. This document is associated with a software system, demonstrating the reference architecture on one of the DiVA case studies, to be integrated in the DiVA Studio.

Aspect Model Unweaving — by Brice Morin — last modified 2009-08-18 11:24

Since software systems need to be continuously available, their ability to evolve at runtime is a key issue. The emergence of models@runtime, combined with Aspect-Oriented Modeling techniques, is a promising approach to tame the complexity of adaptive systems. However, with no support for aspect unweaving, these approaches are not agile enough in an adaptive system context. In case of small modications, the adapted model has to be generated by again weaving all the aspects, even those unchanged. This paper shows how aspects can be unwoven, based on a precise traceability metamodel dedicated to aspect model weaving. We analyze traceability models, which describe how aspects were woven into a base, to determine the extent to which an aspect has affected the woven model in order to determine how it can be unwoven. Aspect unweaving is nally performed by applying inverse operations of a sub-sequence of the weaving operations in opposite order.

Unifying Runtime Adaptation and Design Evolution — by Brice Morin — last modified 2009-08-18 11:21

The increasing need for continuously available software systems has raised two key-issues: self-adaptation and design evolution. The former one requires software systems to monitor their execution platform and automatically adapt their configuration and/or architecture to adjust their quality of service (optimization, fault-handling). The later one requires new design decisions to be reflected on the fly on the running system to ensure the needed high availability (new requirements, corrective and preventive maintenance). However, design evolution and selfadaptation are not independent and reflecting a design evolution on a running self-adaptative system is not always safe. We propose to unify run-time adaptation and run-time evolution by monitoring both the run-time platform and the design models. Thus, it becomes possible to correlate those heterogeneous events and to use pattern matching on events to elaborate a pertinent decision for run-time adaptation. A flood prediction system deployed along the Ribble river (Yorkshire, England) is used to illustrate how to unify design evolution and run-time adaptation and to safely perform runtime evolution on adaptive systems.

D4.1: Survey and evaluation of approaches for the adaptation reasoning framework — by Michael Hentze — last modified 2009-06-30 22:33

Creation of an adaptation reasoning framework for dynamic, adaptive, and distributed systems is not a trivial task. Such a framework reasons on the variability that is represented by models implementing DiVA's MDE ap-proach and which causes, due to the potential big size of such systems, an explosion of complexity. A dynamic system operates in real-time and is in the potentially constant need to respond fast to component or context changes through global reconfiguration. Complexity explosion would, if not appropriately handled, result in unacceptable calculation costs and too long reaction time spans while deciding which of a large number of possible configuration variants is valid or even optimal. This survey researches and evaluates existing reasoning approaches and shows ways to reduce reasoning com-plexity in the context of DiVA. Results will be the base of the later Reasoning Framework implementation of WP4 that is coupled to the concepts and implementations of the technical DiVA work packages 1, 2, and 3.

On the Use of Software Models during Software Execution — by Nelly Bencomo — last modified 2009-06-04 18:24

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.

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.