Elsevier

Journal of Computer Languages

Volume 51, April 2019, Pages 193-213
Journal of Computer Languages

Leveraging product line engineering for the development of domain-specific metamodeling languages

https://doi.org/10.1016/j.cola.2019.02.006Get rights and content

Highlights

  • We propose a workflow to develop a domain-specific metamodeling language (DSM2L) by software product line engineering (SPLE).

  • To put this idea into practice, the MoDEBiTE metamodeling language is engineered based on the SPLE paradigm.

  • The applicability, usefulness, and validity of MoDEBiTE is presented with an experiment on six case studies, which shows the validity of the proposed workflow.

Abstract

A domain-specific metamodeling language (DSM2L) enables language engineers to define a family of similar metamodel-based languages. In recent years, several DSM2Ls have been developed for various domains, e.g., traceability, variability management, process modeling, and metamodeling feature models. However, there is no consensus on an engineering approach for constructing a DSM2L. To address this problem, we consider a DSM2L as a software product line (SPL), in which the software products are the family of languages. Based on this assumption, we propose a roadmap to develop a DSM2L using an SPL engineering framework. To investigate the pros and cons of the roadmap, the MoDEBiTE metamodeling language is engineered in the domain of bidirectional transformations. In order to validate the proposal of engineering a DSM2L, an experiment with six transformation cases is performed on MoDEBiTE. The results of the experiment show the applicability, usefulness, and validity of MoDEBiTE, demonstrating the validity of the proposal.

Introduction

Domain-specific languages (DSLs) provide more focused syntax and more precise semantics for a particular domain rather than general-purpose languages. A DSL can comprise a family of similar languages, which have a common core with different features [1]. While a DSL may be developed in an ad-hoc manner, it is possible to produce the DSL variants automatically to facilitate reusability. In order to generate the syntax, semantics, and tooling aspects of a family of DSL variants, Zschaler et al. [2] proposed the idea of domain-specific metamodeling language (DSM2L). A DSM2L enables language engineers defining a reusable core with a set of variation points to generate language-specific constructs. The development architecture of a wide range of the DSM2L languages [3], [4], [5], [6], [7] is based on the promotion transformation. Promotion, which is considered in this paper due to its wide use, is a transformation from a model of the DSM2L language to the metamodel of a DSL variant [5].

Developing a DSM2L language faces some issues. Most existing approaches for defining DSM2Ls [2], [3], [8], [9], [10] concentrate on technical aspects of implementing domain-specific metamodeling languages. Moreover, increasing the complexity of problem domains makes DSM2Ls to become complex as well. This fact hinders the analysis, design, and development of DSM2Ls in a systematic manner. To alleviate these issues, we propose to consider a DSM2L language as a software product line (SPL) due to the similar concepts in both paradigms. A product line is an infrastructure consisting of a set of common core assets with well-defined variation points to produce a family of similar applications [11].

This paper presents a roadmap for engineering DSM2L languages based on a mature framework of software product line engineering (SPLE) [11]. The main benefit of the SPLE framework is separation of concerns in constructing the product line (domain engineering) and building DSL variants (application engineering) [11]. The proposed roadmap is applicable to DSM2L development when the metamodeling language is defined based on the promotion architecture. To investigate the pros and cons of the proposal, we use the roadmap to develop MoDEBiTE1 [7], which is a metamodeling language for producing languages specific to the domain of bidirectional transformations (Bx). A bidirectional transformation provides a mechanism to preserve inter-model consistency between two sources of data [12]. We apply the whole life cycle of the proposed roadmap on engineering the MoDEBiTE language, which leads to a feature model, a set of design patterns, a development process, and a testing strategy. To validate that the engineering process proposed by the roadmap works fine for MoDEBiTE, this DSM2L tool is applied on six Bx examples to develop six DSL variants. The results show the applicability, usefulness, and validity of the MoDEBiTE language.

The contribution of this paper targets two groups of engineers: DSM2L developers and Bx designers. For DSM2L developers, this article provides an instructive roadmap to present a systematic way for engineering a metamodeling language. In turn, the Bx designer can find the paper a practical guide to learn how to apply MoDEBiTE for the development of a case-specific bidirectional transformation language.

The rest of the paper is organized as follows. In Section 2, we propose a roadmap for developing DSM2Ls based on the product line engineering framework. Section 3 describes several steps of the roadmap for engineering the MoDEBiTE metamodeling language as an illustrative case. Section 4 investigates the results of applying a systematic methodology of case study research which is focused on evaluating the contributions of the MoDEBiTE product line. In Section 5, the related work is studied. After that, a discussion is provided in Section 6. Finally, the paper is concluded in Section 7.

Section snippets

Proposal: a roadmap for product line engineering of DSM2Ls

This section aims to propose an engineering roadmap for developing domain-specific metamodeling languages. To that end, Section 2.1 provides the needed background on DSM2Ls and product line engineering. Then, in Section 2.2 we propose a roadmap for developing a DSM2L language based on product line engineering.

Engineering the MoDEBiTE language: an illustrative case

MoDEBiTE is a metamodeling language for developing a language family, called EVL+Strace [7], in the domain of bidirectional transformations. A Bidirectional transformation is a mechanism for preserving the consistency between two relevant data sources. EVL+Strace exploits the advantages of the Epsilon validation language (EVL) [20], which provides inter-model constraints and inconsistency resolution. An EVL+Strace language variant should be defined for a particular Bx case, including fixed

Validation

This section validates the proposed roadmap for DSM2Ls on the development of MoDEBiTE to produce the EVL+Strace language family. The validation has been investigated by carrying out an experiment consisting of six Bx examples. Each example is a bidirectional transformation scenario that is considered as an application from the SPL view. In this case, the proposed sub-processes of the MoDEBiTE product line are applied to produce an EVL+Strace language for each transformation scenario. To enhance

Related work

This section reviews the studies that are somehow related to this work. The related work is investigated in four categories, including model-driven development of model transformations, DSL engineering, language product lines, and transformation product lines. It is worth noting that the category of the DSM2L languages has been studied in Section 2.1.2. Moreover, we have already investigated the category of related Bx approaches in detail in our prior study [7].

Discussion

In this section, we investigate our work from two aspects. First, engineering a DSM2L language is discussed based on the processes of the LPL life cycle in Section 6.1. Then, the pros and cons of using SPLE on developing the DSM2L components are investigated in Section 6.2.

Conclusion

The common recurring patterns and variations across families of modeling languages have led to the advent of domain-specific metamodeling languages. However, there is no consensus on an engineering approach for developing a DSM2L. To address this problem, a proposal is presented that considers a DSM2L as a software product line to produce the abstract syntax and semantics of a DSL family. It is therefore possible to develop a DSM2L by means of SPLE techniques. A roadmap is proposed for

References (62)

  • S. Zschaler et al.

    Domain-specific metamodelling languages for software language engineering

    Software Language Engineering: Second International Conference, SLE 2009

    (2010)
  • R.F. Paige et al.

    Rigorous identification and encoding of trace-links in model-driven engineering

    Softw. Syst. Model.

    (2011)
  • A. Demuth et al.

    Cross-layer modeler: a tool for flexible multilevel modeling with consistency checking

    Proceedings of the 19th ACM SIGSOFT Symposium and the 13th European Conference on Foundations of Software Engineering

    (2011)
  • J. Steel et al.

    A transformation workbench for building information models

  • M. Brambilla et al.

    A metamodel transformation framework for the migration of WebML models to MDA

    Proceedings of the 4th International Workshop on Model-Driven Web Engineering, MDWE@MoDELS 2008, Tolouse, France, September 30, 2008.

    (2008)
  • S. Jablonski et al.

    A meta modeling framework for domain specific process management

    Proceedings of the 2008 32Nd Annual IEEE International Computer Software and Applications Conference

    (2008)
  • N. Drivalos et al.

    Engineering a DSL for software traceability

    Software Language Engineering: First International Conference, SLE 2008

    (2009)
  • S. Zschaler et al.

    Vml* – a family of languages for variability management in software product lines

  • K. Pohl et al.

    Software Product Line Engineering: Foundations, Principles and Techniques

    (2005)
  • K. Czarnecki et al.

    Bidirectional transformations: across-discipline perspective

    Theory and Practice of Model Transformations

    (2009)
  • J. de Lara et al.

    Model-driven engineering with domain-specific meta-modelling languages

    Softw. Syst. Model.

    (2015)
  • P. Langer et al.

    From UML profiles to EMF profiles and beyond

  • J. de Lara et al.

    Domain-specific textual meta-modelling languages for model driven engineering

  • D.S. Kolovos

    Editing EMF models with Exeed

    Technical Report

    (2007)
  • A. Kleppe

    A language description is more than a metamodel

    Fourth International Workshop on Software Language Engineering

    (2007)
  • C. Atkinson et al.

    A flexible infrastructure for multilevel language engineering

    IEEE Trans. Softw. Eng.

    (2009)
  • D. Kolovos et al.

    On the evolution of OCL for capturing structural constraints in modelling languages

    Rigorous Methods for Software Construction and Analysis

    (2009)
  • E. Guerra et al.

    Engineering model transformations with transML

    Softw. Syst. Model.

    (2013)
  • K.C. Kang et al.

    Feature-oriented domain analysis (FODA) feasibility study

    Technical Report

    (1990)
  • K. Czarnecki et al.

    Formalizing cardinality-based feature models and their specialization

    Softw. Process

    (2005)
  • A.S. Karataş et al.

    Attribute-based variability in feature models

    Requirements Eng.

    (2016)
  • Cited by (6)

    • Context-sensitive parsing for programming languages

      2022, Journal of Computer Languages
      Citation Excerpt :

      Some of these parsing algorithms have been discovered in the mid 60s and their many variations are still used in modern compilers. Although different in regard to their use, the domain-specific languages are defined, modeled and implemented using CFGs as well [3–5]. These reasons make a CFG one of the most widely used formalisms, even if hidden somewhere deep in a compiler.

    • Multi-level production process modeling language

      2021, Journal of Computer Languages
      Citation Excerpt :

      To create cardinality-based feature models we used a plug-in for Eclipse named Yet Another Feature Modeling Tool (YAFMT) [36]. This tool was also used by Samimi-Dehkordi et al. [37] when they analyzed a domain for the Model-Driven Engineering of Bidirectional Transformations via Epsilon (MoDEBiTE) language. The only difference in the syntax of FODA models that we encountered is when specifying a group of features, a square is used instead of a circle at the end of relations.

    • Prioritization based Taxonomy of Cloud-based Outsource Software Development Challenges: Fuzzy AHP analysis

      2020, Applied Soft Computing Journal
      Citation Excerpt :

      Similarly, Nakamaru et al. [3] presented a tool titled Silverchain to generate embedded domain specific languages for a BNF-style grammar. Furthermore, Samimi-Dehkordi et al. [4] proposed a domain-specific metamodeling language using a software product line engineering framework. Similarly, Jafari and Rasoolzadegan [5] conducted a systematic mapping study to explore the research efforts on security patterns and presented a state-of-the-art guidelines for both researchers and practitioners.

    • Code generation using model driven architecture: A systematic mapping study

      2020, Journal of Computer Languages
      Citation Excerpt :

      With regard to the use of models to build Web sites, some methodologies (e.g. [13]) and models (e.g. RMM [14], WebML [15] have a direct impact on this research because they focus on modelling applications at the software level. In [16], the authors propose an interesting approach where they conceive a language that enables engineers to define a family of similar metamodel-based languages (DSM2L) to develop Software product lines (SPLs) as implementations of a MDA. The standard Interaction Flow Modeling Language (IFML)6 is designed for expressing the content, user interaction and control behaviour of the front-end of software applications in general.

    • Systematic Component-Oriented Language Reuse

      2023, Proceedings - 2023 ACM/IEEE International Conference on Model Driven Engineering Languages and Systems Companion, MODELS-C 2023

    This article was originally submitted to the Journal of Visual Languages and Computing, however during the process of review the journal underwent a name change and is now titled Journal of Computer Languages.

    View full text