The Eclipse GEMOC Studio project is intended to federate the research results regarding the support of the coordinated use of various modeling languages that will lead to the concept of globalization of modeling languages, that is, the use of multiple modeling languages to support the socio-technical coordination required in systems and software engineering.
The project is intended to develop techniques, frameworks, and environments to facilitate the creation, integration, and automated processing of heterogeneous modeling languages. Indeed, the development of coordinated advanced modeling environments for a Domain-Specific (modeling) Languages (DSLs) is a tedious task, which becomes recurrent with the increasing number of DSLs involved in the development and management of complex software-intensive systems.
The GEMOC Studio is an output of multiple projects and research contracts with industry and academia related to the globalization of modeling languages. The GEMOC Studio is sustained as a research platform under the umbrella of the Eclipse Research Consortium GEMOC, to support further developments, experimentations, demonstrators, and pilot projects.
The scope of the Eclipse GEMOC Studio project is to provide generic components through Eclipse technologies for the development, integration, and use of heterogeneous executable modeling languages. This includes, among others:
- metaprogramming approaches and associated execution engines to design and execute the behavioral semantics of executable modeling languages,
- efficient and domain-specific execution trace services,
- model animation services,
- advanced debugging facilities such as forward and backward debugging (i.e. omniscient debugging), timeline, etc.
- coordination facilities to support concurrent and coordinated execution of heterogeneous models
The project also intends to provide the GEMOC Studio as an Eclipse product, which eases the diffusion of the various technologies aforementioned through an integrated studio that also includes documentation, examples, and tutorials. The GEMOC Studio offers two workbenches (accessible with specific perspectives):
- a Language Workbench: to be used by language designers to build and compose new executable modeling languages,
- a Modeling Workbench: to be used by domain designers to create, execute, and coordinate models conforming to executable modeling languages.
Outside the scope of the project: applications of the framework to a given DSL or any component specific to a given DSL. The only exception will be for DSLs used for demonstration purpose that will be bundled as examples.
The Eclipse GEMOC Studio offers a framework for designing and integrating EMF-based modeling languages. The framework provides a generic interface to plug in different execution engines associated to their specific metalanguages used to define the discrete-event operational semantics, and the behavioral coordination, of DSLs. It also integrates generic runtime services that are shared among the approaches used to implement the execution semantics, such as graphical animation or omniscient debugging.
Based on a common API, GEMOC proposes a framework to integrate any kind of metaprogramming approach used to define discrete-event operational semantics into an execution engine. An engine is developed using the execution framework and is specific to a metaprogramming approach. The project offers different engines implementation. Since a significant part of the logic is common to all execution engines, the framework provides a basic abstract execution engine that can be extended into a concrete engine for any new metaprogramming approach.
Notably, implementing this API allows to use and reuse of generic or user-defined runtime services as add-ons(extensions) that send and receive generic messages to and from the execution engines. For example, the GEMOC framework offers a set of runtime services such as:
- generic debuggers that can be used for any executable DSL and engine.
- efficient execution trace model
- model animation
The frameworks help to regulate interactions needed to support collaboration and work coordination across different system domains. Engines implementations that use the framework are then potentially eligible for coordination, i.e. being able to run a system described using different models optionally expressed in different languages. Such system can then be developed in an independent manner in order to meet the specific needs of domain experts. Yet the expert can see how their work on a particular aspect influences works on other concerns.
The framework and the initial engines are distributed through three technologies (update sites) that build on top of each other:
- the Sirius Animator technology focuses on the core execution framework and model debugging environment. It contains a set of generic runtime services that can be shared among the different execution engines (facilities for debugging, graphical/textual animation, and execution trace management). It also contains a Java-based execution engine.
- the MoCCML / Concurrency focuses on explicit concurrency constraints within execution semantics.
- the BCOoL / Coordination technology focuses on explicit concurrency constraints in between execution semantics.
In addition, the project defines an Eclipse RCP, namely the GEMOC Studio, which provides a ready to use environment for both language designers (using the language workbench) and domain designers (using the modeling workbench).
The GEMOC Studio is built on top of existing Eclipse projects (EMF, Sirius, Xtext, Xtend) and provided as an Eclipse package. It also targets integration with other workbenches hosted in Eclipse or Polarsys, such as Capella.
The initial contribution has dependencies to the following eclipse components which are all available under the Eclipse Public Licence:
- Melange: used to define the DSL behavioral semantics through Xtend aspects over Ecore model (K3 Xtend annotation processor is part of Melange), assembling the various DSL concerns (syntax, semantics) to generate a Java/EMF runtime of the DSL, and ensure the interoperability between the graphical editor and the graphical animator)
- Timesquare: only used for the concurrency concerns in DSL semantics, and the concurrent execution of heterogeneous models.
Some optional runtime extensions requires JavaFX.
As soon as the project is created and the infrastructure is ready.
The project is going to grow thanks to the contribution of new approaches for designing and globalizing DSLs. In particular, new meta-programming approaches are expected as alternatives to define the execution semantics of EMF-based DSLs, and novel approaches are also expected for managing specific relationships between DSLs (synchronization, multi-scale...).
Moreover, future works include any facilities related to the scope of the project, including, but not limited to:
- Deep investigation of the notion of language interface (viewpoint engineering, etc.)
- Formal analysis of model coordination
- Leveraging the execution trace of, possibly heterogeneous, coordinated executable models
- Simulation, model explorer, model checking
- Coordination of discrete and continuous models
- Co-simulation (incl., FMI/FMU)
- Adaptable concurrency model at the language level (Design space exploration, optimizing compilers, code adaptation, code obfuscation)
- Live and collaborative modeling (e.g., for sustainability systems)
- Materials for education