Alignment of viewpoint heterogeneous design models: Emergency Department Case Study

International audienceGenerally, various models can be used to describe a given application domain on different aspects and thus give rise to several views. To have a complete view of the application domain, heterogeneous models need to be unified, which is a hard task to do. To tackle this problem, we have proposed a method to relate partial models without combining them in a single model. In our approach, partial models are organized as a network of models through a virtual global model called M1C (Model of correspondences between models) which conforms to a ubiquitous language based on a Meta-Model of Correspondences (MMC). This paper presents an application of our method to an “Emergency Department” case study. It has been performed as a collaborative process involving model designers and a supervisor. The focus is put on the building of the M1C model from 3 partial models

Towards Language-Oriented Modeling

In this habilitation à diriger des recherches (HDR), I review a decade of research work in the fields of Model-Driven Engineering (MDE) and Software Language Engineering (SLE). I propose contributions to support a language-oriented modeling, with the particular focus on enabling early validation & verification (V&V) of software-intensive systems. I first present foundational concepts and engineering facilities which help to capture the core domain knowledge into the various heterogeneous concerns of DSMLs (aka. metamodeling in the small), with a particular focus on executable DSMLs to automate the development of dynamic V&V tools. Then, I propose structural and behavioral DSML interfaces, and associated composition operators to reuse and integrate multiple DSMLs (aka. metamodeling in the large).In these research activities I explore various breakthroughs in terms of modularity and reusability of DSMLs. I also propose an original approach which bridges the gap between the concurrency theory and the algorithm theory, to integrate a formal concurrency model into the execution semantics of DSMLs. All the contributions have been implemented in software platforms — the language workbench Melange and the GEMOC studio – and experienced in real-world case studies to assess their validity. In this context, I also founded the GEMOC initiative, an attempt to federate the community on the grand challenge of the globalization of modeling languages

Framework for Heterogeneous Modeling and Composition

National audienceEmbedded and cyber-physical systems are becoming more and more complex. They are often split into subsystems and each subsystem can be addressed by a Domain Specific Modeling Language (DSML). A DSML efficiently specifies the domain concepts as well as their behavioral semantics. For a single system, several models conforming to different DSMLs are then developed and the system specification is consequently heterogeneous, \textit{i.e.}, it is specified by using heterogeneous languages. The behaviors of these models have to be coordinated to provide simulation and/or verification of the overall system. This thesis studies this coordination problem with the objective of enabling the execution and the verification of the heterogeneous systems, by relying on the behavioral composition of DSMLs. We are currently proposing a language named B-COoL (Behavioral Composition Operator Language) to specify the composition of DSMLs behavior. The aim of B-COoL is two-fold: to capitalize the coordination at the language level, and to enable the automatic generation of the coordination between models conforming to composed DSMLs

Integration of Heterogeneous Modeling Languages via Extensible and Composable Language Components

Effective model-driven engineering of complex systems requires to appropriately describe different specific system aspects. To this end, efficient integration of different heterogeneous modeling languages is essential. Modeling language integaration is onerous and requires in-depth conceptual and technical knowledge and ef- fort. Traditional modeling lanugage integration approches require language engineers to compose monolithic language aggregates for a specific task or project. Adapting these aggregates cannot be to different contexts requires vast effort and makes these hardly reusable. This contribution presents a method for the engineering of grammar-based language components that can be independently developed, are syntactically composable, and ultimately reusable. To this end, it introduces the concepts of language aggregation, language embed- ding, and language inheritance, as well as their realization in the language workbench MontiCore. The result is a generalizable, systematic, and efficient syntax-oriented composition of languages that allows the agile employment of modeling languages efficiently tailored for individual software projects.Comment: 12 pages, 11 figures. Proceedings of the 3rd International Conference on Model-Driven Engineering and Software Development. Angers, Loire Valley, France, pp. 19-31, 201

Multi-Platform Generative Development of Component & Connector Systems using Model and Code Libraries

Component-based software engineering aims to reduce software development effort by reusing established components as building blocks of complex systems. Defining components in general-purpose programming languages restricts their reuse to platforms supporting these languages and complicates component composition with implementation details. The vision of model-driven engineering is to reduce the gap between developer intention and implementation details by lifting abstract models to primary development artifacts and systematically transforming these into executable systems. For sufficiently complex systems the transformation from abstract models to platform-specific implementations requires augmentation with platform-specific components. We propose a model-driven mechanism to transform platform-independent logical component & connector architectures into platform-specific implementations combining model and code libraries. This mechanism allows to postpone commitment to a specific platform and thus increases reuse of software architectures and components.Comment: 10 pages, 4 figures, 1 listin

From Sensors to Visualization Dashboards: Need for Language Composition

International audienceIn the context of the Internet of Things, the SensApp platform is designed to collect data from sensors and support the building of associated monitoring dashboards. Bridging the gap between sensors and visualization involves up to eleven kind of models, from state machine modeling the behavior of a sensor to task diagrams modeling the actions of the end-user. This paper describes this case study, emphasizing the need for domain specific modeling language composition mechanisms to support the activity of modeling modern software-intensive systems

A Generic Framework for Representing and Analysing Model Concurrency

International audienceRecent results in language engineering simplify the development of tool-supported executable domain-specific modelling languages (xDSMLs), including editing (e.g., completion and error checking) and execution analysis tools (e.g., debugging, monitoring and live modelling). However, such frameworks are currently limited to sequential execution traces, and cannot handle execution traces resulting from an execution semantics with a concurrency model supporting parallelism or interleaving. This prevents the development of concurrency analysis tools, like debuggers supporting the exploration of model executions resulting from different interleavings. In this paper, we present a generic framework to integrate execution semantics with either implicit or explicit concurrency models, to explore the possible execution traces of conforming models, and to define strategies for helping in the exploration of the possible executions. This framework is complemented with a protocol to interact with the resulting executions and hence to build advanced concurrency analysis tools. The approach has been implemented within the GEMOC Studio. We demonstrate how to integrate two representative concurrent meta-programming approaches (MoCCML/Java and Henshin), which use different paradigms and underlying foundations to define an xDSML's concurrency model. We also demonstrate the ability to define an advanced concurrent omniscient debugger with the proposed protocol. The paper, thus, contributes key abstractions and an associated protocol for integrating concurrent meta-pro\-gram\-ming approaches in a language workbench, and dynamically exploring the possible executions of a model in the modelling workbench