Reusable Textual Notations for Domain-Specific Languages

… of the Second International Workshop on …

International Journal on Software Tools for Technology Transfer, 2010

Domain specific languages (DSLs) are increasingly used today. Coping with complex language definitions, evolving them in a structured way, and ensuring their error freeness are the main challenges of DSL design and implementation. The use of modular language definitions and composition operators are therefore inevitable in the independent development of language components. In this article, we discuss these arising issues by describing a framework for the compositional development of textual DSLs and their supporting tools. We use a redundance-free definition of a readable concrete syntax and a comprehensible abstract syntax as both representations significantly overlap in their structure. For enhancing the usability of the abstract syntax, we added concepts like associations and inheritance to a grammarbased definition in order to build up arbitrary graphs (as known from metamodeling). Two modularity concepts, grammar inheritance and embedding, are discussed. They permit compositional language definition and thus simplify the extension of languages based on already existing ones. We demonstrate that compositional engineering of new languages is a useful concept when project-individual DSLs with appropriate tool support are defined.

For many problem domains domain-specific languages (DSLs) offer users more appropriate notations and abstractions in which to model systems when compared with general purpose programming languages. These benefits can often be amplified if a visual notation is used instead of textual notations. In many problem domains visual notations are preferred by practitioners as they often are the most intuitive representation of a problem. However, the lack of supporting infrastructure for constructing, implementing, and maintaining visual languages in general and domain-specific visual languages (DSVLs) in particular has been an impediment to gaining wider acceptance. This paper describes techniques used in the Moses tool-suite for defining the syntax and semantics of DSVLs, which are very general, yet are built on a few very simple concepts and are therefore easy to apply.

Lecture Notes in Business Information Processing, 2008

Reuse is a key technique for a more efficient development and ensures the quality of the results. In object technology explicit encapsulation, interfaces, and inheritance are well-known principles for independent development that enable combination and reuse of developed artifacts. In this paper we apply modularity concepts for domain specific languages (DSLs) and discuss how they help to design new languages by extending existing ones and composing fragments to new DSLs. We use an extended grammar format with appropriate tool support that avoids redefinition of existing functionalities by introducing language inheritance and embedding as first class artifacts in a DSL definition. Language embedding and inheritance is not only assisted by the parser, but also by the editor, and algorithms based on tree traversal like context checkers, pretty printers, and code generators. We demonstrate that compositional engineering of new languages becomes a useful concept when starting to define project-individual DSLs using appropriate tool support.

Software and Systems Modeling, 2018

Most of current modeling languages are based on graphical diagrams. The concrete graphical syntax of these languages typically is defined informally-by text and diagram examples. Only recently, starting from UML 2.5, a formalism is offered for defining the graphical syntax of UML. This formalism is based on Diagram Definition standard by OMG, where the main emphasis is on enabling diagram interchange between different tools implementing the given language. While this is crucial for standardized languages such as UML, this aspect is not so important for domain-specific languages. In this paper, an approach is offered for a simple direct definition of concrete graphical syntax by means of metamodels. Metamodels are typically used for a language definition, but mainly the MOF-inspired approach via meta-metamodel instantiation is used. We offer an alternative approach based on core metamodel specialization which leads to a more direct and understandable definition staying at the same meta-layer. In addition, our approach permits a natural extension-facility for a graphical editor definition for the given language, which is vital in the world of DSLs. In contrast to most DSL development platforms, which are based on the abstract syntax metamodel of the language and a mapping to graphics, our facility is based directly on the graphical syntax. But we show that in those cases where the relation to the DSL abstract syntax is really required, a mapping from the graphical syntax to abstract syntax can be relatively easily defined by the specialization approach.

Lecture Notes in Computer Science, 2007

An understandable concrete syntax and a comprehensible abstract syntax are two central aspects of defining a modeling language. Both representations of a language significantly overlap in their structure and also information, but may also differ in parts of the information. To avoid discrepancies and problems while handling the language, concrete and abstract syntax need to be consistently defined. This will become an even bigger problem, when domain specific languages will become used to a larger extent. In this paper we present an extended grammar format that avoids redundancy between concrete and abstract syntax by allowing an integrated definition of both for textual modeling languages. For an amendment of the usability of the abstract syntax it furthermore integrates meta-modeling concepts like associations and inheritance into a well-understood grammar-based approach. This forms a sound foundation for an extensible grammar and therefore language definition.

Proceedings of the Second Workshop on Graphical Modeling Language Development - GMLD '13, 2013

Model-Driven Engineering (MDE) encourages the use of graphical modeling tools, which facilitate the development process from modeling to coding. Such tools can be designed using the MDE approach into meta-modeling environments called metaCASE tools. It turned out that current metaCASE tools still require, in most cases, manual programming to build full tool support for the modeling language, especially for users' native methodologies and representational elements and propose limited possibilities in terms of reusability. In this context, we propose MID, a set of meta-models supporting the easy specification of modeling editors by means of reusable components and explain how representational meta-modeling is carried out with it.

SDL 2015: Model-Driven Engineering for Smart Cities

A modelling language usually has an abstract syntax (e.g., expressed with a metamodel) separate from its concrete syntax. The question explored in this paper is: how easy is it to add a textual concrete syntax to an existing language that offers only a concrete graphical syntax? To answer this question, this paper reports on lessons learned during the creation of a textual syntax (supported by an editor and transformation tool) for the Goal-oriented Requirement Language (GRL), which is part of the User Requirements Notation standard. Our experiment shows that although current technologies help create textual modelling languages efficiently with feature-rich editors, there are important conflicts between the reuse of existing metamodels and the usability of the resulting textual syntax that require attention.

Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering

Domain-Specific Modelling Languages (DSLs) allow domain experts to create models using abstractions they are most familiar with. A DSL's syntax is specified in two parts: the abstract syntax defines the language's concepts and their allowed combinations, and the concrete syntax defines how those concepts are presented to the user (typically using a graphical or textual notation). However important concrete syntax is for the usability of the language, current modelling tools offer limited possibilities for defining the mapping between abstract and concrete syntax. Often, the language designer is restricted to defining a single icon representation of each concept, which is then rendered to the user in a (fixed) graphical interface. This paper presents a framework that explicitly models the bi-directional mapping between the abstract and concrete syntax, thereby making these restrictions easy to overcome. It is more flexible and allows, amongst others, for a model to be represented in multiple front-ends, using multiple representation formats, and multiple mappings. Our approach is evaluated with an implementation in our prototype tool, the Modelverse, and by applying it on an example language.

This paper presents a comparison of textual and visual syntax notation of Domain-Specic Language (DSL) programs on the example of DOMMLite DSL . Starting from the denition of DOMMLite meta-model, the prototypes of both textual and graphical editors are implemented using tools of the Eclipse Modeling Project 1 . Initial observations in favor and against both syntax notations are summarized and the impact of the chosen concrete syntax on the team development and version control is analyzed.