Software language engineering in the large: towards composing and deriving languages

https://doi.org/10.1016/j.cl.2018.08.002Get rights and content

Highlights

  • Comprehensive overview of language engineering techniques, challenges, and techniques applied in the field.

  • Addresses major SLE challenges: 1. Designing new DSLs 2. Engineering DSLs from components? 3. Deriving DSLs from other DSLs?

  • Presents a real-world example of language creation, composition, and derivation with the MontiCore language workbench.

  • Describes a comprehensive approach to language derivation using abstract syntax and concrete syntax of the base language.

  • Carefully describes elements of domain-specific transformation languages.

  • Explains systematic application through real-world example using the MontArcTL transformation language.

  • Discusses other approaches to language derivation and future challenges for SLE.

Abstract

Suitable software languages are crucial to tackling the ever-increasing complexity of software engineering processes and software products. They model, specify, and test products, describe processes and interactions with services and serve many other purposes. Meanwhile, engineering suitable modeling languages with useful tooling also has become a challenging endeavor - and far too often, new languages are developed from scratch. We shed light on the advances of modeling language engineering that facilitate reuse, modularity, compositionality, and derivation of new languages based on language components. To this end, we discuss ways to design, combine, and derive modeling languages in all their relevant aspects. We illustrate the application of advanced language engineering throughout the paper, which culminates in the example of deriving complete domain-specific transformations language from existing language components.

Section snippets

Motivation

Using models to understand and shape the world is a very foundational technique that has already been used in ancient Greece and Egypt. Scientists model to comprehend while engineers model to design (parts of) the world. Although modeling has been employed for ages in virtually all disciplines it is fairly recent that the form of models is made explicit in modeling languages. Computer science invented this approach to enable formality and a precise understanding of what is a well-formed model

Language engineering

Model-Driven Development [6], [14], [15] lifts abstract models to primary development artifacts to facilitate software analysis, communication, documentation, and transformation. Automated analysis and transformation of models require that these adhere to contracts. Such automation is feasible, if models conform to contracts in the form of languages specifications. For many popular modeling languages, such as UML [3], AADL [16], or Matlab/Simulink [17], research and industry have produced

Composing modeling languages

Model-Driven Development is successful when initiated bottom-up [56], i.e., developers employ modeling languages considered suitable for their domain-specific challenges instead of using predefined, monolithic general-purpose modeling techniques. For efficient language engineering, evolution, validation, and maintenance, these languages should be retained as independent as possible. Ultimately, however, combining such languages mandates their efficient composition [18]. Considering, for

Deriving modeling languages

Software engineering leverages modeling languages to mechanize working with models of other languages, such as transformation languages [63], [76], delta modeling languages [60], or tagging languages [61]. Such languages have in common that they are either overly generic or are specifically tied to a base language (i.e., the languages whose models are transformed or tagged). The former requires developers to learn completely new languages that are independent of a (possibly well-known) base

Discussion

Research in software language engineering investigates the efficient engineering, deployment, use, and evolution of software languages to support software engineers and domain experts to efficiently model future systems. DSLs foster innovation and efficiency in software engineering. They have become crucial innovation drivers in many disciplines, including Automotive [116], Avionics [16], Civil Engineering [117], Industry 4.0 [118], Robotics [119], and Software Engineering.

Yet, many successful

Conclusion

Ludwig Wittgenstein once postulated that the limits of his language are the limits of his world. Modern programming languages are suitable to describe structure, operations, and data, while general-purpose modeling languages, such as UML, are suitable for specifying structure, architecture, and behavior of software systems. However, both kinds of languages suffer from being designed for software engineers and raise a gap between the problem domains (such as medicine, physics, robotics) and the

References (122)

  • D. Balasubramanian et al.

    A subgraph operator for graph transformation languages

    Electr Commun EASST

    (2007)
  • J. de Lara et al.

    Parallel graph transformation for model simulation applied to timed transition petri nets

    Electr Notes Theor Comput Sci

    (2004)
  • C.J. Date et al.

    A guide to the SQL standard

    (1987)
  • T. Bray et al.

    Extensible markup language (XML)

    World Wide Web J

    (1997)
  • Object Management Group. Unified modeling language (UML), Version 2.5. http://www.omg.org/spec/UML/2.5/PDF/; 2015....
  • B. Rumpe

    Modeling with UML: language, concepts, methods

    (2016)
  • B. Rumpe

    Agile Modeling with UML: code generation, testing, refactoring

    (2017)
  • R. France et al.

    Model-driven development of complex software: a research roadmap

    Fut Softw Eng (FOSE ’07)

    (2007)
  • M. Fowler

    Domain-specific languages

    (2010)
  • P. Hudak

    Domain specific languages

    Handbook of programming languages

    (1997)
  • M. Völter et al.

    DSL engineering - designing, implementing and using domain-specific languages

    (2013)
  • A. van Deursen et al.

    Domain-specific languages: An annotated bibliography

    ACM Sigplan Notices

    (2000)
  • A. Kleppe

    Software language engineering: creating domain-specific languages using metamodels

    (2008)
  • L. Hermerschmidt et al.

    Generating domain-specific transformation languages for component & connector architecture descriptions

    Proceedings of the workshop on model-driven engineering for component-based software systems (ModComp’15)

    (2015)
  • K. Hölldobler et al.

    Advances in modeling language engineering

    Proceedings of the international conference on model and data engineering

    (2017)
  • C. Atkinson et al.

    Model-driven development: a metamodeling foundation

    IEEE Softw

    (2003)
  • B. Selic

    The pragmatics of model-driven development

    IEEE Softw

    (2003)
  • P.H. Feiler et al.

    Model-Based Engineering with AADL: an introduction to the SAE architecture analysis & design language

    (2012)
  • J. Abell

    MATLAB and SIMULINK. Modeling dynamic systems

    (2016)
  • T. Clark et al.

    Conceptual model of the globalization for domain-specific languages

    Globalizing domain-specific languages

    (2015)
  • D. Harel et al.

    Meaningful modeling: what’s the semantics of ”Semantics”?

    IEEE Comput

    (2004)
  • J.-M. Favre et al.

    Empirical language analysis in software linguistics.

    Proceedings of the SLE

    (2010)
  • D.E. Knuth

    Semantics of context-free languages

    Theory Comput Syst

    (1968)
  • P. Klint et al.

    Toward an engineering discipline for grammarware

    ACM Trans Softw Eng Methodol

    (2005)
  • H. Grönniger et al.

    MontiCore: a framework for the development of textual domain specific languages

    Proceedings of the 30th international conference on software engineering (ICSE 2008), Leipzig, Germany, May 10–18, 2008, Companion Volume

    (2008)
  • H. Krahn et al.

    MontiCore: a framework for compositional development of domain specific languages

    Int J Softw Tools Technol Transf (STTT)

    (2010)
  • G.H. Wachsmuth et al.

    Language design with the spoofax language workbench

    IEEE Softw

    (2014)
  • S. Ellner et al.

    The semantics of graphical languages

    PEPM ’07: Proceedings of the 2007 ACM SIGPLAN symposium on partial evaluation and semantics-based program manipulation

    (2007)
  • M. Völter et al.

    Language modularization and composition with projectional language workbenches illustrated with MPS

    Softw Lang Eng

    (2010)
  • H. Grönniger et al.

    Modeling language variability

    Proceedings of the workshop on modeling, development and verification of adaptive systems LNCS 6662

    (2011)
  • M. Richters et al.

    On formalizing the UML object constraint language OCL

    ER

    (1998)
  • J.-M. Jézéquel et al.

    Model driven language engineering with Kermeta

    GTTSE

    (2009)
  • K. Czarnecki

    Generative programming-principles and techniques of software engineering based on automated configuration and fragment-based component models

    (1998)
  • T. Mens et al.

    A taxonomy of model transformation

    Electr Notes Theor Comput Sci

    (2006)
  • S. Erdweg et al.

    Evaluating and comparing language workbenches: existing results and benchmarks for the future

    Comput Lang Syst Struct

    (2015)
  • B. Rumpe et al.

    MontiCore 5 language workbench. Edition 2017. Aachener Informatik-Berichte, Software Engineering Band 32

    (2017)
  • L. Kats et al.

    The Spoofax language workbench

  • D. Steinberg et al.

    EMF: eclipse modeling framework

    (2008)
  • M. Eysholdt et al.

    Xtext: implement your language faster than the quick and dirty way

    Proceedings of the ACM international conference companion on object oriented programming systems languages and applications companion. SPLASH ’10

    (2010)
  • V. Viyović et al.

    Sirius: a rapid development of DSM graphical editor

    Proceedings of the 8th international conference on intelligent engineering systems (INES)

    (2014)
  • Cited by (42)

    • A Cross-Domain Systematic Mapping Study on Software Engineering for Digital Twins

      2022, Journal of Systems and Software
      Citation Excerpt :

      We assume the latter is due to the different perspectives on Digital Twins as (design-time) models, (run-time) systems, or something in-between and the heterogeneous implementation techniques that are employed accordingly. Research on heterogeneous modeling (Lee, 2010) and software language engineering (Kleppe, 2008; Hölldobler et al., 2018) can contribute to closing the gaps between the different technological spaces (Kurtev et al., 2002) and applying established reuse techniques to Digital Twins systematically. To understand how Digital Twins are applied to the different lifecycle phases of their counterparts, we classified the publications accordingly.

    • MontiThings: Model-Driven Development and Deployment of Reliable IoT Applications

      2022, Journal of Systems and Software
      Citation Excerpt :

      Model-driven engineering (MDE) (France and Rumpe, 2007) can mitigate these challenges by lifting more models to primary development artifacts that can abstract from implementation details of the platforms and devices the IoT applications are deployed to and separate concerns into different modeling languages whose models can be integrated and analyzed automatically. To make models machine-processable and, thus, accessible to automated analyses, syntheses, integration, and evolution, these models must conform to explicit modeling languages (Hölldobler et al., 2018), such as UML (Rumpe, 2016), SysML (Friedenthal et al., 2014), or AADL (Feiler and Gluch, 2012). Languages for the model-driven engineering (MDE) of IoT applications provide little abstraction (e.g., Eclipse Mita2) or offer no or only limited mechanisms for handling error situations (e.g., ThingML Morin et al., 2017; Harrand et al., 2016).

    • A Low-Code Platform for Systematic Component-Oriented Language Composition

      2023, SLE 2023 - Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering, Co-located with: SPLASH 2023
    • Seamless Code Generator Synchronization in the Composition of Heterogeneous Modeling Languages

      2023, SLE 2023 - Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering, Co-located with: SPLASH 2023
    • Model-Driven Integration of Analysis Components for Cyber-Physical Production Systems

      2023, Proceedings - 2023 49th Euromicro Conference on Software Engineering and Advanced Applications, SEAA 2023
    View all citing articles on Scopus
    View full text