Joël Champeau

Model-driven generative development of measurement software

Metrics offer a practical approach to evaluate properties of domain-specific models. However, it is costly to develop and maintain measurement software for each domain-specific modeling language. In this paper, we present a model-driven and generative approach to measuring models. The approach is completely domain-independent and operationalized through a prototype that synthesizes a measurement infrastructure for a domain-specific modeling language. This model-driven measurement approach is model-driven from two viewpoints: (1) it measures models of a domain-specific modeling language; (2) it uses models as unique and consistent metric specifications, with respect to a metric specification metamodel which captures all the necessary concepts for model-driven specifications of metrics. The benefit from applying the approach is evaluated by four case studies. They indicate that this approach significantly eases the measurement activities of model-driven development processes.

A Model-Driven Measurement Approach

Companies using domain specific languages in a model-driven development process need to measure their models. However, developing and maintaining a measurement software for each domain specific modeling language is costly. Our contribution is a model-driven measurement approach. This measurement approach is model-driven from two viewpoints: 1) it measures models of a model-driven development process; 2) it uses models as unique and consistent metric specifications, w.r.t a metric specification metamodel. This declarative specification of metrics is then used to generate a fully fledged implementation. The benefit from applying the approach is evaluated by two applications. They indicate that this approach reduces the domain-specific measurement software development cost.

Model-Driven Simulation of a Maritime Surveillance System

This paper reports an industrial experiment made at Thales to use Model Driven Architecture (MDA) for system engineering. System engineering processes are currently mainly document-centric. The main experiment goal was to study the applicability of MDA at the system engineering level. The experiment consisted of setting up a model-driven simulation environment for a maritime surveillance system. The simulation is achieved thanks to 3 models conform to 3 metamodels. The implementation uses the Eclipse Modeling Framework and is written in the Java Programming language. This pilot project met the deadline, the budget and the threshold of desired functionalities. We report the main advances given by the MDA approach in the context of simulation for system engineering.

Towards Tool Integration through Artifacts and Roles

Existing approaches to tool integration based upon metamodels encounter the problem that common (integration) metamodels become too large and complicated, due to the large number of different tools that have to be integrated, each with their specific metamodel defining models handled by each tool. The approach taken here is radically different in that it distinguishes between the model for integration and the tool metamodels, and that it provides mechanisms by which the common integration model and the various tool metamodels can be related. In addition the integration model covers the need for expressing commonalities between models in different languages. Integration is done by means of Artifact resources that are representatives of the real models and model elements. Pure Artifact resources have properties that are required for simple tool integration like trace ability. In order to cover transformations, special Artifact resources for models and model elements in languages defined by metamodels will have properties identifying the metamodel of the language and the type of model element. In cases where integration is based upon concepts that are common to a set of languages, the common concepts are represented by roles played by Artifact resources, in general the same real model element may therefore play different roles for different integration purposes. The integration approach is validated by three experiments: trace ability, transformation, and common concepts for the purpose of software-hardware co-design. The approach is independent of specific implementation platforms. The paper demonstrates how the approach is realized based upon OSLC [24].

MoPCoM/MARTE Process Applied to a Cognitive Radio System Design and Analysis

Today, developments of real time embedded systems have to face new challenges. On the one hand, economic laws, such as Time-to-market, require a reliable development process allowing quick design space exploration. On the other hand, fast increasing technology, as stated by the Moores law, requires techniques to handle the resulting productivity gap. Model Driven Development has been widely used in response to those issues. Benefits of such approach are numerous and have been demonstrated through several experiments. We present in this paper the Model Driven Development MoPCoM methodology, dedicated to SoC / SoPC design and analysis, and based on the use of the MARTE profile. This approach refines the MDA Y-Chart in order to ease design space exploration and IP integration. We illustrate our approach on Cognitive Radio System development implemented on an FPGA. This work is part of the MoPCoM research project (http://www.mopcom.fr) gathering academic and industrial organizations.

A Definition of "Abstraction Level" for Metamodels

In model-driven software development, the first-class data are models, which are all structured by a metamodel. In this paper, we propose a definition of abstraction levels for metamodels based on set theory and compatible with MOF. We claim that splitting metamodels into different abstractions levels raise their organizational quality. We present application cases of this statement.

Automated measurement of models of requirements

On way to formalize system requirements is to express them using the object-oriented paradigm. In this case, the class model representing the structure of requirements is called a requirements metamodel, and requirements themselves are object-based models of natural language requirements. In this paper, we show that such object-oriented requirements are well suited to support a large class of requirements metrics. We define a requirements metamodel and use an automated measurement approach proposed in our previous work to specify requirements metrics. We show that it is possible to integrate 78 metrics from 11 different papers in the proposed framework. The software that computes the requirements metric values is fully generated from the specification of metrics.

Model-based product line evolution: an incremental growing by extension

Model-Based Engineering (MBE) and Product Line Engineering (PLE) have been combined, to handle new system development constraints like: increasing complexity, higher product quality, faster time-to-market and cost reduction. As observed by some authors, the derivation of a product from product line shared core assets has been insufficiently addressed and can remain tedious in practice. We cope with this issue focusing on having a flexible and reactive model-based derivation, and propose an incremental evolution by extension of the product line coupled with this derivation activity. Process and tools bridge the gap between Application and Domain Engineering introducing a semi-automatic feedback to benefits from the developments made in the Application Engineering. The approach is applied to a model-based product line dedicated to Class diagrams, and is tooled within the Eclipse environment.

An approach for describing concurrency and communication of heterogeneous systems

The fast development of technology and the time-to-market constraints need well-adapted technical support and development processes to ease design space exploration and the reduction of the productivity gap. Model Based Engineering (MBE) overcomes the increasing complexity of system being highly heterogeneous and integrating concurrent sub-systems. Elsewhere, Models of Computation (MoC) help enforcing MBE with aspects related to the execution semantics of models. In a previous paper, we introduced a language called Cometa providing more expressiveness for these aspects. It allows the capture and analysis of several MoCs at high level of abstraction, highlighting communication and synchronization among parts of a heterogeneous system. The language was tooled in Rhapsody and tested on an industrial case. In this paper, we present the key concepts of the Cometa language and the tooling experiments of Cometa in an open source environment. The objective of this approach is being able to model heterogeneous systems, but also to broaden the scope of the language tooling, by taking benefits from an open source environment.

Relationships Formalization for Model-Based Product Lines

Model-Based Engineering (MBE) and Product Line Engineering (PLE) have been combined, to handle new system development constraints like: increasing complexity, higher product quality and cost reduction. Many authors have pointed out the need of modularization in the variability and in the core assets space. Existing approaches focus on separating and delimiting concerns or providing generic composition mechanisms. In Model-Based Product Lines, with an increasing number of models to manage, organizing the modeling space becomes central to support product line consistency, maintenance and product derivation process. To organize the modeling space, we propose to precisely describe the dependencies among modeling artifacts and clarify their use. Thus, we introduce the Product Line Modeling Space (PLiMoS) language that specializes relationships, based on an intentional framework, for the product line domain. The Domain Specific Language (DSL) provides a solution to model the modeling space and preserves independence with the product line tooling.