This is a joint work between Supélec and the Triskell research team at IRISA.

Approach

The complete and executable definition of a Domain Specific Language (DSL) relies on the specification of two essential facets:

• a model of the domain-specific concepts with actions and their semantics;
• and a scheduling model that orchestrates the actions of a domain-specific model.

Metamodels can capture the former facet, while Models of Computation (MoCs) capture the latter facet. Unfortunately, theories and tools for metamodeling and MoCs have evolved independently, creating a cultural and technical chasm between the two communities. Consequently, there is currently no framework to explicitly model and compose both facets of a DSL.

In this work, we propose a new framework to combine a metamodel and a MoC in a modular fashion. This allows:

1. the complete and executable definition of a DSL,
2. the reuse of a given MoC for different domain-specific metamodels,
3. and the use of different MoCs for a given metamodel, to account for variants of a DSL.

We provide an implementation of this framework built on top of the Kermeta workbench and the ModHel’X framework, which therefore provides a "bridge" between the two approaches.

Experimentation

We provide two instantiations of this bridge, implementing a simplified version of the behavioral semantics of two "DSLs":

• SPEM, the Software and Systems Process Engineering Metamodel specification of the OMG;
• fUML, the Semantics of a Foundational Subset for Executable UML Models (FUML) of the OMG.

For both DSLs, we decompose the mapping between their abstract syntax and their semantic domain into two elements:

1. several Domain Specific semantic Actions (DSAs), which represent the elementary behaviors associated to the concepts in the abstract syntax of the DSL. The semantics of the DSAs is described in an executable way and weaved on the metamodel of the DSL using Kermeta.
2. a Model of Computation (MoC), which defines how and when the domain specific semantic actions are triggered. ModHel'X provides the environment for describing MoCs in an executable way and for executing a model according to a chosen MoC (i.e. for scheduling the DSAs according to the scheduling rules provided by the MoC).

Since both fUML and SPEM have an event-based semantics, we have chosen to use the well-known Discrete Events (DE) MoC. DE is a MoC for the simulation of communicating processes, for instance hosts exchanging messages on a network, and it is has been previously implemented in ModHel'X.

Downloads

First, intall the Kermeta workbench version 1.4.1 (see instructions here).

Then download the following Eclipse projects, to import into your Kermeta/Eclipse workspace (File > Import > Existing Projects into Workspace > Select Archive File):

1. the ModHel'X project;
2. the fUML project or the SPEM project, which respectively contain:
   • the metamodel and the domain specific semantic actions of each DSL;
   • the wrapper(s) that allow the DSAs to be wrapped into ModHel'X blocks so that they can be executed by ModHel'X according to the Discrete Events MoC;
   • example models that can be executed.

Before trying to run any of the example models, don't forget to register the ModHel'X, fUML and SPEM metamodels into the EMF EPackage Registry: open each Ecore metamodel, right-click on the top level element, then in the contextual menu choose EPackages registration > Register EPackages into repository.

Implementation details

In the above implementation, we provide a prototype version of ModHel'X written in Kermeta. A more complete implementation exists in Java and can be downloaded here with an example of a heterogeneous model (the Power Window Example).

The Java implementation of ModHel'X is based on EMF, therefore we could have built the above experimentation on top of it. However, the Kermeta implementation that we provide here shows a much clearer separation between the abstract syntax, the abstract semantics and the MoC specific actions in the architecture of ModHel'X.