MontiCore: Modular Development of Textual Domain Specific Languages (original) (raw)
Related papers
MontiCore: a framework for compositional development of domain specific languages
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.
Supporting Modularization in Textual DSL Development
2010 XXIX International Conference of the Chilean Computer Science Society, 2010
A domain-specific language DSL provides a notation tailored towards an application domain. The closer the language is to their target domain, the more useful the language is for developers. But this increment in the level of specificity raises the issue of duplication of concepts among different languages, and leads to the definition of a family of languages. Despite the advance in tool support for defining the abstract and concrete syntaxes of DSLs, developing a family of DSLs still requires a significant amount of duplicated effort. In this work we present an infrastructure for implementing families of textual DSLs. We introduce a technique based on XText that reduces the effort required to create editors and interpreters by enabling the modularization of the common features and the smooth specification of variability between the DSLs.
Development of Domain-Specific Languages based on Generic Syntax and Functional Composition
2012
Domain-specific languages allow to raise the level of abstraction by using concepts and operations of the domain. Limited applicability of these languages requires lower development costs compared to general-purpose languages. This means that different development techniques need to be used. This work is a contribution to the field of development of domain-specific languages. It analyses the current state of the field. Special attention is given to the analysis of language composition methods and identifying widespread composition techniques. Composition is analyzed not only on the level of grammars, but also on the level of language concepts. The work presents proposed approach for language development based on the standardized generic syntax that serves the role of common substrate for developed languages. The structure of language elements is defined based on principles of functional composition extended with metaprogramming capabilities. The behavior of such language is defined ...
Reusable Textual Notations for Domain-Specific Languages
2019
Domain-specific languages enable concise and precise formalization of domain concepts and promote direct employment by domain experts. Therefore, syntactic constructs are introduced to empower users to associate concepts and relationships with visual textual symbols. Model-based language engineering facilitates the description of concepts and relationships in an abstract manner. However, concrete representations are commonly attached to abstract domain representations, such as annotations in metamodels, or directly encoded into language grammar and thus introduce redundancy betweenmetamodel elements and grammar elements. In this work we propose an approach that enables autonomous development and maintenance of domain concepts and textual language notations in a distinctive and metamodel-agnostic manner by employing style models containing grammar rule templates and injection-based property selection. We provide an implementation and showcase the proposed notationspecification langua...
2020
The introduction of Extensible Markup Language (XML) Schema Definitions (XSDs) represented a tremendous leap towards the design of domain-specific languages (DSLs) by enabling machine processibility of domain models conforming to formally described language grammar, i.e. capturing vocabulary and valid sentences. Consequently, it elevated the need for automating the creation and maintenance of dedicated and modern integrated development environments (IDEs) evading inherent XML limitations, such as rigid angle-bracket syntax, as well as enabling the support of valid domain model construction. Techniques and tools provided by model-driven engineering frameworks and language workbench frameworks offer elementary assistance during the initial implementation of a DSL. These frameworks, however, fail to automate DSL generation due to disparities exposed by the transformation and synthesis of XSDs, language grammars, and metamodels. Moreover, fundamental differences in the nature of languag...
Implementing modular domain specific languages and analyses
Proceedings of the Workshop on Model-Driven Engineering, Verification and Validation - MoDeVVa '12, 2012
Domain specific languages allow users to directly express domain concepts in their programs and thereby eliminate the accidental complexity resulting from implementation details irrelevant to the domain. Cleaner programs, written in DSLs are much easier to analyze formally. However, domain specific analyses need to be implemented over and over again for each new domain specific language. In this paper we show that the use of language engineering techniques for modularizing languages can drastically improve on this situation. Language fragments (aka. language modules) together with a set of analyses defined for them can be reused between different DSLs, making the implementation of analyses significantly easier. This paper presents our approach for using the Meta-Programming System to implement domain specific languages and analyses both as extensions of C and in the domain of intelligent buildings. The main lesson learned is that modularization at language and analysis level allows rapid instantiation of advanced DSLs and their corresponding analyses.
2010
In this paper, we introduce a general framework of language embedding in OO host languages. Unlike other approaches, which embed object language programs as nested calls to functions or data constructors, our framework embeds object language programs as a chain of method invocations. Our framework allows embedding a wider range of object language grammars into an OO host language, while still allowing object language programs to be type checked by the host language compiler and to run efficiently at run time. We demonstrate our framework using ELIA, our extension to Java with automatically constructed parameters (ACPs), and show how we can encode the parser, AST builder, type checker, and interpreter for the simply typed lambda calculus (STLC) in a concrete syntax without redundant brackets or commas. Our framework is only based on the basic OO features, generics, and ACPs, and do not require higher-order functions or generalized abstract data types (GADTS) in the host language. It ...
Composing Visual Syntax for Domain Specific Languages
2009
With the increasing interest in metamodeling techniques for Domain Specific Modeling Languages (DSML) definition, there is a strong need to improve the language modeling process. One of the problems to solve is language evolution. Possible solutions include maximizing the reuse of metamodel patterns, composing them to form new, more expressive DSMLs. In this paper we improve the process of rapid prototyping of DSML graphical editors in meta-modeling tools, by defining composition rules for the graphical syntax layer. The goal is to provide formally defined operators to specify what happens to graphical mappings when their respective metamodels are composed. This improves reuse of Domain Specific Modeling Languages definitions and reduces development time.
A component-based approach for specifying DSML's concrete syntax
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.