Mireille Blay-Fornarino

A reflective model for first class dependencies

We propose a reflective model to express and to automatically manage dependencies between objects. This model describes reflective facilities which enable the changing of language semantics. Although the importance of inter-object dependencies is well accepted, there is only limited object-oriented language support for their specification and implementation. In response to this lack of expressiveness of object models, the FLO language integrates dependency management into the object oriented paradigm. Dependencies are described as first class objects and FLO automatically maintains the consistency of the dependency graph.In this paper, we first show how a user can declare dependencies and how the system maintains the consistency of the graph of expressed dependencies. In a second part, we focus on the implementation of this management by controlling the messages sent to linked objects. In order to make dependency management orthogonal to other application concerns, we propose an abstraction of message handling, implemented with meta-objects. We illustrate the extensibility of our language with different control behavior implementations, in particular we study different implementations of the global control of message propagation flow.

Computer-Assisted Scientific Workflow Design

Workflows are increasingly adopted to describe large-scale data- and compute-intensive processes that can take advantage of today’s Distributed Computing Infrastructures. Still, most Scientific Workflow formalisms are notoriously difficult to fully exploit, as they entangle the description of scientific processes and their implementation, blurring the lines between what is done and how it is done as well as between what is and what is not infrastructure-dependent. This work addresses the problem of data-intensive Scientific Workflow design by describing scientific experiments at a higher level of abstraction, emphasizing scientific concepts over technicalities, easing the separation of functional and non-functional concerns and leveraging domain knowledge. To achieve this goal, we propose a model-driven approach enhanced with Knowledge Engineering technologies. The main contributions of this work are a semantic Scientific Workflow model to capture user goals and a generative process assisting the transformation from high-level models to executable workflow artefacts.

Interactions Between Objects: An Aspect of Object-Oriented Languages

It is now well known that it is not easy to manage the interactions between objects in conventional object-oriented languages [Rum92,Bos94]. The interactions are tangled in the code of the objects, specializing classes, sending messages to others objects in the code of methods or referencing interacting objects by specific attributes. The consequence is that the semantic of the objects participating to an interaction is modified and the application maintainability and extensibility are harder.

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.

Merging overlapping orchestrations: an application to the Bronze Standard medical application

Merging orchestrations is a crucial issue in the development process of service-based applications. However, merging orchestrations with overlaps is a manual and tedious process today. In this paper, we present a case-study on the Bronze-Standard, a medical imaging application built from Web-Service based orchestrations. We introduce the OMSM, an orchestration model supporting merging, that we designed to assist this process. Through a detailed analysis of the use-case, we show how our model helps the developer to obtain a proper composition of the application. There is still room for generalizing the approach to a broader set of orchestrations as discussed.

Distributed access knowledge-based system: reified interaction service for trace and control

Explains our approach to help users graphically trace and control the behavior of distant objects in a knowledge-based system (KBS). This working context implies tackling several problems: numerous, varied and heterogeneous entities to distribute; dynamic and interactive communications; bi-directional control; and user-friendly means of expression. Our approach is based on an architecture using an existing tool (DICO*) that allows connecting distant heterogeneous objects through an interaction mechanism. We also offer two kinds of dedicated and extensible libraries of trace and control interactions. We have tested this approach in a prototype proving the advantages of these two libraries as well as those of DICO* to distribute KBSs. Our reified interaction service accommodates adaptive multi-access to a KBS without modifying its code.