Concrete syntax definition for modeling languages

Model Driven Engineering (MDE) promotes the use of models as primary artefacts of a software development process, as an attempt to handle complexity through abstraction, e.g. to cope with the evolution of execution platforms. MDE follows a stepwise approach, by prescribing to develop abstract models further improved to integrate little by little details relative to the final deployment platforms. Thus, the application of an MDE process results in various models residing at various levels of abstraction. Each one of these models is expressed in a modeling language, in which one may find appropriate concepts for the abstraction level considered. Many advocate to use the right (modeling) language for the right purpose. This means that it is sometimes better approach to use small languages specific to the considered domain and abstraction level, than to use general purpose languages (e.g. UML) when they do not perfectly fit the (modeling) needs. As a matter of fact, an MDE development process, which involves many different domains and abstraction levels, should also involve a large variety of modeling languages. Project managers who want to apply an MDE process need to deal with this language proliferation to such an extent that, in the long run, one may infer that language engineers can become major actors of software development teams. We believe that comprehensive modeling language management facilities may considerably alleviate that MDE drawback. Such facilities may include modeling language definition, extension, adaptation, or composition. To define a (modeling) language, one needs to define its abstract syntax, its semantics, and one or more concrete syntaxes. This thesis focuses on concrete syntax definition for modeling languages, when the abstract syntax is given in the form of a metamodel. We will provide solutions both for textual and graphical concrete syntaxes. Some of our experiences in building textual languages (as MTL, a model transformation language), and graphical languages (as Netsilon, a web-application modeler) has shown that a lot of work was spent in implementing interface using traditional techniques, be it a text processor generated from a compiler compiler specification, or a modeler making use of modern 2D graphical libraries. Indeed, abstract and concrete syntax were implemented in a disconnected way, and it was then necessary to assemble them, which became rapidly clumsy while abstract syntax evolved. We built our solution to concrete syntax definition as companions of the abstract syntax. The definition of concrete syntax we propose here made it possible to build automatic tools able to analyze or synthesize models from/to text, and to create graphical modelers. We will present a metamodel for textual concrete syntax definition to construct constructive reversible grammars. We will also propose a technique for graphical concrete syntax definition following a two-step process: specification and realization. Specification is a restrictive approach in which a metamodel defines a graphical concrete syntax. Both relations with abstract syntax and spatial relationships are expressed by means of constraints. The realization step proposes a way to provide the concrete syntax tree a meaning, by attributing it a graphical appearance, and by expressing possible user interactions. The structure of the document is the following. After introducing in deeper details the problem and the general structure of the solution we propose, we will take a tour of MDE, text and graph grammars. Then, we will present Netsilon as an example of an MDE tool to MDE development, which required both the definition of a graphical and a textual modeling language. The two following sections will present the solutions we propose for textual and graphical concrete syntax definition, respectively. Final remarks and possible improvements, especially regarding reusability in general of MDE meta-artifacts (like metamodels or model transformations), and of concrete syntax in particular, will conclude the document

The TopModL Initiative

International audienceWe believe that there is a very strong need for an environment to support research and experiments on model-driven engineering. Therefore we have started the TopModL project, an open-source initiative, with the goal of building a development community to provide: (1) an executable environment for quick and easy experimentation, (2) a set of source files and a compilation tool chain, (3) a web portal to share artefacts developed by the community. The aim of TopModL is to help the model-engineering research community by providing the quickest path between a research idea and a running prototype. In addition, we also want to identify all the possible contributions, understand how to make it easy to integrate existing components, while maintaining architectural integrity. At the time of writing we have almost completed the bootstrap phase (known as Blackhole), which means that we can model TopModL and generate TopModL with TopModL. Beyond this first phase, it is now of paramount importance to gather the best possible description of the requirements of the community involved in model-driven engineering to further develop TopModL, and also to make sure that we are able to reuse or federate existing efforts or goodwill. This paper is more intended to set up a basis for a constructive discussion than to offer definitive answers and closed solutions

Modeling Modeling Modeling

International audienceModel-driven engineering and model-based approaches have permeated all branches of software engineering to the point that it seems that we are using models, as Molière's Monsieur Jourdain was using prose, without knowing it. At the heart of modeling, there is a relation that we establish to represent something by something else. In this paper we review various definitions of models and relations between them. Then, we define a canonical set of relations that can be used to express various kinds of representation relations and we propose a graphical concrete syntax to represent these relations. We also define a structural definition for this language in the form of a metamodel and a formal interpretation using Prolog. Hence, this paper is a contribution towards a theory of modeling

Metamodel-Aware Textual Concrete Syntax Specification

Metamodeling is raising more and more interest in the field of language engineering. While this approach is now well understood for the definition of abstract syntaxes, the formal definition of concrete syntaxes is still a challenge. Concrete syntaxes are traditionally expressed with rules, conforming to EBNF-like grammars, which can be processed by compiler compilers to generate parsers. Unfortunately, these generated parsers produce concrete syntax trees, leaving a gap with the abstract syntax defined by metamodels. This gap is usually filled by time consuming ad-hoc hand-coding. In this paper we propose a new kind of specification for concrete syntaxes that takes advantage of metamodels to generate tools (such as parsers or text generators) which directly manipulate abstract syntax trees. The principle is to map abstract syntaxes to concrete syntaxes via EBNF-like rules that explain how to render an abstract concept into a given concrete syntax, and how to trigger other rules to handle the properties of the concepts. The major difference with EBNF is that rules may have sub-rules, which can be automatically triggered based on the inheritance hierarchy of the abstract syntax concepts

VETESS : IDM, Test et SysML

Selected paper from the 7-th NEPTUNE WorkshopNational audienceIl apparaît souvent que les processus d'ingénierie système sont en fait décomposés en phases discontinues oùtrop peu d'informations sont partagées entre les différentes équipes, par exemple entre les équipes de design et de tests.Cette faiblesse peut être palliée par l’utilisation de modèles de spécifications qui jouent alors le rôle de référentiel pourl’ensemble des équipes participant au cycle de vie du logiciel. Ce type de modèle est couramment utilisé comme basedans les activités de conception, de vérification, ou encore de test. Le test basé sur les modèles est une approcheoriginale où sont automatiquement générés des cas de test et des scripts de test exécutables à partir d'une spécificationdu système sous test. Cette spécification prend la forme d'un modèle comportemental, permettant ainsi au générateur detests de déterminer, d'une part, quels sont les contextes d'exécution pertinents et, d'autre part, de prédire les effets sur lesystème de ces exécutions. Le but du projet VETESS est de rendre possible cette approche pour valider les systèmesembarqués automobiles. Il s’agit ainsi de mettre en œuvre et d’outiller un processus automatique permettant de dériver,d'un modèle de spécification décrit avec un sous-ensemble du langage de modélisation SysML, des cas de test, et deproduire ensuite les scripts de test correspondants à exécuter sur banc de test automobiles

On Executable Meta-Languages applied to Model Transformations

Domain specific languages for model transformation have recently generated significant interest in the model-driven engineering community. The adopted QVT specification has normalized some scheme of model transformation language; however several different model transformation language paradigms are likely to co-exist in the near future, ranging from imperative to declarative (including hybrid). It remains nevertheless questionable how model transformation specific languages compare to more general purpose languages, in terms of applicability, scalability and robustness. In this paper we report on our specific experience in applying an executable meta-language to the model transformation field

Defining Model Driven Engineering Processes

Abstract. Software engineering techniques made it possible for developers to build larger, and more accurate, reliable, and maintainable software-intensive systems. This was essentially possible by introducing techniques for raising the level of abstraction for describing both the problem and its solution, and by clearly establishing a methodology to define the problem and how to move to its solution. Model Driven Engineering (MDE) targets precisely at organizing such levels of abstraction and methodologies. It encourages developers to use models to describe both the problem and its solution at different levels of abstraction, and provides a framework for methodologists to define what model to use at a given moment (i.e., at a given level of abstraction), and how to lower the level of abstraction by defining the relationship between the participating models. Such an MDE process is supposed to be defined by means of assets and methodologists have the duty to provide such assets. However, it is not yet clear what exactly these assets are, despite the fact that techniques to express them have already been widely studied. This position paper addresses this issue by identifying some of the MDE assets that have to be provided, and shows how they should be defined in order to enable them to participate in different MDE process definitions

Towards an MDA-Oriented UML Profile for Distribution

The era of distributed systems is upon us. Middlewarespecific concerns, and especially the distribution concern, which is the core of any middleware-mediated application, are addressed every day in all sorts of enterprise systems. However, object-oriented UML designs offer a very limited perspective on what exactly is distributed, how exactly the distribution is achieved, and where exactly distributed services are located. In order to answer these questions, the MDA-compliant Enterprise Fondue method proposes a hierarchy of UML profiles as a means for addressing the distribution concern at three different MDA-levels of abstraction. Model transformations are provided to incrementally refine existing design models according to the proposed profiles. For the last phase of the Enterprise Fondue process, code generation for specific middleware infrastructures is supported through the Parallax framework. The CORBA technology is used for illustrating the entire approach on a concrete example. 1