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

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

Specifying Executable Platform-Independent Models using OCL

Model-driven architecture aims at describing a system using a platform-independent model in sufficient detail so that the full implementation of the system can be generated from this model and a platform model. This implies that the platform-independent model must describe the static structure as well as the dynamic behavior of the system. We propose a declarative language for describing the behavior of platform-independent models based on a hybrid notation that uses graphical elements as well as textual elements in the form of OCL code snippets. Compared to existing approaches based on action languages it is situated at a higher level of abstraction and, through a clean separation of modifier operations and query operations, simplifies the comprehension of the behavioral aspects of the platform-independent system

Surveying navigation modelling approaches

Recently, a number of authors who work on web application modelling have paid attention to the ideas regarding separation of concerns that underlie aspect-orientation, as well as some ideas that come from the model-driven development community. They attempt to improve the representation and separation of some concerns such as customisation or navigational concerns that are scattered throughout different software artifacts and tangled with other concerns in order to give a best support to the evolution of web applications. This paper surveys recent proposals in this field and compares them within a homogeneous framework that bridges the gap between the many different terminologies used, and highlights open problems that need further research.Ministerio de Ciencia y Tecnología TIN2007-64119Ministerio de Ciencia y Tecnología TIN-2007-67843-C06-0

Sitemaps from a model driven perspective: A first step for bridging the gap between information architecture and navigation design

Researchers claim that there is a disconnection between information architecture and navigation design. One way of approaching these two fields is to share deliverables. However, it is difficult to change the minds of audiences to make them use deliverables they are not used to. Thus, we propose let audiences use those deliverables they are more comfortable with, and then transform one deliverable into another, as far as possible. To get this aim, firstly, we need to have a deep knowledge of deliverables, and secondly, a set of mappings have to be defined in order to translate the information the source deliverable is covering into the target deliverable. Our approach uses metamodelling as the technique to define the pieces that compose deliverables and their relationships, and model transformations for mapping deliverables. In this context, the paper focuses on one of the most widely used information architecture deliverables, sitemaps, and its main contributions are: (1) a sitemap metamodel, which define the minimum set of elements that can be used for specifying sitemaps; and, (2) a set of model to model transformations to obtain a XHTML skeleton of structural and utility navigationMinisterio de Ciencia y Tecnología TIN-2007-67843-C06-03Ministerio de Ciencia y Tecnología TIN2007-6411

Meta-environment and executable meta-language using smalltalk: an experience report

Object-oriented modelling languages such as EMOF are often used to specify domain specific meta-models. However, these modelling languages lack the ability to describe behavior or operational semantics. Several approaches have used a subset of Java mixed with OCL as executable meta-languages. In this experience report we show how we use Smalltalk as an executable meta-language in the context of the Moose reengineering environment. We present how we implemented EMOF and its behavioral aspects. Over the last decade we validated this approach through incrementally building a meta-described reengineering environment. Such an approach bridges the gap between a code-oriented view and a meta-model driven one. It avoids the creation of yet another language and reuses the infrastructure and run-time of the underlying implementation language. It offers an uniform way of letting developers focus on their tasks while at the same time allowing them to meta-describe their domain model. The advantage of our approach is that developers use the same tools and environment they use for their regular tasks. Still the approach is not Smalltalk specific but can be applied to language offering an introspective API such as Ruby, Python, CLOS, Java and C

Survey of Template-Based Code Generation

L'automatisation de la génération des artefacts textuels à partir des modèles est une étape critique dans l'Ingénierie Dirigée par les Modèles (IDM). C'est une transformation de modèles utile pour générer le code source, sérialiser les modèles dans de stockages persistents, générer les rapports ou encore la documentation. Parmi les différents paradigmes de transformation de modèle-au-texte, la génération de code basée sur les templates (TBCG) est la plus utilisée en IDM. La TBCG est une technique de génération qui produit du code à partir des spécifications de haut niveau appelées templates. Compte tenu de la diversité des outils et des approches, il est nécessaire de classifier et de comparer les techniques de TBCG existantes afin d'apporter un soutien approprié aux développeurs. L'objectif de ce mémoire est de mieux comprendre les caractéristiques des techniques de TBCG, identifier les tendances dans la recherche, et éxaminer l'importance du rôle de l'IDM par rapport à cette approche. J'évalue également l'expressivité, la performance et la mise à l'échelle des outils associés selon une série de modèles. Je propose une étude systématique de cartographie de la littérature qui décrit une intéressante vue d'ensemble de la TBCG et une étude comparitive des outils de la TBCG pour mieux guider les dévloppeurs dans leur choix. Cette étude montre que les outils basés sur les modèles offrent plus d'expressivité tandis que les outils basés sur le code sont les plus performants. Enfin, Xtend2 offre le meilleur compromis entre l'expressivité et la performance.A critical step in model-driven engineering (MDE) is the automatic synthesis of a textual artifact from models. This is a very useful model transformation to generate application code, to serialize the model in persistent storage, generate documentation or reports. Among the various model-to-text transformation paradigms, Template-Based Code Generation (TBCG) is the most popular in MDE. TBCG is a synthesis technique that produces code from high-level specifications, called templates. It is a popular technique in MDE given that they both emphasize abstraction and automation. Given the diversity of tools and approaches, it is necessary to classify and compare existing TBCG techniques to provide appropriate support to developers. The goal of this thesis is to better understand the characteristics of TBCG techniques, identify research trends, and assess the importance of the role of MDE in this code synthesis approach. We also evaluate the expressiveness, performance and scalability of the associated tools based on a range of models that implement critical patterns. To this end, we conduct a systematic mapping study of the literature that paints an interesting overview of TBCG and a comparative study on TBCG tools to better guide developers in their choices. This study shows that model-based tools offer more expressiveness whereas code-based tools performed much faster. Xtend2 offers the best compromise between the expressiveness and the performance

Model Driven Software Engineering for Web Applications

Model driven software engineering (MDSE) is becoming a widely accepted approach for developing complex applications and it is on its way to be one of the most promising paradigms in software engineering. MDSE advocates the use of models as the key artifacts in all phases of the development process, from analysis to design, implementation and testing. The most promising approach to model driven engineering is the Model Driven Architecture (MDA) defined by the Object Management Group (OMG). Applications are modeled at a platform independent level and are transformed to (possibly several) platform specific implementations. Model driven Web engineering (MDWE) is the application of model driven engineering to the domain of Web application development where it might be particularly helpful because of the continuous evolution of Web technologies and platforms. However, most current approaches for MDWE provide only a partial application of the MDA pattern. Further, metamodels and transformations are not always made explicit and metamodels are often too general or do not contain sufficient information for the automatic code generation. Thus, the main goal of this work is the complete application of the MDA pattern to the Web application domain from analysis to the generated implementation, with transformations playing an important role at every stage of the development process. Explicit metamodels are defined for the platform independent analysis and design and for the platform specific implementation of dynamic Web applications. Explicit transformations allow the automatic generation of executable code for a broad range of technologies. For pursuing this goal, the following approach was chosen. A metamodel is defined for the platform independent analysis and for the design of the content, navigation, process and presentation concerns of Web applications as a conservative extension of the UML (Unified Modeling Language) metamodel, together with a cor-responding UML profile as notation. OCL constraints ensure the well-formedness of models and are checked by transformations. Transformations implement the systematic evolution of analysis and design models. A generic platform for Web applications built on an open-source Web platform and a generic runtime environment is proposed that represents a family of platforms supporting the combination of a broad range of technologies. The transformation to the platform specific models for this generic platform is decomposed along the concerns of Web applications to cope in a fine-grained way with technology changes. For each of the concerns a metamodel for the corresponding technology is defined together with the corresponding transformations from the platform independent design models. The resulting models are serialized to code by means of serialization transformations