MontiCore - Language Workbench

Introduction

MontiCore is a language workbench for the efficient development of domain-specific languages. MontiCore is used as a basic vehicle for our ongoing research in the area of model-based software engineering. The MontiCore Language Workbench and Library Handbook [HKR21] features agile and compositional development of domain-specific (modeling) languages (DSLs). These concepts have the potential to greatly impact the software engineering process by enabling easy development of high-quality, custom-tailored languages to express software models. Such models can be analyzed, interpreted, and, in the end, potentially transformed into a running software product.

The MontiCore framework provides necessary application programming interfaces along with a special language definition format based on grammars.

MontiCore has been realized particularly with respect to modularity both concerning the implementation and the development of DSLs. As such, DSLs can be realized in a compositional way, reusing, for example, common language definitions. This allows the creation of language libraries which make it even easier to create the desired DSL. Modularity and compositionality of MontiCore’s language component is based on (1) compositional concrete and abstract syntax, (2) compositional definition of context conditions, (3) clear definition of model interfaces using symbols of various symbol kinds (far beyond any restrictions of programming languages), and (4) compositional analysis and generation infrastructure enabling black-box reuse of algorithms on sub-languages.

Therefore, MontiCore comes with a large library of language components containing various forms of expressions, statements, and literals. A second level of language components defines constituents for modeling languages, such as StateCharts, Class Diagrams, Object Diagrams, Sequence Diagrams, BDDs and IBDs from UML and SysML as well as Feature Diagrams, etc. The library of language components also provides possibilities to specify in first-order logic (i.e., an extension of the OCL), with specific emphasis on sets, physical units (SI units), both as literals and as types including automatic conversions. It provides regular expressions as language elements defining subtypes for strings providing typesafe processing of strings beyond standard programming language capabilities. Each of the provided language components comes with locally defined symbol kinds that can be exported and mapped to symbol kinds of other languages.

MontiCore has successfully been deployed in a variety of industrial and research projects. Among many other general and domain-specific languages, the UML/P family of modeling languages has been realized with MontiCore, and various forms of structured text languages for requirements, norms, and even legal texts were defined.

Based on the facilities the MontiCore Language Workbench provides, automatic derivation of a transformation language for a given modeling language, variability of the languages, adding tagging to a given language, or even smart analysis techniques, such as semantic differences have been constructed and successfully realized. Below we provide a selection of relevant publications about MontiCore and related topics that are based on the MontiCore framework. Please also note the MontiCore Website for technical details as well as access to MontiCore itself.

Agree to play YouTube video "MontiCore"

Videos in this playlist:

  • MontiCore - Allgemeine Informationen (Deutsch)
  • MontiCore - General Information (English)
  • and 20 videos about specific topics in MontiCore’s tooling

MontiCore’s History

MontiCore has been developed since 2004 [GKR+08] [HKR21]. We started its development because at that time the available tools for model management where often very poor in functionality and also not extensible, but closed shops. In 2004 the first version of UML/P was published (and is now available as [Rum16] [Rum17]) demonstrating that the conglomerate of languages - that the UML is made of - can be substantiated with useful transformation, refinement and refactoring techniques (cf. Evolution & Transformation of Models). We were mainly interested in model-based techniques for code and test code generation as well as flexible combination of language fragments, such as OCL within Statechart or class Diagrams for typing in Component and Connector Diagrams. However, hard coded modeling tools where not helpful in realizing these techniques. This original motivation for providing a flexible and adaptable toolset through MontiCore can also be found in the foundational PhD theses of MontiCore [Kra10] [Voe11].

Later, it became apparent that UML will be complemented by several DSLs that will be connected to software development or execution in various ways. The definition of DSLs encounters the same difficulties as the definition of UML has faced, i.e., they are often built from scratch, reuse is difficult or not supported, and the same concepts get different syntactic shapes. Thus, combining DSLs is rather impossible. We therefore extended the focus of MontiCore to become a general language workbench that allows to define languages and language fragments and to derive as much as possible from an integrated, compact definition.

MontiCore provides sophisticated techniques to generate transformation languages and their transformation engines based on DSLs [HRW15], [AHRW17], [RRW15] [HHR+15] [Wei12], we have explored tagging languages [Loo17] [MRRW16] [GLRR15], various forms of the UML and its derivatives [Sch12] [Wor16] [Hab16] [Rei16] [Rot17] and a variety DSLs. Despite MontiCore being an academic tool to explore modeling and meta-modeling techniques, after so years of development, it has reached an extraordinary strength and is thus increasingly used in industrial projects, like energy management [Pin14], as well as in scientific projects of entirely different nature, such as the simulation of urban scenarios for autonomous driving [Ber10] or human brain modeling [PBI+16].

MontiCore, however, does not primarily focus comfort, e.g., graphical editing, but advanced functionality for model-based analysis or synthesis of software intensive systems as well as efficient textual editing for experienced users.

Selected Topic-Specific Publications

  1. [HKR21]
    K. Hölldobler, O. Kautz, B. Rumpe:
    MontiCore Language Workbench and Library Handbook: Edition 2021.
    Aachener Informatik-Berichte, Software Engineering, Band 48, ISBN 978-3-8440-8010-0, Shaker Verlag, May 2021.
  2. [Rot17]
    A. Roth:
    Adaptable Code Generation of Consistent and Customizable Data Centric Applications with MontiDex.
    Aachener Informatik-Berichte, Software Engineering, Band 31, ISBN 978-3-8440-5688-4, Shaker Verlag, Dec. 2017.
  3. [Rum17]
    B. Rumpe:
    Agile Modeling with UML: Code Generation, Testing, Refactoring.
    Springer International, May 2017.
  4. [AHRW17]
    K. Adam, K. Hölldobler, B. Rumpe, A. Wortmann:
    Engineering Robotics Software Architectures with Exchangeable Model Transformations.
    In: International Conference on Robotic Computing (IRC’17), pp. 172-179, IEEE, Apr. 2017.
  5. [Loo17]
    M. Look:
    Modellgetriebene, agile Entwicklung und Evolution mehrbenutzerfähiger Enterprise Applikationen mit MontiEE.
    Aachener Informatik-Berichte, Software Engineering, Band 27, ISBN 978-3-8440-5131-5, Shaker Verlag, Mar. 2017.
  6. [Wor16]
    A. Wortmann:
    An Extensible Component & Connector Architecture Description Infrastructure for Multi-Platform Modeling.
    Aachener Informatik-Berichte, Software Engineering, Band 25, Shaker Verlag, Nov. 2016.
  7. [MRRW16]
    S. Maoz, J. O. Ringert, B. Rumpe, M. v. Wenckstern:
    Consistent Extra-Functional Properties Tagging for Component and Connector Models.
    In: Workshop on Model-Driven Engineering for Component-Based Software Systems (ModComp’16), Volume 1723, pp. 19-24, CEUR Workshop Proceedings, Oct. 2016.
  8. [Hab16]
    A. Haber:
    MontiArc - Architectural Modeling and Simulation of Interactive Distributed Systems.
    Aachener Informatik-Berichte, Software Engineering, Band 24, Shaker Verlag, Sep. 2016.
  9. [Rum16]
    B. Rumpe:
    Modeling with UML: Language, Concepts, Methods.
    Springer International, Jul. 2016.
  10. [Rei16]
    D. Reiß:
    Modellgetriebene generative Entwicklung von Web-Informationssystemen.
    Aachener Informatik-Berichte, Software Engineering, Band 22, ISBN 978-3-8440-4446-1, Shaker Verlag, May 2016.
  11. [PBI+16]
    D. Plotnikov, I. Blundell, T. Ippen, J. M. Eppler, A. Morrison, B. Rumpe:
    NESTML: a modeling language for spiking neurons.
    In: Modellierung 2016 Conference, Volume 254, pp. 93-108, LNI, Bonner Köllen Verlag, Mar. 2016.
  12. [GLRR15]
    T. Greifenberg, M. Look, S. Roidl, B. Rumpe:
    Engineering Tagging Languages for DSLs.
    In: Conference on Model Driven Engineering Languages and Systems (MODELS’15), pp. 34-43, ACM/IEEE, 2015.
  13. [HRW15]
    K. Hölldobler, B. Rumpe, I. Weisemöller:
    Systematically Deriving Domain-Specific Transformation Languages.
    In: Conference on Model Driven Engineering Languages and Systems (MODELS’15), pp. 136-145, ACM/IEEE, 2015.
  14. [HHR+15]
    L. Hermerschmidt, K. Hölldobler, B. Rumpe, A. Wortmann:
    Generating Domain-Specific Transformation Languages for Component & Connector Architecture Descriptions.
    In: Workshop on Model-Driven Engineering for Component-Based Software Systems (ModComp’15), Volume 1463, pp. 18-23, CEUR Workshop Proceedings, 2015.
  15. [RRW15]
    J. O. Ringert, B. Rumpe, A. Wortmann:
    Tailoring the MontiArcAutomaton Component & Connector ADL for Generative Development.
    In: MORSE/VAO Workshop on Model-Driven Robot Software Engineering and View-based Software-Engineering, pp. 41-47, ACM, 2015.
  16. [Pin14]
    C. Pinkernell:
    Energie Navigator: Software-gestützte Optimierung der Energieeffizienz von Gebäuden und technischen Anlagen.
    Aachener Informatik-Berichte, Software Engineering, Band 17, ISBN 978-3-8440-2876-8, Shaker Verlag, 2014.
  17. [Wei12]
    I. Weisemöller:
    Generierung domänenspezifischer Transformationssprachen.
    Aachener Informatik-Berichte, Software Engineering, Band 12, ISBN 978-3-8440-1191-3, Shaker Verlag, 2012.
  18. [Sch12]
    M. Schindler:
    Eine Werkzeuginfrastruktur zur agilen Entwicklung mit der UML/P.
    Aachener Informatik-Berichte, Software Engineering, Band 11, ISBN 978-3-8440-0864-7, Shaker Verlag, 2012.
  19. [Voe11]
    S. Völkel:
    Kompositionale Entwicklung domänenspezifischer Sprachen.
    Aachener Informatik-Berichte, Software Engineering, Band 9, ISBN 978-3-8440-0328-4, Shaker Verlag, 2011.
  20. [Ber10]
    C. Berger:
    Automating Acceptance Tests for Sensor- and Actuator-based Systems on the Example of Autonomous Vehicles.
    Aachener Informatik-Berichte, Software Engineering, Band 6, ISBN 978-3-8322-9378-9, Shaker Verlag, 2010.
  21. [Kra10]
    H. Krahn:
    MontiCore: Agile Entwicklung von domänenspezifischen Sprachen im Software-Engineering.
    Aachener Informatik-Berichte, Software Engineering, Band 1, ISBN 978-3-8322-8948-5, Shaker Verlag, März. 2010.
  22. [GKR+08]
    H. Grönniger, H. Krahn, B. Rumpe, M. Schindler, S. Völkel:
    MontiCore: A Framework for the Development of Textual Domain Specific Languages.
    In: 30th International Conference on Software Engineering (ICSE 2008), Leipzig, Germany, May 10-18, 2008, Companion Volume, pp. 925-926, 2008.