Sébastien Mosser

MODAClouds: a model-driven approach for the design and execution of applications on multiple clouds

Cloud computing is emerging as a major trend in the ICT industry. While most of the attention of the research community is focused on considering the perspective of the Cloud providers, offering mechanisms to support scaling of resources and interoperability and federation between Clouds, the perspective of developers and operators willing to choose the Cloud without being strictly bound to a specific solution is mostly neglected. We argue that Model-Driven Development can be helpful in this context as it would allow developers to design software systems in a cloud-agnostic way and to be supported by model transformation techniques into the process of instantiating the system into specific, possibly, multiple Clouds. The MODAClouds (MOdel-Driven Approach for the design and execution of applications on multiple Clouds) approach we present here is based on these principles and aims at supporting system developers and operators in exploiting multiple Clouds for the same system and in migrating (part of) their systems from Cloud to Cloud as needed. MODAClouds offers a quality-driven design, development and operation method and features a Decision Support System to enable risk analysis for the selection of Cloud providers and for the evaluation of the Cloud adoption impact on internal business processes. Furthermore, MODAClouds offers a run-time environment for observing the system under execution and for enabling a feedback loop with the design environment. This allows system developers to react to performance fluctuations and to re-deploy applications on different Clouds on the long term.

An Architecture to Support the Collection of Big Data in the Internet of Things

The Internet of Things (IoT) relies on physical objects interconnected between each others, creating a mesh of devices producing information. In this context, sensors are surrounding our environment (e.g., cars, buildings, smartphones) and continuously collect data about our living environment. Thus, the IoT is a prototypical example of Big Data. The contribution of this paper is to define a software architecture supporting the collection of sensor-based data in the context of the IoT. The architecture goes from the physical dimension of sensors to the storage of data in a cloud-based system. It supports Big Data research effort as its instantiation supports a user while collecting data from the IoT for experimental or production purposes. The results are instantiated and validated on a project named SMARTCAMPUS, which aims to equip the SophiaTech campus with sensors to build innovative applications that supports end-users.

Using multiple feature models to design applications for mobile phones

The design of a mobile phone application is a tedious task according to its intrinsic variability. Software designers must take into account in their development process the versatility of available platforms (e.g., Android, iPhone). In addition to this, the variety of existing devices and their divergences (e.g., frontal camera, GPS) introduce another layer of complexity in the development process. These two dimensions can be formalized as Software Product Lines (SPL), independently defined. In this paper, we use a dedicated metamodel to bridge the gap between an application SPL and a mobile device one. This meta-model is also the support for the product derivation process. The approach is implemented in a framework named Applide, and is used to successfully derive customer relationship management software on different devices.

SPLEMMA: a generic framework for controlled-evolution of software product lines

Managing in a generic way the evolution process of feature-oriented Software Product Lines (spls) is complex due to the number of elements that are impacted and the heterogeneity of the spls regarding artifacts used to define them. Existing work presents specific approaches to manage the evolution of spls in terms of such artifacts, i.e., assets, feature models and relation definitions. Moreover stakeholders do not necessarily master all the knowledge of the spl making its evolution difficult and error-prone without a proper tool support. In order to deal with these issues, we introduce SPLEmma, a generic framework that follows a Model Driven Engineering approach to capture the evolution of a spl independently of the kind of assets, technologies or feature models used for the product derivation. Authorized changes are described by the spl maintainer and captured in a model used to generate tools that guide the evolution process and preserve the consistency of the whole spl. We report on the application of our approach on two spls: YourCast for digital signage systems, and SALOON, which enables generation of configurations for cloud providers.

Web Services Composition: Mashups Driven Orchestration Definition

On the one hand, mashups are a new kind of Web application built upon the composition of different resources in a user-friendly way. Tools based on such concepts focus on graphic design and allows final users to build complex applications using pipes to connect data sources into a data--flow. It underlines a constant need for making services resuable in an easy way. On the other hand, Web Services Oriented Architecture (WSOA) supports development of high quality applications based on a control-flow between services. We explore in this paper how a WSOA can be defined as a data-flow in a mashup-like approach, where Model Driven Engineering techniques enable a clever composition of data-flows and the generation of control-flows based architecture.

Using composite feature models to support agile software product line evolution

Managing continuous change in a Software Product Line (SPL) is one of the challenges now faced by the SPL engineering community. On the one hand, the SPL paradigm captures the intrinsic variability of a software based on a systemic vision of the software to model. On the other hand, Agile Software Development advocates the incremental development of software based on constant interaction with a customer community. In this paper, we present an approach based on Composite Feature Models (CFM) to support the agile evolution of a SPL. This study is driven by the refactoring of a daily used application (information broadcasting system), in the context of a nationally funded project. Preliminary results show that CFMs support the incremental development of a SPL based on interactions with a community, tackling the challenge of SPL continuous evolution.

From aspect-oriented requirements models to aspect-oriented business process design models: an iterative and concern-driven approach for software engineering

Aspect-oriented approaches are available for various phases of software development such as requirements analysis, design, and implementation. Yet, moving from one phase to the next with aspects remains a challenge seldom studied. In this paper, we present an iterative, concern-driven software engineering approachbased on a tool-supported, semi-automatic transformation of scenario-based, aspect-oriented requirements models into aspect-oriented business process design models. This approach is realized by a mapping from Aspect-oriented Use Case Maps (AoUCM) to Adore business process models, allowing for the continued encapsulation of requirements-level concerns in design-level artifacts. Problems detected during the design phase can be rectified in the requirements models via several feedback loops that support iterative model development. We discuss the transformation process and illustrate, as proof-of-concept, our contribution on the PicWeb case study, a SOA-based implementation of business processes for pictures management.

Web Services Orchestrations Evolution: A Merge Process for Behavioral Evolution

Services Oriented Architectures preach loosely-coupled services and high---level composition mechanisms, using for example Web Services to define services and Orchestrations to compose them. But orchestration evolutions imply modification at source code level. This article shows how the orchestration paradigm itself can be used to support evolution of Web Services Orchestrations through a behavioral merge process. Using the same model to express orchestrations and evolutions, we expose formally and illustrate in this contribution a merging process helping Wsoa administrators to deal with behavioral evolutions.

Using constraint-based optimization and variability to support continuous self-adaptation

Self-adaptation is one of the upcoming paradigms that accurately tackles nowadays systems complexity. In this context, Dynamic Software Product Lines model the intrinsic variability of a family of systems, and dynamically support their reconfiguration according to updated context. However, when several configurations are available for the same context, making a decision about the right one is a hard challenge: further dimensions such as QoS are needed to enrich the decision making process. In this paper, we propose to combine variability with Constraint-Satisfaction Problem techniques to face this challenge. The approach is illustrated and validated with a context-driven system used to support the control of a home through mobile devices.

Using feature model to build model transformation chains

Model transformations are intrinsically related to model-driven engineering. According to the increasing size of standardised meta-model, large transformations need to be developed to cover them. Several approaches promote separation of concerns in this context, that is, the definition of small transformations in order to master the overall complexity. Unfortunately, the decomposition of transformations into smaller ones raises new issues: organising the increasing number of transformations and ensuring their composition (i.e. the chaining). In this paper, we propose to use feature models to classify model transformations dedicated to a given business domain. Based on this feature models, automated techniques are used to support the designer, according to two axis: (i)the definition of a valid set of model transformations and (ii) the generation of an executable chain of model transformation that accurately implement designers intention. This approach is validated on Gaspard2, a tool dedicated to the design of embedded system.