demo_relis.bib

@BOOK{Abouzahra2017,
  author = {Abouzahra, A. and Sabraoui, A. and Afdel, K.},
  publisher = {Ieee},
  title = {A Metamodel Composition Driven Approach to Design New Domain Specific Modeling Languages},
  year = {2017},
  address = {New York},
  series = {2017 European Conference on Electrical Engineering and Computer Science},
  abstract = {Designing a new domain specific modeling language is a complex and consuming task job effort. One solution is to compose existing DSMLs to form a new more complete DSML. Based on a metamodels composition we can improve the process of rapid prototyping of new DSMLs. In this paper we investigate the consequences of composing metamodels of DSMLs on their graphical syntaxes. Our motivation is to upgrade the quick development of graphical comments for a new DSML formed by the composition of multiple DSMLs metamodels. We explain how the DSMLs can be reused to rapidly form new ones with low cost. Thus, this work contributes by defining a set of rules to compose DSMLs and provide a layer for DSMLs graphical syntaxes composition. We propose three rules to compose DSMLs metamodels: reference, specialization and fusion. We have used a small use case to illustrate the approach. For each defined rule we apply it to the use case to exemplify it. We expose, throughout these examples, how graphical syntaxes can be reused. We also show on how graphical comments can be composed.},
  doi = {10.1109/eecs.2017.30},
  paper = {https://dx.doi.org/10.1109/eecs.2017.30}
}
@ARTICLE{Abouzahra2018,
  author = {Abouzahra, Anas and Sabraoui, Ayoub and Afdel, Karim},
  journal = {Advances in Science, Technology and Engineering Systems Journal3},
  title = {A Practical Approach for Extending DSMLs by Composing their Meta -models},
  year = {2018},
  volume = {6}
}
@MISC{Adam2016,
  author = {Adam, Kai and Butting, Arvid and Heim, Robert and Kautz, Oliver and Rumpe, Bernhard and Wortmann, Andreas},
  title = {Model-driven separation of concerns for service robotics},
  year = {2016},
  doi = {10.1145/3023147.3023151},
  paper = {https://dx.doi.org/10.1145/3023147.3023151}
}
@ARTICLE{Ahmad2020,
  author = {Ahmad, Muhammad Waqas and Anwar, Muhammad Waseem and Azam, Farooque and Rasheed, Yawar and Ghani, Usman and Ahmad, Mukhtar},
  journal = {Lecture Notes in Computer Science},
  title = {AutoNet: Meta-model for Seamless Integration of Timed Automata and Colored Petri Nets},
  year = {2020},
  pages = {307--319},
  volume = {12133},
  doi = {10.1007/978-3-030-47679-3\_26},
  paper = {http://dx.doi.org/10.1007/978-3-030-47679-3\_26}
}
@INBOOK{Alexander2007,
  author = {Alexander, Perry},
  pages = {263--276},
  publisher = {Morgan Kaufmann},
  title = {15 - Domain Interactions},
  year = {2007},
  address = {Burlington},
  series = {Systems on Silicon},
  type = {Book Section},
  abstract = {It is noted that the decisions made locally in one domain can have impacts on system-level requirements and other domain specific requirements. Rosetta defines an interaction as a collection of mechanisms for describing how information flows between modeling domains. Each interaction defines three kinds of information transfer. Translators define how information is transformed as it flows through a parameter shared by two facets. Translators handle both information translation and coordination of the communication process. Functors define transformations of facets from one domain to another. Because facets are simply Rosetta values, these transformations take the form of functions whose domain and range include facet types. Furthermore, algebra combinators, or simply combinators define mechanisms for combining two facets to produce a new facet. The primary use for combinator is to provide a capability for composing and refining or abstracting two facets in a single step. Moreover, combinators are like functors, except that the domain of a combinator must include two facets that can be composed into a single facet.}
}
@INPROCEEDINGS{Ali2019,
  author = {Ali, Hyacinth and Mussbacher, Gunter and Kienzle, J{\"{o}}rg},
  booktitle = {22nd {ACM/IEEE} International Conference on Model Driven Engineering Languages and Systems Companion, {MODELS} Companion 2019, Munich, Germany, September 15-20, 2019},
  title = {Towards Modular Combination and Reuse of Languages with Perspectives},
  year = {2019},
  editor = {Burgue{\~{n}}o, Loli and Pretschner, Alexander and Voss, Sebastian and Chaudron, Michel and Kienzle, J{\"{o}}rg and V{\"{o}}lter, Markus and G{\'{e}}rard, S{\'{e}}bastien and Zahedi, Mansooreh and Bousse, Erwan and Rensink, Arend and Polack, Fiona and Engels, Gregor and Kappel, Gerti},
  pages = {387--394},
  publisher = {{IEEE}},
  doi = {10.1109/MODELS-C.2019.00060},
  paper = {https://doi.org/10.1109/MODELS-C.2019.00060}
}
@ARTICLE{Alshayeb2016,
  author = {Alshayeb, Mohammad and Khashan, Nasser and Mahmood, Sajjad},
  journal = {Frontiers Inf. Technol. Electron. Eng.},
  title = {A framework for an integrated unified modeling language},
  year = {2016},
  number = {2},
  pages = {143--159},
  volume = {17},
  doi = {10.1631/FITEE.1500094},
  paper = {https://doi.org/10.1631/FITEE.1500094}
}
@INBOOK{Assmann2013,
  author = {A{\ss}mann, Uwe and Ebert, J\"{u}rgen and Walter, Tobias and Wende, Christian},
  pages = {257--274},
  publisher = {Springer},
  title = {Ontology-Driven Metamodelling for Ontology-Integrated Modelling(*)},
  year = {2013},
  address = {Berlin, Heidelberg},
  type = {Book Section},
  abstract = {In this chapter, we continue the discussion on metamodelling (cf. Chap 7) and on how it can be useful for ontology-integrated modelling (OIM) in the ODSD infrastructure. It shows how an M3 integration bridge (cf. Chap. 8) can be employed to enable ontology-driven metamodelling (ODMM), which is meant to provide a sound base and appropriate tooling to support language engineers in the design phase of ontology-integrated structural modelling languages.}
}
@INCOLLECTION{Badouel2018,
  author = {Badouel, \'{E} and Djeumen Djatcha, R. A.},
  booktitle = {---},
  publisher = {Springer Verlag},
  title = {Modular Design of Domain-Specific Languages Using Splittings of Catamorphisms},
  year = {2018},
  editor = {Fischer, B. and Uustalu, T. and Uustalu, T.},
  pages = {62--79},
  type = {Serial},
  volume = {11187 LNCS},
  abstract = {Language oriented programming is an approach to software composition based on domain specific languages (DSL) dedicated to specific aspects of an application domain. In order to combine such languages we embed them into a host language (namely Haskell, a strongly typed higher-order lazy functional language). A DSL is then given by an algebraic type, whose operators are the constructors of abstract syntax trees. Such a multi-sorted signature is associated to a polynomial functor. An algebra for this functor tells us how to interpret the programs. Using Bekic's Theorem we define a modular decomposition of algebras that leads to a class of parametric multi-sorted signatures, associated with regular functors, allowing for the modular design of DSLs. \copyright 2018, Springer Nature Switzerland AG.},
  doi = {10.1007/978-3-030-02508-3_4},
  paper = {https://dx.doi.org/10.1007/978-3-030-02508-3_4}
}
@BOOK{Balasubramanian2007,
  author = {Balasubramanian, K. and Schmidt, D. C. and Molnar, Z. and Ledeczi, A.},
  publisher = {Ieee Computer Soc},
  title = {Component-based system integration via (Meta)Model composition},
  year = {2007},
  address = {Los Alamitos},
  series = {Ecbs 2007: 14th Annual Ieee International Conference and Workshops on the Engineering of Computer-Based Systems, Proceedings: Raising Expectations of Computer-Bases Systems},
  abstract = {This paper provides three contributions to the study of functional integration of distributed enterprise systems. First, we describe the challenges associated with functionally integrating the software of these systems. Second, we describe how the composition of domain-specific modeling languages (DSMLs) can simplify the functional integration of enterprise distributed systems by enabling the combination of diverse middleware technologies. Third, we demonstrate how composing DSMLs can solve fiunctional integration problems by reverse engineering an existing CORBA Component Model (CCM) system and exposing it as Web Service(s) to web clients who use these services. This paper shows that functional integration done using (meta)model composition provides significant benefits with respect to automation, reusability, and scalability compared to conventional integration processes and methods.}
}
@INBOOK{Balasubramanian2008,
  author = {Balasubramanian, K. and Schmidt, D. C. and Moln\'{a}r, Z. and L\'{e}deczi, A.},
  pages = {474--504},
  publisher = {IGI Global},
  title = {System integration using model-driven engineering},
  year = {2008},
  type = {Book Section},
  abstract = {With the emergence of commercial-off-the-shelf (COTS) component middleware technologies software system integrators are increasing faced with the task of integrating heterogeneous enterprise distributed systems built using different COTS technologies. Although there are well-documented patterns and techniques for system integration using various middleware technologies, system integration is still largely a tedious and error-prone manual process. This chapter provides three contributions to the study of functional integration of distributed enterprise systems. First, we describe the challenges associated with functionally integrating software for these types of systems. Second, we describe how the composition of domain-specific modeling languages (DSMLs) can simplify the functional integration of enterprise distributed systems. Third, we demonstrate how composing DSMLs can solve functional integration problems in an enterprise distributed system case study by reverse engineering an existing CCM system and exposing it as Web service(s) to Web clients who use these services. \copyright 2009, IGI Global.},
  doi = {10.4018/978-1-59904-618-1.ch016},
  paper = {https://dx.doi.org/10.4018/978-1-59904-618-1.ch016}
}
@ARTICLE{Balasubramanian2015,
  author = {Balasubramanian, Daniel and Dubey, Abhishek and Otte, William and Levendovszky, Tihamer and Gokhale, Aniruddha and Kumar, Pranav and Emfinger, William and Karsai, Gabor},
  journal = {Science of Computer Programming},
  title = {DREMS ML: A wide spectrum architecture design language for distributed computing platforms},
  year = {2015},
  pages = {3--29},
  volume = {106},
  abstract = {Complex sensing, processing and control applications running on distributed platforms are difficult to design, develop, analyze, integrate, deploy and operate, especially if resource constraints, fault tolerance and security issues are to be addressed. While technology exists today for engineering distributed, real-time component-based applications, many problems remain unsolved by existing tools. Model-driven development techniques are powerful, but there are very few existing and complete tool chains that offer an end-to-end solution to developers, from design to deployment. There is a need for an integrated model-driven development environment that addresses all phases of application lifecycle including design, development, verification, analysis, integration, deployment, operation and maintenance, with supporting automation in every phase. Arguably, a centerpiece of such a model-driven environment is the modeling language. To that end, this paper presents a wide-spectrum architecture design language called DREMS ML that itself is an integrated collection of individual domain-specific sub-languages. We claim that the language promotes ``correct-by-construction'' software development and integration by supporting each individual phase of the application lifecycle. Using a case study, we demonstrate how the design of DREMS ML impacts the development of embedded systems.},
  doi = {10.1016/j.scico.2015.04.002},
  paper = {https://dx.doi.org/10.1016/j.scico.2015.04.002}
}
@ARTICLE{Barbierato2016,
  author = {Barbierato, Enrico and Gribaudo, Marco and Iacono, Mauro},
  journal = {Electronic Notes in Theoretical Computer Science},
  title = {Modeling Hybrid Systems in SIMTHESys},
  year = {2016},
  pages = {5--25},
  volume = {327},
  abstract = {Hybrid systems (HS) have been proven a valid formalism to study and analyze specific issues in a variety of fields. However, most of the analysis techniques for HS are based on low-level description, where single states of the systems have to be defined and enumerated by the modeler. Some high level modeling formalisms, such as Fluid Stochastic Petri Nets, have been introduced to overcome such difficulties, but simple procedures allowing the definitions of domain specific languages for HS could simplify the analysis of such systems. This paper presents a stochastic HS language consisting of a subset of piecewise deterministic Markov processes, and shows how SIMTHESys \endash a compositional, metamodeling based framework describing and extending formalisms \endash can be used to convert into this paradigm a wide number of high-level HS description languages. A simple example applying the technique to solve a model of the energy consumption of a data-center specified using Queuing Network and Hybrid Petri Nets is presented to show the effectiveness of the proposal.},
  doi = {10.1016/j.entcs.2016.09.021},
  paper = {https://dx.doi.org/10.1016/j.entcs.2016.09.021}
}
@INPROCEEDINGS{Barroca2015,
  author = {Barroca, Bruno and Mustafiz, Sadaf and Mierlo, Simon Van and Vangheluwe, Hans},
  booktitle = {Proceedings of the 8th International Conference on Simulation Tools and Techniques, Athens, Greece, August 24-26, 2015},
  title = {Integrating a neutral action language in a {DEVS} modelling environment},
  year = {2015},
  editor = {Theodoropoulos, Georgios},
  pages = {19--28},
  publisher = {{ICST/ACM}},
  doi = {10.4108/eai.24-8-2015.2260967},
  paper = {https://doi.org/10.4108/eai.24-8-2015.2260967}
}
@ARTICLE{Bart2013,
  author = {Bart, Meyers and Joachim, Denil and Frdric, Boulanger and Ccile, Hardebolle and Christophe, Jacquet and Hans, Vangheluwe},
  journal = {CEUR Workshop Proceedings},
  title = {A DSL for Explicit Semantic Adaptation},
  year = {2013},
  pages = {47--56},
  volume = {1112}
}
@INPROCEEDINGS{Bellstrom2008,
  author = {Bellstr{\"{o}}m, Peter and V{\"{o}}hringer, J{\"{u}}rgen and Kop, Christian},
  booktitle = {Information Systems Development, Towards a Service Provision Society [Proceedings of {ISD} 2008, University of Cyprus, Paphos, Cyprus. August 25-27, 2008]},
  title = {Toward Modeling Language-Independent Integration of Dynamic Schemata},
  year = {2008},
  editor = {Papadopoulos, George Angelos and Wojtkowski, Wita and Wojtkowski, W. Gregory and Wrycza, Stanislaw and Zupancic, Joze},
  pages = {21--29},
  publisher = {Springer},
  doi = {10.1007/b137171\_3},
  paper = {https://doi.org/10.1007/b137171\_3}
}
@INPROCEEDINGS{Berg2013,
  author = {Berg, Henning},
  booktitle = {---},
  title = {Service-Oriented Integration of Metamodels' Behavioural Semantics},
  year = {2013},
  address = {Berlin, Heidelberg},
  pages = {155--170},
  publisher = {Springer},
  series = {Communications in Computer and Information Science},
  abstract = {Metamodel composition is a central operation in model-driven engineering approaches. Composition of metamodels is not trivial. The essence of the problem is that metamodels are not defined as reusable artefacts. Moreover, most composition mechanisms focus on the structural aspects of metamodels without considering how metamodels may be composed semantically. Hence, models of different metamodels can not exchange data directly during execution at runtime. In this paper we investigate a new approach for integrating metamodels and their models by considering metamodels as reusable services at a conceptual level. In particular, the behavioural semantics of metamodels can be coupled in a loosely manner, without entanglement of semantically different concepts. This allows creating complex metamodel architectures where separation of concerns is high.},
  doi = {10.1007/978-3-642-45404-2_11},
  paper = {https://dx.doi.org/10.1007/978-3-642-45404-2_11}
}
@INPROCEEDINGS{Berg2013a,
  author = {Berg, Henning and M\oller-Pedersen, Birger},
  booktitle = {---},
  title = {Type-Safe Symmetric Composition of Metamodels Using Templates},
  year = {2013},
  address = {Berlin, Heidelberg},
  pages = {160--178},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {Composition of models is a key operation in model-driven engineering where it is used for, e.g., elaborating models with additional concepts, acquiring a holistic system view, or making model variants. However, there are few state-of-the-art composition mechanisms that support type-safe symmetric composition of metamodels and their behavioural semantics. This hampers the flexible customisation and reuse of metamodels in model-driven engineering approaches. This paper presents a new mechanism for composing metamodels by defining metamodels as reusable templates. Composition of metamodels is achieved using template instantiations that allow customising the metamodel classes as part of the composition process. The work includes a prototypical metamodel composition tool that supports the ideas presented. The result is an approach for composing metamodels in a type-safe manner, where name conflict resolution, composition of behavioural semantics and reuse of tools are supported.},
  doi = {10.1007/978-3-642-36757-1_10},
  paper = {https://dx.doi.org/10.1007/978-3-642-36757-1_10}
}
@INPROCEEDINGS{Berg2015,
  author = {Berg, Henning and M{\o}ller{-}Pedersen, Birger},
  booktitle = {Model-Driven Engineering and Software Development - Third International Conference, {MODELSWARD} 2015, Angers, France, February 9-11, 2015, Revised Selected Papers},
  title = {Metamodel and Model Composition by Integration of Operational Semantics},
  year = {2015},
  editor = {Desfray, Philippe and Filipe, Joaquim and Hammoudi, Slimane and Pires, Lu{\'{\i}}s Ferreira},
  pages = {172--189},
  publisher = {Springer},
  series = {Communications in Computer and Information Science},
  volume = {580},
  doi = {10.1007/978-3-319-27869-8\_10},
  paper = {https://doi.org/10.1007/978-3-319-27869-8\_10}
}
@PHDTHESIS{Berg2017,
  author = {Berg, Henning},
  school = {University of Oslo, Norway},
  title = {Type-Safe and Conformance-Preserving Composition and Typing of Metamodels with Co-evolution of Models},
  year = {2017},
  paper = {http://hdl.handle.net/10852/55782}
}
@INPROCEEDINGS{Blanc2005,
  author = {Blanc, Xavier and Ramalho, Franklin and Robin, Jacques},
  booktitle = {---},
  title = {Metamodel Reuse with MOF},
  year = {2005},
  address = {Berlin, Heidelberg},
  pages = {661--675},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {As model-driven development promotes metamodels as key assets it raises the issue of their reuse throughout a model-driven product line life cycle. One recurrent reuse need occurs when metamodeling integrated multi-language platforms: one construct from one language is integrated to constructs from other languages by generalizing it, making it more expressive. None of the metamodel assembly facilities provided by MOF and UML (import, merge and combine) or others proposed in previous work adequately addresses this need. We thus propose a new reuse and generalize facility for such purpose.},
  doi = {10.1007/11557432_49},
  paper = {https://dx.doi.org/10.1007/11557432_49}
}
@ARTICLE{Boucke2010,
  author = {Bouck{\'{e}}, Nelis and Weyns, Danny and Holvoet, Tom},
  journal = {J. Syst. Softw.},
  title = {Composition of architectural models: Empirical analysis and language support},
  year = {2010},
  number = {11},
  pages = {2108--2127},
  volume = {83},
  doi = {10.1016/j.jss.2010.06.011},
  paper = {https://doi.org/10.1016/j.jss.2010.06.011}
}
@INPROCEEDINGS{Boulanger2010,
  author = {Boulanger, Fr\'{e}d\'{e}ric and Jacquet, Christophe and Hardebolle, C\'{e}cile and Rouis, Elyes},
  booktitle = {---},
  title = {Modeling Heterogeneous Points of View with ModHel'X},
  year = {2010},
  address = {Berlin, Heidelberg},
  pages = {310--324},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {Non-functional properties (NFPs) concern various characteristics of a system (cost, power, QoS). These characteristics belong to different models of the system, built by different design teams, using different formalisms. Therefore, the design of a system includes a number of domain-specific modeling languages, used to express various NFPs. This paper focuses on the heterogeneity of the points of view on the system. We show that ``multi-view'' approaches which do not rely on a unique underlying model appear better-suited to express NFPs than model weaving or annotations. However, existing approaches in this category do not yet support model execution. We introduce a multi-view extension to ModHel'X, a framework for executing heterogeneous models, and we show how it can be used for modeling non-functional characteristics of a system and expressing NFPs. A key point of this approach is that it relies only on the core concepts of ModHel'X, but uses them in new ways.},
  doi = {10.1007/978-3-642-12261-3_29},
  paper = {https://dx.doi.org/10.1007/978-3-642-12261-3_29}
}
@BOOK{Bousse2016,
  author = {Bousse, E. and Degueule, T. and Vojtisek, D. and Mayerhofer, T. and Deantoni, J. and Combemale, B.},
  publisher = {Assoc Computing Machinery},
  title = {Execution Framework of the GEMOC Studio (Tool Demo)},
  year = {2016},
  address = {New York},
  series = {Proceedings of the 2016 Acm Sigplan International Conference on Software Language Engineering},
  abstract = {The development and evolution of an advanced modeling environment for a Domain-Specific Modeling Language (DSML) is a tedious task, which becomes recurrent with the increasing number of DSMLs involved in the development and management of complex software-intensive systems. Recent efforts in language workbenches result in advanced frameworks that automatically provide syntactic tooling such as advanced comments. However, defining the execution semantics of languages and their tooling remains mostly hand crafted. Similarly to comments that share code completion or syntax highlighting, the development of advanced debuggers, animators, and others execution analysis tools shares common facilities, which should be reused among various DSMLs. In this tool demonstration paper, we present the execution framework offered by the GEMOC studio, an Eclipse-based language and modeling workbench. The framework provides a generic interface to plug in different execution engines associated to their specific metalanguages used to define the discrete-event operational semantics of DSMLs. It also integrates generic runtime services that are shared among the approaches used to implement the execution semantics, such as graphical animation or omniscient debugging.},
  doi = {10.1145/2997364.2997384},
  paper = {https://dx.doi.org/10.1145/2997364.2997384}
}
@INBOOK{Braatz2011,
  author = {Braatz, B. and Brandt, C.},
  pages = {82--101},
  publisher = {Springer-Verlag Berlin},
  title = {Domain-Specific Modelling Languages with Algebraic Graph Transformations on RDF},
  year = {2011},
  address = {Berlin},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {6563},
  abstract = {Domain-specific modelling langugages (DSMLs), which are tailored to the requirements of their users, can significantly increase the acceptance of formal (or at least semi-formal) modelling in scenarios where informal drawings and natural language descriptions are predominant today. We show in this paper how the Resource Description Framework (RDF), which is a standard for the fundamental data structures of the Semantic Web, and algebraic graph transformations on these data structures can be used to realise the abstract syntax of such DSMLs. We examine a small DSML for IT infrastructures as an application scenario. From this scenario, we derive distributed modelling, evolution of language definitions, migration of legacy models and integration of modelling languages as key requirements for a DSML framework. RDF and transformation rules are then used to provide a solution, which meets these requirements, where all kinds of modifications-from simple editing steps via model migration to language integration-are realised by the single, uniform formalism of algebraic graph transformation.}
}
@ARTICLE{Braatz2011,
  author = {Braatz, B. and Brandt, C.},
  journal = {Electronic Communications of the EASST},
  title = {Rule-based integration of domain-specific modelling languages},
  year = {2011},
  volume = {42},
  abstract = {Domain-specific modelling languages (DSMLs) can increase the acceptance of (semi-)formal modelling techniques. They allow all stakeholders in an application domain to participate in the modelling process using notations that are close to their understanding of the domain. When several groups of stakeholders are concerned with a certain aspect of the modelled system, the question arises how different DSMLs can be integrated with respect to this aspect. In this paper, we propose rule-based transformations as a means to integrate heterogeneous DSMLs overlapping on dedicated aspects. We illustrate the approach by a running example of a small visual DSML for IT landscapes and a textual DSML for firewall configurations. \copyright Multi-Paradigm Modeling 2010.},
  doi = {10.14279/tuj.eceasst.42.620.635},
  paper = {https://dx.doi.org/10.14279/tuj.eceasst.42.620.635}
}
@ARTICLE{Braatz2014,
  author = {Braatz, Benjamin and Brandt, Christoph},
  journal = {Software & Systems Modeling},
  title = {A framework for families of domain-specific modelling languages},
  year = {2014},
  number = {1},
  pages = {109--132},
  volume = {13},
  abstract = {Domain-specific modelling langugages, which are tailored to the requirements of their users, can significantly increase the acceptance of formal (or at least semi-formal) modelling in scenarios where informal diagrams and natural language descriptions are predominant today. We show in this article how the Resource Description Framework (RDF), which is a standard for the fundamental data structures of the Semantic Web, and algebraic graph transformations on these data structures can be used to realise and modify the abstract syntax of models in such domain-specific languages. We examine a small domain-specific modelling language for IT infrastructures\emdashinspired by real-world requirements from a banking environment\emdashas an application scenario. From this scenario, we derive four key requirements for a domain-specific modelling framework: (1) distributed modelling, (2) evolution of language definitions, (3) migration of legacy models and (4) integration of modelling languages. RDF and transformation rules are then used to provide a solution which meets these requirements simultaneously, where all kinds of modifications\emdashfrom simple editing steps via model migration to language integration\emdashare realised in an integrated manner by the single, declarative formalism of algebraic graph transformation.},
  doi = {10.1007/s10270-012-0271-y},
  paper = {https://dx.doi.org/10.1007/s10270-012-0271-y}
}
@INBOOK{Brauer2008,
  author = {Brauer, M. and Demuth, B.},
  pages = {182--193},
  publisher = {Springer-Verlag Berlin},
  title = {Model-level integration of the OCL standard library using a pivot model with generics support},
  year = {2008},
  address = {Berlin},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {5002},
  abstract = {OCL 2.0 specifies a standard library of predefined types and associated operations. A itiodel-level representation of the library is required to reference its elements within the abstract syntax model created by an OCL parser. Existing OCL engines build this model in the implementation code which severely limits reusability, flexibility and maintainability. To address these problems, we show how a common pivot model with explicit support for template types can help to externalize the definition of the standard library and integrate it with instances of arbitrary domain-specific modeling languages. We exemplify the feasibility of our approach with a prototypical implementation for the Dresden OCL2 Toolkit and present a tailored EMF comment for modeling the OCL types and operations. We limit our discussion to the model level, i.e., we do not consider an implementation of the standard library for ail execution engine.}
}
@INPROCEEDINGS{Broman2019,
  author = {Broman, D.},
  booktitle = {---},
  title = {A vision of miking: Interactive programmatic modeling, sound language composition, and self-learning compilation},
  year = {2019},
  editor = {Nierstrasz, O. and Gray, J. and Oliveira, B. C. d S.},
  pages = {55--60},
  publisher = {Association for Computing Machinery, Inc},
  abstract = {This paper introduces a vision of Miking, a language framework for constructing efficient and sound language environments and compilers for domain-specific modeling languages. In particular, this language framework has three key objectives: (i) to automatically generate interactive programmatic modeling environments, (ii) to guarantee sound compositions of language fragments that enable both rapid and safe domain-specific language development, (iii) to include first-class support for self-learning compilation, targeting heterogeneous execution platforms. The initiative is motivated in the domain of mathematical modeling languages. Specifically, two different example domains are discussed: (i) modeling, simulation, and verification of cyber-physical systems, and (ii) domain-specific differentiable probabilistic programming. The paper describes the main objectives of the vision, as well as concrete research challenges and research directions. \copyright 2019 Copyright held by the owner/author(s).},
  doi = {10.1145/3357766.3359531},
  paper = {https://dx.doi.org/10.1145/3357766.3359531}
}
@INBOOK{Bryant2015,
  author = {Bryant, B. and Jezequel, J. M. and Laemmel, R. and Mernik, M. and Schindler, M. and Steinmann, F. and Tolvanen, J. P. and Vallecillo, A. and Volter, M.},
  pages = {43--69},
  publisher = {Springer International Publishing Ag},
  title = {Globalized Domain Specific Language Engineering},
  year = {2015},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {9400},
  abstract = {This chapter is dedicated to discussing the engineering aspects involved in the integration of modeling languages, as an essential part of the globalization process. It covers the foundations of language integration, the definition of the relationships between the languages to be integrated, and the various dimensions of language and tool integration. Language variants, evolution, refactoring and retirement are also discussed, as key issues involved in the globalization of modeling languages.},
  doi = {10.1007/978-3-319-26172-0_4},
  paper = {https://dx.doi.org/10.1007/978-3-319-26172-0_4}
}
@MISC{Burden2012,
  author = {Burden, H\aakan and Heldal, Rogardt and Lundqvist, Martin},
  title = {Industrial experiences from multi-paradigmatic modelling of signal processing},
  year = {2012},
  doi = {10.1145/2508443.2508445},
  paper = {https://dx.doi.org/10.1145/2508443.2508445}
}
@ARTICLE{Burger2016,
  author = {Burger, Erik and Henss, J\"{o}rg and K\"{u}ster, Martin and Kruse, Steffen and Happe, Lucia},
  journal = {Software & Systems Modeling},
  title = {View-based model-driven software development with ModelJoin},
  year = {2016},
  number = {2},
  pages = {473--496},
  volume = {15},
  abstract = {Fragmentation of information across instances of different metamodels poses a significant problem for software developers and leads to a major increase in effort of transformation development. Moreover, compositions of metamodels tend to be incomplete, imprecise, and erroneous, making it impossible to present it to users or use it directly as input for applications. Customized views satisfy information needs by focusing on a particular concern, and filtering out information that is not relevant to this concern. For a broad establishment of view-based approaches, an automated solution to deal with separate metamodels and the high complexity of model transformations is necessary. In this paper, we present the ModelJoin approach for the rapid creation of views. Using a human-readable textual DSL, developers can define custom views declaratively without having to write model transformations or define a bridging metamodel. Instead, a metamodel generator and higher-order transformations create annotated target metamodels and the appropriate transformations on-the-fly. The resulting views, which are based on these metamodels, contain joined instances and can effectively express concerns unforseen during metamodel design. We have applied the ModelJoin approach and validated the textual DSL in a case study using the Palladio Component Model.},
  doi = {10.1007/s10270-014-0413-5},
  paper = {https://dx.doi.org/10.1007/s10270-014-0413-5}
}
@ARTICLE{Burmester2004,
  author = {Burmester, Sven and Giese, Holger and Niere, J{\"{o}}rg and Tichy, Matthias and Wadsack, J{\"{o}}rg P. and Wagner, Robert and Wendehals, Lothar and Z{\"{u}}ndorf, Albert},
  journal = {Int. J. Softw. Tools Technol. Transf.},
  title = {Tool integration at the meta-model level: the Fujaba approach},
  year = {2004},
  number = {3},
  pages = {203--218},
  volume = {6},
  doi = {10.1007/s10009-004-0155-8},
  paper = {https://doi.org/10.1007/s10009-004-0155-8}
}
@INPROCEEDINGS{Bussenot2018,
  author = {Bussenot, R. and Leblanc, H. and Percebois, C.},
  booktitle = {---},
  title = {Orchestration of domain specific test languages with a behavior driven development approach},
  year = {2018},
  pages = {431--437},
  publisher = {Institute of Electrical and Electronics Engineers Inc.},
  abstract = {An airplane is composed by many complexes and embedded systems. During the integration testing phase, the design office produces requirements of the targeted system, and the test center produces concrete test procedures to be executed on a test bench. In this context, integration tests are mostly written in natural language and manually executed step by step by a tester. In order to formalize integration tests procedures dedicated to each system with domain specific languages approved by testers, and in order to automatize integration tests, we have introduced agile practices in the integration testing phase. We have chosen a Behavior Driven Development (BDD) approach to orchestrate Domain Specific Test Languages produced for the ACOVAS FUI project. \copyright 2018 IEEE.},
  doi = {10.1109/SYSOSE.2018.8428788},
  paper = {https://dx.doi.org/10.1109/SYSOSE.2018.8428788}
}
@INPROCEEDINGS{Butting2016,
  author = {Butting, A. and Rumpe, B. and Wortmann, A.},
  booktitle = {---},
  title = {Embedding component behavior DSLs into the MontiArcAutomaton ADL},
  year = {2016},
  editor = {Syriani, E. and Gray, J. and Deantoni, J.},
  pages = {8--17},
  publisher = {CEUR-WS},
  volume = {1731},
  abstract = {Component & connector architecture description languages often need to capture application-specific or company-specific requirements. Therefore, it is a crucial prerequisite for their successful application to adapt the ADLs by customizing the languages themselves. Pervasive modeling with tailored ADLs can benefit from integration of DSLs to model-specific forms of component behavior. This requires expertise of the underlying language integration mechanisms. Current research in integrating heterogeneous component behavior DSLs into an ADL focuses on integration of specific kinds of DSLs or is restricted to syntactic integration. However, language integrators can be liberated from requiring in-depth language integration expertise using appropriate abstractions. To this effect, we present a compact DSL for the integration of behavior DSLs into a component & connector ADL that guides and facilitates this form of language integration. Modeling the embedding of behavior DSLs into ADLs facilitates their composition and ultimately the pervasive modeling of complex architectures.}
}
@ARTICLE{Butting2019,
  author = {Butting, Arvid and Eikermann, Robert and Kautz, Oliver and Rumpe, Bernhard and Wortmann, Andreas},
  journal = {Journal of Systems and Software},
  title = {Systematic composition of independent language features},
  year = {2019},
  note = {Publisher: Elsevier},
  pages = {50--69},
  volume = {152}
}
@ARTICLE{Butting2020,
  author = {Butting, Arvid and Pfeiffer, Jerome and Rumpe, Bernhard and Wortmann, Andreas},
  journal = {Models '20},
  title = {A Compositional Framework for Systematic Modeling Language Reuse},
  year = {2020},
  pages = {35\endash46},
  abstract = {Many engineering domains started using generic modeling languages, such as SysML, to describe or prescribe the systems under development. This raises a gap between the generic modeling languages and the domains of experience of the engineers using these. Engineering truly domain-specific languages (DSLs) for experts of these domains still is too challenging for their wide-spread adoption. One major obstacle, the inability to reuse multi-dimensional (encapsulating constituents of syntax and semantics) language components in a black-box fashion, prevents the effective engineering of novel DSLs. To facilitate engineering DSLs, we devised a concept of 3D components for textual, external, and translational DSLs that relies on systematic reuse through systematic closed and open variability in which DSL syntaxes can be embedded, well-formedness rules joined, and code generators integrated in a black-box fashion. We present this concept, a method for its systematic application, an integrated collection of modeling languages supporting systematic language reuse, and an extensible framework that leverages these languages to derive novel DSLs from language product lines. These can greatly mitigate many of the challenges in DSL reuse and, hence, can advance the engineering of truly domain-specific modeling languages.},
  doi = {10.1145/3365438.3410934},
  paper = {http://dx.doi.org/10.1145/3365438.3410934}
}
@INBOOK{Caetano2015,
  author = {Caetano, A. and Antunes, G. and Bakhshandeh, M. and Borbinha, J. and da Silva, M. M.},
  pages = {1--8},
  publisher = {Ieee},
  title = {Analysis of Federated Business Models An Application to the Business Model Canvas, ArchiMate, and e3value},
  year = {2015},
  address = {New York},
  series = {Conference on Business Informatics},
  type = {Book Section},
  abstract = {Enterprise models contribute to the understanding, communication and analysis of how business processes are performed, the goals they achieve, the information they use, as well as the applications that support the business, and the underlying technological infrastructure. The analysis of these different domains requires combining different enterprise models, often described with different domain specific modelling languages. This paper explores the application of computational semantic techniques to specify, integrate and analyse multiple enterprise models. The models are individually specified and federated using ontological schemas, and analysed using computational inference and graph analsys. The paper describes (1) how to specify enterprise models as ontological schemas, (2) how to integrate the ontological schemas using transformation maps, and (3) how to analyse the integrated models. This solution is demonstrated through the specification, integration and analysis of a business model landscape comprising three enterprise modelling languages: the Business Model Canvas, e3value, and ArchiMate.},
  doi = {10.1109/cbi.2015.48},
  paper = {https://dx.doi.org/10.1109/cbi.2015.48}
}
@INPROCEEDINGS{Campos2013,
  author = {Campos, E. and Freire, M. and Kulesza, U. and Bezerra, A. and Aranha, E.},
  booktitle = {---},
  title = {Composition of domain specific modeling languages: An exploratory study},
  year = {2013},
  pages = {149--156},
  abstract = {This paper presents an exploratory study in the context of composition of domain-specific modeling languages (DSMLs). It aims evaluating a composition method using Ecore-based DSMLs based on xText tool. The study was performed applying the method to modelling a composition of DSMLs from the domain of controlled experiments in software engineering. The study consists of four different DSMLs, whose ultimate goal is to generate executable workflows for each experiment subject. The study results present: (i) new adaptations that can be incorporated into the method in order to enable its application to the xText context; and (ii) a brief comparison of the method application using xText and XML based approaches.}
}
@INBOOK{Campos2014,
  author = {Campos, E. and Kulesza, U. and Freire, M. and Aranha, E.},
  pages = {178--193},
  publisher = {Springer-Verlag Berlin},
  title = {A Generative Development Method with Multiple Domain-Specific Languages},
  year = {2014},
  address = {Berlin},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {8892},
  abstract = {This paper investigates approaches proposed in the literature to compose domain-specific languages (DSLs) and mechanisms to integrate DSLs with feature models (FMs) in product line engineering. We propose a method for the development of generative approaches based on existing related work, which provides guidelines for the systematic development of DSL composition integrated with FMs during domain and application engineering. The proposed method is evaluated through an exploratory study of development of a generative approach for the experimental software engineering domain.}
}
@INPROCEEDINGS{Cazzola2012,
  author = {Cazzola, Walter},
  booktitle = {---},
  title = {Domain-Specific Languages in Few Steps},
  year = {2012},
  address = {Berlin, Heidelberg},
  pages = {162--177},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {Often an ad hoc programming language integrating features from different programming languages and paradigms represents the best choice to express a concise and clean solution to a problem. But, developing a programming language is not an easy task and this often discourages from developing your problem-oriented or domain-specific language. To foster DSL development and to favor clean and concise problem-oriented solutions we developed Neverlang The Neverlang framework provides a mechanism to build custom programming languages up from features coming from different languages. The composability and flexibility provided by Neverlang permit to develop a new programming language by simply composing features from previously developed languages and reusing the corresponding support code (parsers, code generators, ?).In this work, we explore the Neverlang framework and try out its benefits in a case study that merges functional programming \`{a} la Python with coordination for distributed programming as in Linda.},
  doi = {10.1007/978-3-642-30564-1_11},
  paper = {https://dx.doi.org/10.1007/978-3-642-30564-1_11}
}
@INPROCEEDINGS{Cazzola2012,
  author = {Cazzola, Walter},
  booktitle = {Software Composition - 11th International Conference, {SC} 2012, Prague, Czech Republic, May 31 - June 1, 2012. Proceedings},
  title = {Domain-Specific Languages in Few Steps - The Neverlang Approach},
  year = {2012},
  editor = {Gschwind, Thomas and Paoli, Flavio De and Gruhn, Volker and Book, Matthias},
  pages = {162--177},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  volume = {7306},
  doi = {10.1007/978-3-642-30564-1\_11},
  paper = {https://doi.org/10.1007/978-3-642-30564-1\_11}
}
@ARTICLE{Chabibi2019,
  author = {Chabibi, B. and Nassar, M. and Anwar, A.},
  journal = {Journal of Computing Science and Engineering},
  title = {SimulML: A DSML for simulating SysML models},
  year = {2019},
  number = {1},
  pages = {17--31},
  volume = {13},
  abstract = {SysML language offers strong capabilities to specify, analyze and design complex systems. However, the operational semantics of the diagrams is not precisely defined, which affects the implementation of SysML models. Furthermore, the SysML models are insufficient for system verification addressing various stakeholders' requirements. This aspect is managed by the simulation process. As system modeling and simulation analysis are used during the system development process, its efficiency is considerably reduced. This study integrates SysML modeling and simulation, through a defined intermediate domain-specific language, namely Simulation Modeling Language, which is intended to link SysML and simulation environments. The defined intermediate modeling language permits modeling complex systems via specification of its syntax and semantics, using simulation principles and constructs, in addition to bridging the gap between SysML models and different simulation environments. Utilizing the defined intermediate language, the proposed integration approach is facilitated by the potential and strength of both SysML modeling and simulation. Moreover, this integration approach is based on the concepts of Model-Driven Engineering ensuring an efficient passage between different models. \copyright 2019. The Korean Institute of Information Scientists and Engineers.},
  doi = {10.5626/JCSE.2019.13.1.17},
  paper = {https://dx.doi.org/10.5626/JCSE.2019.13.1.17}
}
@ARTICLE{Chanti2014,
  author = {Chanti, H. and Thiry, L. and Hassenforder, M. and Brillhac, J. F. and Fromy, P.},
  journal = {IFAC Proceedings Volumes},
  title = {Formalization and composition of languages for the modeling of fire safety systems},
  year = {2014},
  number = {3},
  pages = {1625--1630},
  volume = {47},
  abstract = {Modeling complex systems, such as the ones found in the certification of fire protection systems, generally requires the intervention of many specialists, each one using its own formalisms, concepts and tools. To model such systems, many specific languages are required and to be integrated they should be formally described. In this proposal, we suggest to use functional programming concepts to formalize and integrate the languages involved in the field of fire safety systems. Formalization is done by specifying constructor functions and integration by the way of generic/higher-order functions.},
  doi = {10.3182/20140824-6-ZA-1003.01900},
  paper = {https://dx.doi.org/10.3182/20140824-6-ZA-1003.01900}
}
@INPROCEEDINGS{Chen2007,
  author = {Chen, K. and Sztipanovits, J. and Neema, S.},
  booktitle = {2007 Design, Automation & Test in Europe Conference & Exhibition},
  title = {Compositional Specification of Behavioral Semantics},
  year = {2007},
  pages = {1--6},
  abstract = {An emerging common trend in model-based design of embedded software and systems is the adoption of domain-specific modeling languages (DSMLs). While abstract syntax metamodeling enables the rapid and inexpensive development of DSMLs, the specification of DSML semantics is still a hard problem. In previous work, we have developed methods and tools for the semantic anchoring of DSMLs. Semantic anchoring introduces a set of reusable "semantic units" that provide reference semantics for basic behavioral categories using the abstract state machine (ASM) framework. In this paper, we extend the semantic anchoring framework to heterogeneous behaviors by developing a method for the composition of semantic units. Semantic unit composition reduces the required effort from DSML designers and improves the quality of the specification. The proposed method is demonstrated through a case study},
  doi = {10.1109/DATE.2007.364408},
  paper = {https://dx.doi.org/10.1109/DATE.2007.364408}
}
@ARTICLE{Clark2015,
  author = {Clark, Tony},
  journal = {Science of Computer Programming},
  title = {XPL: A language for modular homogeneous language embedding},
  year = {2015},
  pages = {589--616},
  volume = {98},
  abstract = {Languages that are used for Software Language Engineering (SLE) offer a range of features that support the construction and deployment of new languages. SLE languages offer features for constructing and processing syntax and defining the semantics of language features. New languages may be embedded within an existing language (internal) or may be stand-alone (external). Modularity is a desirable SLE property for which there is no generally agreed approach. This article analyses the current tools for SLE and identifies the key features that are common. It then proposes a language called XPL that supports these features. XPL is higher-order and allows languages to be constructed and manipulated as first-class elements and therefore can be used to represent a range of approaches to modular language definition. This is validated by using XPL to define the notion of a language module that supports modular language construction and language transformation.},
  doi = {10.1016/j.scico.2014.08.005},
  paper = {https://dx.doi.org/10.1016/j.scico.2014.08.005}
}
@INBOOK{Clark2015,
  author = {Clark, T. and van den Brand, M. and Combemale, B. and Rumpe, B.},
  pages = {7--20},
  publisher = {Springer Int Publishing Ag},
  title = {Conceptual Model of the Globalization for Domain-Specific Languages},
  year = {2015},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {9400},
  abstract = {Domain Specific Languages (DSL) have received some prominence recently. Designing a DSL and all their tools is still cumbersome and lots of work. Engineering of DSLs is still at infancy, not even the terms have been coined and agreed on. In particular globalization and all its consequences need to be precisely defined and discussed. This chapter provides a definition of the relevant terms and relates them, such that a conceptual model emerges. The authors think that this clarification of terms and the meaning will foster the field of efficient DSL definition and evolution in the future.},
  doi = {10.1007/978-3-319-26172-0_2},
  paper = {https://dx.doi.org/10.1007/978-3-319-26172-0_2}
}
@ARTICLE{Clasen2011,
  author = {Clasen, Cau and Jouault, Frdric and Cabot, Jordi},
  journal = {---},
  title = {VirtualEMF: a model virtualization tool},
  year = {2011},
  pages = {332--335}
}
@INPROCEEDINGS{Cledou2017,
  author = {Cledou, Guillermina and Proen\c{c}a, Jos\'{e} and Soares Barbosa, Luis},
  booktitle = {---},
  title = {Composing Families of Timed Automata},
  year = {2017},
  address = {Cham},
  pages = {51--66},
  publisher = {Springer International Publishing},
  series = {Lecture Notes in Computer Science},
  abstract = {Featured Timed Automata (FTA) is a formalism that enables the verification of an entire Software Product Line (SPL), by capturing its behavior in a single model instead of product-by-product. However, it disregards compositional aspects inherent to SPL development. This paper introduces Interface FTA (IFTA), which extends FTA with variable interfaces that restrict the way automata can be composed, and with support for transitions with atomic multiple actions, simplifying the design. To support modular composition, a set of Reo connectors are modelled as IFTA. This separation of concerns increases reusability of functionality across products, and simplifies modelling, maintainability, and extension of SPLs. We show how IFTA can be easily translated into FTA and into networks of Timed Automata supported by UPPAAL. We illustrate this with a case study from the electronic government domain.},
  doi = {10.1007/978-3-319-68972-2_4},
  paper = {https://dx.doi.org/10.1007/978-3-319-68972-2_4}
}
@INPROCEEDINGS{Combemale2013,
  author = {Combemale, Beno\^{i}t and De Antoni, Julien and Larsen, Matias Vara and Mallet, Fr\'{e}d\'{e}ric and Barais, Olivier and Baudry, Benoit and France, Robert B.},
  booktitle = {---},
  title = {Reifying Concurrency for Executable Metamodeling},
  year = {2013},
  address = {Cham},
  pages = {365--384},
  publisher = {Springer International Publishing},
  series = {Lecture Notes in Computer Science},
  abstract = {Current metamodeling techniques can be used to specify the syntax and semantics of domain specific modeling languages (DSMLs). Still, there is little support for explicitly specifying concurrency semantics of DSMLs. Often, such semantics are provided by the implicit concurrency model of the execution environment supported by the language workbench used to implement the DSMLs. The lack of an explicit concurrency model has several drawbacks: it prevents from developing a complete understanding of the DSML's behavioral semantics, as well as effective concurrency-aware analysis techniques, and explicit models of semantic variants. This work reifies concurrency as a metamodeling facility, leveraging formalization work from the concurrency theory and models of computation (MoC) community. The essential contribution of this paper is a language workbench for binding domain-specific concepts and models of computation through an explicit event structure at the metamodel level. We present a case study that serves to demonstrate the utility of the novel metamodeling facilities and clarify the scope of the approach.},
  doi = {10.1007/978-3-319-02654-1_20},
  paper = {https://dx.doi.org/10.1007/978-3-319-02654-1_20}
}
@ARTICLE{Combemale2014,
  author = {Combemale, B. and DeAntoni, J. and Baudry, B. and France, R. B. and J\'{e}z\'{e}quel, J. and Gray, J.},
  journal = {Computer},
  title = {Globalizing Modeling Languages},
  year = {2014},
  number = {6},
  pages = {68--71},
  volume = {47},
  abstract = {In the software and systems modeling community, domain-specific modeling language (DSML) research is focused on providing technologies for developing languages and tools that allow domain experts to develop system solutions efficiently. Unfortunately, it's very difficult for software and systems engineers to reason about information spread across models describing different system aspects because of the current lack of support for explicitly relating concepts expressed in different DSMLs. Here, we describe a research initiative that broadens the DSML research focus beyond independent DSML development to one that supports globalized DSMLs-that is, DSMLs that facilitate coordination of work across different domains of expertise. Coordinating domain-specific modeling languages provides support for language heterogeneity in software-intensive systems' development and runtime management.},
  doi = {10.1109/MC.2014.147},
  paper = {https://dx.doi.org/10.1109/MC.2014.147}
}
@BOOK{Coulon2018,
  author = {Coulon, F. and Degueule, T. and van der Storm, T. and Combemale, B.},
  publisher = {Assoc Computing Machinery},
  title = {Shape-Diverse DSLs: Languages without Borders (Vision Paper)},
  year = {2018},
  address = {New York},
  series = {Proceedings of the 11th Acm Sigplan International Conference on Software Language Engineering},
  abstract = {Domain-Specific Languages (DSLs) manifest themselves in remarkably diverse shapes, ranging from internal DSLs embedded as fluent APIs, to external DSLs with dedicated syntax and tool support. Although different shapes have different pros and cons, combining them for a single language is problematic: language designers usually commit to a particular shape early in the design process, and it is hard to reconsider this choice later. In this new ideas paper, we envision a language engineering approach enabling (i) language users to manipulate language constructs in the most appropriate shape according to the task at hand, and (ii) language designers to combine the strengths of different technologies for a single DSL. We report on early experiments and lessons learned building PRISM, our prototype approach to this problem. We illustrate its applicability in the engineering of a shape-diverse DSL implemented conjointly in Rascal, EMF, and Java. We hope that our initial contribution will raise the awareness of the community and encourage future research.},
  doi = {10.1145/3276604.3276623},
  paper = {https://dx.doi.org/10.1145/3276604.3276623}
}
@ARTICLE{Craciunean2019,
  author = {Craciunean, D. C. and Karagiannis, D.},
  journal = {International Journal of Advanced Computer Science and Applications},
  title = {A Categorical Model of Process Co-Simulation},
  year = {2019},
  number = {3},
  pages = {430--438},
  volume = {10},
  abstract = {A set of dynamic systems in which some entities undergo transformations, or receive certain services in successive phases, can be modeled by processes. The specification of a process consists of a description of the properties of this process as a mathematical object in a suitable modeling language. The language chosen for specifying a process should facilitate the writing of this specification in a very clear and simple form. This raises the need for the use of various types of formalisms that are faithful to the component subsystems of such a system and which are capable of mimicking their varied dynamics. Often in practice, the development of domain specific languages is used to provide building blocks adapted to the processes. Thus, the concept of multi-paradigm modeling arises which involves the combination of different types of models, the decomposition and composition of heterogeneous specified models as well as their simulation. Multi-paradigm modeling presents a variety of challenges such as coupling and transforming the models described in various formalisms, the relationship between models at different levels of abstraction, and the creation of metamodels to facilitate the rapid development of varied formalisms for model specification. The simulation can be seen as a set of state variables that evolve over time. Co-simulation is a synthesis of all simulations of the components of the system, coordinated and synchronized based on interactions between them. The theory of categories provides a framework for organizing and structuring formal systems in which heterogeneous information can be transferred, thus allowing for the building of rigorous cohesion bridges between heterogeneous components. This paper proposes a new model of co-simulation of processes based on the category theory.}
}
@ARTICLE{Cuadrado2009,
  author = {Cuadrado, J. S. and Molina, J. G.},
  journal = {Ieee Transactions on Software Engineering},
  title = {A Model-Based Approach to Families of Embedded Domain-Specific Languages},
  year = {2009},
  number = {6},
  pages = {825--840},
  volume = {35},
  abstract = {With the emergence of model-driven engineering (MDE), the creation of domain-specific languages (DSLs) is becoming a fundamental part of language engineering. The development cost of a DSL should be modest compared to the cost of developing a general-purpose programming language. Reducing the implementation effort and providing reuse techniques are key aspects for DSL approaches to be really effective. In this paper, we present an approach to build embedded domain-specific languages applying the principles of model-driven engineering. On the basis of this approach, we will tackle reuse of DSLs by defining families of DSLs, addressing reuse both from the DSL developer and user point of views. A family of DSLs will be built up by composing several DSLs, so we will propose composition mechanisms for the abstract syntax, concrete syntax, and model transformation levels of a DSL's definition. Finally, we contribute a software framework to support our approach, and we illustrate the paper with a case study to demonstrate its practical applicability.},
  doi = {10.1109/tse.2009.14},
  paper = {https://dx.doi.org/10.1109/tse.2009.14}
}
@INBOOK{Deantoni2015,
  author = {Deantoni, J. and Brun, C. and Caillaud, B. and France, R. B. and Karsai, G. and Nierstrasz, O. and Syriani, E.},
  pages = {70--87},
  publisher = {Springer International Publishing Ag},
  title = {Domain Globalization: Using Languages to Support Technical and Social Coordination},
  year = {2015},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {9400},
  abstract = {When a project is realized in a globalized environment, multiple stakeholders from different organizations work on the same system. Depending on the stakeholders and their organizations, various (possibly overlapping) concerns are raised in the development of the system. In this context a Domain Specific Language (DSL) supports the work of a group of stakeholders who are responsible for addressing a specific set of concerns. This chapter identifies the open challenges arising from the coordination of globalized domain-specific languages. We identify two types of coordination: technical coordination and social coordination. After presenting an overview of the current state of the art, we discuss first the open challenges arising from the composition of multiple DSLs, and then the open challenges associated to the collaboration in a globalized environment.},
  doi = {10.1007/978-3-319-26172-0_5},
  paper = {https://dx.doi.org/10.1007/978-3-319-26172-0_5}
}
@BOOK{Deantoni2016,
  author = {Deantoni, J. and Ieee},
  publisher = {Ieee Computer Soc},
  title = {Modeling the Behavioral Semantics of Heterogeneous Languages and their Coordination},
  year = {2016},
  address = {Los Alamitos},
  series = {2016 Architecture-Centric Virtual Integration},
  abstract = {In the software and system modeling community, research on domain-specific modeling languages (DSMLs) is focused on providing technologies for developing languages and tools that allow domain experts to develop system solutions efficiently. Unfortunately, the current lack of support for explicitly relating concepts expressed in different DSMLs makes it very difficult for software and system engineers to reason about information spread across models describing different system aspects. As a particular challenge, we present in this paper how we dealt with relationships between heterogeneous behavioral models to support their concurrent and coordinated execution. This was achieved by providing dedicated meta-language to define the behavioral semantics of DSMLs and their coordination. The approach made explicit a formal model of the control flow (MoCC); domain-specific actions (DSA) and a well-defined protocol between them (incl., mapping, feedback and callback) reified through explicit domain-specific events (DSE). The protocol is then used to infer a relevant behavioral language interface for specifying coordination patterns to be applied on conforming executable models. As a result, heterogeneous languages and their relationships can be developed in the GEMOC studio, which provides extensive support to run and debug heterogeneous models. This is outlined in the paper on the definition of the Marked Graph language and its coordination with a scenario language.},
  doi = {10.1109/acvi.2016.9},
  paper = {https://dx.doi.org/10.1109/acvi.2016.9}
}
@ARTICLE{DelFabro2005,
  author = {Del Fabro, Marcos Didonet and Bzivin, Jean and Jouault, Frdric and Breton, Erwann and Gueltas, Guillaume},
  journal = {---},
  title = {AMW: a generic model weaver},
  year = {2005},
  pages = {105--114}
}
@INPROCEEDINGS{Denton2008,
  author = {Denton, Trip and Jones, Edward and Srinivasan, Srini and Owens, Ken and Buskens, Richard W.},
  booktitle = {---},
  title = {NAOMI \endash An Experimental Platform for Multi\endashmodeling},
  year = {2008},
  address = {Berlin, Heidelberg},
  pages = {143--157},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {Domain-specific modeling languages (DSMLs) are designed to provide precise abstractions of domain-specific constructs. However, models for complex systems typically do not fit neatly within a single domain and capturing all important aspects of such a system requires developing multiple models using different DSMLs. Combining these models into multi-models presents difficult challenges, most importantly those of integrating the various models and keeping both the models and their associated data synchronized. To this end, we present NAOMI, an experimental platform for enabling multiple models, developed in different DSMLs, to work together. NAOMI analyzes model dependencies to determine the impact of changes to one model on other dependent models and coordinates the propagation of necessary model changes. NAOMI also serves as a useful testbed for exploring how diverse modeling paradigms can be combined.},
  doi = {10.1007/978-3-540-87875-9_10},
  paper = {https://dx.doi.org/10.1007/978-3-540-87875-9_10}
}
@INBOOK{Denton2008,
  author = {Denton, T. and Jones, E. and Srinivasan, S. and Owens, K. and Buskens, R. W.},
  pages = {143--157},
  publisher = {Springer-Verlag Berlin},
  title = {NAOMI - An Experimental Platform for Multi-modeling},
  year = {2008},
  address = {Berlin},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {5301},
  abstract = {Domain-specific modeling languages (DSMLs) are designed to provide precise abstractions of domain-specific constructs. However, models for complex systems typically do not fit neatly within a single domain and capturing all important aspects of such a system requires developing multiple Models using different DSMLs. Combining these models into multi-models presents difficult challenges, most importantly those of integrating the various models and keeping both the models and their associated data synchronized. To this end, we present NAOMI, an experimental platform for enabling multiple models, developed in different DSMLs, to work together. NAOMI analyzes model dependencies to determine the impact of changes to one model on other dependent models and coordinates the propagation of necessary model changes. NAOMI also serves as a useful testbed for exploring how diverse modeling paradigms can be combined.}
}
@INPROCEEDINGS{derStorm2013,
  author = {van der Storm, Tijs and Cook, William R. and Loh, Alex},
  booktitle = {---},
  title = {Object Grammars},
  year = {2013},
  address = {Berlin, Heidelberg},
  pages = {4--23},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {Object Grammars define mappings between text and object graphs. Parsing recognizes syntactic features and creates the corresponding object structure. In the reverse direction, formatting recognizes object graph features and generates an appropriate textual presentation. The key to Object Grammars is the expressive power of the mapping, which decouples the syntactic structure from the graph structure. To handle graphs, Object Grammars support declarative annotations for resolving textual names that refer to arbitrary objects in the graph structure. Predicates on the semantic structure provide additional control over the mapping. Furthermore, Object Grammars are compositional so that languages may be defined in a modular fashion. We have implemented our approach to Object Grammars as one of the foundations of the Enso system and illustrate the utility of our approach by showing how it enables definition and composition of domain-specific languages (DSLs).},
  doi = {10.1007/978-3-642-36089-3_2},
  paper = {https://dx.doi.org/10.1007/978-3-642-36089-3_2}
}
@ARTICLE{derStorm2014,
  author = {van der Storm, T. and Cook, W. R. and Loh, A.},
  journal = {Science of Computer Programming},
  title = {The design and implementation of Object Grammars},
  year = {2014},
  pages = {460--487},
  volume = {96},
  abstract = {An Object Grammar is a variation on traditional BNF grammars, where the notation is extended to support declarative bidirectional mappings between text and object graphs. The two directions for interpreting Object Grammars are parsing and formatting. Parsing transforms text into an object graph by recognizing syntactic features and creating the corresponding object structure. In the reverse direction, formatting recognizes object graph features and generates an appropriate textual presentation. The key to Object Grammars is the expressive power of the mapping, which decouples the syntactic structure from the graph structure. To handle graphs, Object Grammars support declarative annotations for resolving textual names that refer to arbitrary objects in the graph structure. Predicates on the semantic structure provide additional control over the mapping. Furthermore, Object Grammars are compositional so that languages may be defined in a modular fashion. We have implemented our approach to Object Grammars as one of the foundations of the Ens (o) over bar system and illustrate the utility of our approach by showing how it enables definition and composition of domain-specific languages (DSLs). (C) 2014 Elsevier B.V. All rights reserved.},
  doi = {10.1016/j.scico.2014.02.023},
  paper = {https://dx.doi.org/10.1016/j.scico.2014.02.023}
}
@INPROCEEDINGS{Devarajegowda2017,
  author = {Devarajegowda, K. and Schreiner, J. and Findenig, R. and Ecker, W.},
  booktitle = {2017 IEEE/ACM International Conference on Computer-Aided Design (ICCAD)},
  title = {Python based framework for HDSLs with an underlying formal semantics: (Invited paper)},
  year = {2017},
  pages = {1019--1025},
  abstract = {Although Moore's law is slowing down, design productivity is still a big issue in semiconductor industry. Drivers are the trend to 3D integration, the addition of design goals such as ultra-low power and safety, and an increasing number of designs in IoT and automotive areas. EDA tools such as high-level synthesis cover a small design area only. Also, the impact of IP reuse is overestimated since IP integration often requires complex configuration and additional software to be developed. To continuously increase design productivity, Infineon heavily relies on an in-house automation framework that utilizes Python as language for automation and synthesis. It supports (and makes use of) classical HDSLs to describe specific design aspects. Mostly structured specification formalisms such as tables, requirements or diagrams (e.g. SysML subsets) are used. These formalisms can be seen as HDSLs with the additional benefit that they exist as a result of a specification process, i.e. need not be coded explicitly. To be able to deal with several formalisms, Infineon's automation framework follows OMG's MDA vision and utilizes meta-models e.g. for generation of infrastructure code. This work focuses on the aspect of combining DSLs, defining a formal semantic for HDSLs and using this definition to validate the correctness of the mapping of HDSLs to HDLs, an essential pillar to connect HDSLs to today's design flows.},
  doi = {10.1109/ICCAD.2017.8203893},
  paper = {https://dx.doi.org/10.1109/ICCAD.2017.8203893}
}
@INPROCEEDINGS{Dinkelaker2010,
  author = {Dinkelaker, T. and Eichberg, M. and Mezini, M.},
  booktitle = {---},
  title = {An architecture for composing embedded domain-specific languages},
  year = {2010},
  pages = {49--60},
  abstract = {Embedded domain-specific languages (EDSLs) are said to be easier to compose than DSLs that are implemented by preprocessors. However, existing approaches focus on composition scenarios where the use of abstractions from one domain does not affect the interpretation of abstractions from another domain. This leads to programs that exhibit scattering and tangling symptoms if multiple EDSLs with crosscutting domain semantics are used. To address this issue, we propose an architecture for embedding DSLs that makes use of meta-object protocols and aspect-oriented concepts to support crosscutting composition of EDSLs. This enables to write modularized EDSL programs where each program addresses one concern. Copyright 2010 ACM.},
  doi = {10.1145/1739230.1739237},
  paper = {https://dx.doi.org/10.1145/1739230.1739237}
}
@ARTICLE{Dominique2014,
  author = {Dominique, Blouin and Yvan, Eustache and JeanPhilippe, Diguet},
  journal = {CEUR Workshop Proceedings},
  title = {Extensible Global Model Management with Meta-model Subsets and Model Synchronization},
  year = {2014},
  pages = {43--52},
  volume = {1236}
}
@INPROCEEDINGS{Drouot2019,
  author = {Drouot, B. and Champeau, J.},
  booktitle = {---},
  title = {Model federation based on role modeling},
  year = {2019},
  editor = {Hammoudi, S. and Selic, B. and Pires, L. F.},
  pages = {74--85},
  publisher = {SciTePress},
  abstract = {Modeling approaches could be a powerful solution for specification, design and analysis. At a system level, models must take into account many system concerns. Thus, several system modeling approaches are based on several viewpoints expressed in Domain Specific Modeling Languages. Cyber threat analysis takes place within this modeling context with the need for several DSMLs to address several viewpoints of the system. So, the analysis of this domain is supported by DSML interoperability to perform simulation or other algorithms. Therefore, in this paper, we present an approach to face DSML interoperability based on role modeling. The Role4All framework is based on a metamodel including the Role concept. The Role4All language provides the capacity to define shared semantics between the DSMLs. Role4All and role modeling avoid model transformations and promote a federation approach between several DSMLs. The federation mechanisms of Role4All are illustrated in the cyber threat modeling framework to emphasize information gathering and the updates of the role model. Copyright \copyright 2019 by SCITEPRESS - Science and Technology Publications, Lda. All rights reserved}
}
@ARTICLE{Drouot2020,
  author = {Drouot, Bastien and Golra, Fahad R. and Champeau, Jo\"{e}l},
  journal = {Communications in Computer and Information Science},
  title = {A Role Modeling Based Approach for Cyber Threat Analysis},
  year = {2020},
  pages = {76--100},
  abstract = {Using DSMLs, the domain experts can express their models in a language that is relevant to the problem area. However, it also adds the complexity of interoperability between these languages, specially for application areas that encompass multiple domains. One such application area, Cyber Threat Analysis (CTA), is at the intersection of various domains that can evolve independently: system modeling, attacker modeling and threat description. In this paper, we present an approach to address CTA interoperability issues based on role modeling. The proposed language provides a mechanism to define shared semantics between DSMLs relative to the CTA. The concept of a role is central to our approach, presented as Role4All framework. These roles allow us to federate different DSMLs to generate an attacker's viewpoint. Our approach is illustrated using a case study on the development of an attacker's viewpoint based on the federation of multiple domain models. Interoperability between the domain models is crucial to apply dedicated algorithms and interpretations on the attacker's viewpoint. We used this attacker viewpoint to simulate attacks on a system for security analysis.},
  doi = {10.1007/978-3-030-37873-8_4},
  paper = {http://dx.doi.org/10.1007/978-3-030-37873-8_4}
}
@INCOLLECTION{Duran2013,
  author = {Dur\'{a}n, F. and Zschaler, S. and Troya, J.},
  booktitle = {---},
  publisher = {---},
  title = {On the reusable specification of non-functional properties in DSLs},
  year = {2013},
  pages = {332--351},
  type = {Serial},
  volume = {7745 LNCS},
  abstract = {Domain-specific languages (DSLs) are an important tool for effective system development. They provide concepts that are close to the problem domain and allow analysis as well as generation of full solution implementations. However, this comes at the cost of having to develop a new language for every new domain. To make their development efficient, we must be able to construct DSLs as much as possible from reusable building blocks. In this paper, we discuss how such building blocks can be constructed for the specification and analysis of a range of non-functional properties, such as, for example, throughput, response time, or reliability properties. We assume DSL semantics to be provided through a set of transformation rules, which enables a range of analyses based on model checking. We demonstrate new concepts for defining language modules for the specification of non-functional properties, show how these can be integrated with base DSL specifications, and provide a number of syntactic conditions that we prove maintain the semantics of the base DSL even in the presence of non-functional-property specifications. \copyright 2013 Springer-Verlag Berlin Heidelberg.},
  doi = {10.1007/978-3-642-36089-3_19},
  paper = {https://dx.doi.org/10.1007/978-3-642-36089-3_19}
}
@INPROCEEDINGS{Edwards2007,
  author = {Edwards, George and Malek, Sam and Medvidovic, Nenad},
  booktitle = {---},
  title = {Scenario-Driven Dynamic Analysis of Distributed Architectures},
  year = {2007},
  address = {Berlin, Heidelberg},
  pages = {125--139},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {Software architecture constitutes a promising approach to the development of large-scale distributed systems, but architecture description languages (ADLs) and their associated architectural analysis techniques suffer from several important shortcomings. This paper presents a novel approach that reconceptualizes ADLs within the model-driven engineering (MDE) paradigm to address their shortcomings. Our approach combines extensible modeling languages based on architectural constructs with a model interpreter framework that enables rapid implementation of customized dynamic analyses at the architectural level. Our approach is demonstrated in XTEAM, a suite of ADL extensions and model transformation engines targeted specifically for highly distributed, resource-constrained, and mobile computing environments. XTEAM model transformations generate system simulations that provide a dynamic, scenario- and risk-driven view of the executing system. This information allows an architect to compare architectural alternatives and weigh trade-offs between multiple design goals, such as system performance, reliability, and resource consumption. XTEAM provides the extensibility to easily accommodate both new modeling language features and new architectural analyses.},
  doi = {10.1007/978-3-540-71289-3_12},
  paper = {https://dx.doi.org/10.1007/978-3-540-71289-3_12}
}
@INPROCEEDINGS{Ehrig2008,
  author = {Ehrig, Hartmut and Ehrig, Karsten and Ermel, Claudia and Prange, Ulrike},
  booktitle = {Fundamental Approaches to Software Engineering, 11th International Conference, {FASE} 2008, Held as Part of the Joint European Conferences on Theory and Practice of Software, {ETAPS} 2008, Budapest, Hungary, March 29-April 6, 2008. Proceedings},
  title = {Consistent Integration of Models Based on Views of Visual Languages},
  year = {2008},
  editor = {Fiadeiro, Jos{\'{e}} Luiz and Inverardi, Paola},
  pages = {62--76},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  volume = {4961},
  doi = {10.1007/978-3-540-78743-3\_5},
  paper = {https://doi.org/10.1007/978-3-540-78743-3\_5}
}
@INPROCEEDINGS{Emerson2006,
  author = {Emerson, Matthew and Sztipanovits, Janos},
  booktitle = {{OOPSLA}\endash6th {Workshop} on {Domain} {Specific} {Modeling}},
  title = {Techniques for metamodel composition},
  year = {2006},
  pages = {123--139}
}
@ARTICLE{Engelen2010,
  author = {Engelen, Luc and van den Brand, Mark},
  journal = {Electron. Notes Theor. Comput. Sci.},
  title = {Integrating Textual and Graphical Modelling Languages},
  year = {2010},
  number = {7},
  pages = {105--120},
  volume = {253},
  doi = {10.1016/j.entcs.2010.08.035},
  paper = {https://doi.org/10.1016/j.entcs.2010.08.035}
}
@INPROCEEDINGS{Erdweg2013,
  author = {Erdweg, Sebastian and van der Storm, Tijs and V\"{o}lter, Markus and Boersma, Meinte and Bosman, Remi and Cook, William R. and Gerritsen, Albert and Hulshout, Angelo and Kelly, Steven and Loh, Alex and Konat, Gabri\"{e}l D. P. and Molina, Pedro J. and Palatnik, Martin and Pohjonen, Risto and Schindler, Eugen and Schindler, Klemens and Solmi, Riccardo and Vergu, Vlad A. and Visser, Eelco and van der Vlist, Kevin and Wachsmuth, Guido H. and van der Woning, Jimi},
  booktitle = {---},
  title = {The State of the Art in Language Workbenches},
  year = {2013},
  address = {Cham},
  pages = {197--217},
  publisher = {Springer International Publishing},
  series = {Lecture Notes in Computer Science},
  abstract = {Language workbenches are tools that provide high-level mechanisms for the implementation of (domain-specific) languages. Language workbenches are an active area of research that also receives many contributions from industry. To compare and discuss existing language workbenches, the annual Language Workbench Challenge was launched in 2011. Each booktitle ={---}, year, participants are challenged to realize a given domain-specific language with their workbenches as a basis for discussion and comparison. In this paper, we describe the state of the art of language workbenches as observed in the previous editions of the Language Workbench Challenge. In particular, we capture the design space of language workbenches in a feature model and show where in this design space the participants of the 2013 Language Workbench Challenge reside. We compare these workbenches based on a DSL for questionnaires that was realized in all workbenches.},
  doi = {10.1007/978-3-319-02654-1_11},
  paper = {https://dx.doi.org/10.1007/978-3-319-02654-1_11}
}
@BOOK{Essadi2016,
  author = {Essadi, N. and Anwar, A. and Mahmoud, N. and Ieee},
  publisher = {Ieee},
  title = {Operator-Based Coordination between Heterogeneous DSLs : Case of Telecommunication Network Supervision},
  year = {2016},
  address = {New York},
  series = {2016 International Conference on Information Technology for Organizations Development},
  abstract = {Coordination between heterogeneous DSLs is needed more and more to overcome complexity of modern systems involving many business domains. This article gives a definition of heterogeneity, coordination and a classification of possible relationships between DSLs. Then, propose coordination operators to resolve heterogeneity accordingly with precedent works. As illustrative example, the paper presents a telecommunication network supervision system where two different DSLs: DSL ANS.1 and DSL supervision need to be coordinated, an operator of structural mapping has been used to coordinate between the two DSLs.}
}
@BOOK{Essadi2017,
  author = {Essadi, N. and Anwar, A. and Laghouaouta, Y.},
  publisher = {Ieee},
  title = {Operators Role-Based approach to coordinate between Heterogeneous DSLs},
  year = {2017},
  address = {New York},
  series = {2017 International Conference on Wireless Technologies, Embedded and Intelligent Systems},
  abstract = {Nowadays systems involve many business domains and are consequently designed by teams of experts with different concerns. Every team uses its Domain Specific Language (DSL) to elaborate heterogeneous models describing different parts of the same system. These heterogeneous models need to be coordinated and integrated, to get a whole view of the system, to ease its validation and to uncover inconsistencies between heterogeneous models. However, many approaches and ways of integration has been already explored, one of important approach among them is coordination between DSLs instead of models, doing so coordination became automatic instead of being manual and tailored to every instance of models. Actually, this work fits in this class by giving a classification of DSLs relationships and their respective operators used to resolve DSLs heterogeneity. Moreover, in this paper we consider coordination as a separate role to be given to DSLs meta-classes responsible of coordination. Explicitly, these meta-classes need to override operations defined in the proposed coordination meta-model. As illustrative example, we present a telecommunication network supervision system where two different DSL are involved.}
}
@INPROCEEDINGS{Essadi2018,
  author = {Essadi, Naima and Anwar, Adil},
  booktitle = {15th {IEEE/ACS} International Conference on Computer Systems and Applications, {AICCSA} 2018, Aqaba, Jordan, October 28 - Nov. 1, 2018},
  title = {Language Interface-Oriented Design: {A} Promising Approach to Coordinate between Heterogeneous DSMLs},
  year = {2018},
  pages = {1--6},
  publisher = {{IEEE} Computer Society},
  doi = {10.1109/AICCSA.2018.8612865},
  paper = {https://doi.org/10.1109/AICCSA.2018.8612865}
}
@INPROCEEDINGS{Essadi2018a,
  author = {Essadi, Naima and Anwar, Adil},
  booktitle = {5th {IEEE} International Congress on Information Science and Technology, CiSt 2018, Marrakech, Morocco, October 21-27, 2018},
  title = {Towards {A} Language Interface Design to Coordinate Between Heterogeneous DSMLs},
  year = {2018},
  editor = {Mohajir, Mohammed El and Achhab, Mohammed Al and Mohajir, Badr Eddine El and Jellouli, Ismail},
  pages = {12--17},
  publisher = {{IEEE}},
  doi = {10.1109/CIST.2018.8596540},
  paper = {https://doi.org/10.1109/CIST.2018.8596540}
}
@INPROCEEDINGS{Essadi2019,
  author = {Essadi, N. and Anwar, A.},
  booktitle = {---},
  title = {Language Interface-Oriented Design: A Promising Approach to Coordinate between Heterogeneous DSMLs},
  year = {2019},
  publisher = {IEEE Computer Society},
  volume = {2018-November},
  abstract = {In front of the increasing complexity and size of nowadays systems, the use of different Domain Specific Modeling Languages to design a same system became a necessity. Indeed, every team of experts uses a specific tailored language to design its concerns. As result designers face an inescapable heterogeneity. Actually, for a same system they get many heterogeneous models that need to be coordinated. The coordination of these heterogeneous models is of course necessary to get whole view of systems, to validate them and to ensure their evolution and consistency. To achieve this goal, authors propose to use an interface-oriented design approach, a mature concept in software engineering, but still not yet very used in software language engineering. To illustrate this approach two DSMLs are used: an Indoor Service Transport Language and an Internet of Things Language. \copyright 2018 IEEE.},
  doi = {10.1109/AICCSA.2018.8612865},
  paper = {https://dx.doi.org/10.1109/AICCSA.2018.8612865}
}
@INBOOK{Estublier2005,
  author = {Estublier, J. and Vega, G. and Ionita, A. D.},
  pages = {69--83},
  publisher = {Springer-Verlag Berlin},
  title = {Composing domain-specific languages for wide-scope software engineering applications},
  year = {2005},
  address = {Berlin},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {3713},
  abstract = {Domain-Specific Languages (DSL) offer many advantages over general languages, but their narrow scope makes them really effective only in very focused domains, for example Product Lines. The recent Model Driven Engineering (MDE) approach seeks to provide a technology to compose and combine models coming from different metamodels. Adapted to DSL, it means that it should be possible to compose "programs" written in different DSLs, which will enable the use of the DSL approach to build applications spanning different domains. The paper presents the Melusine environment, where such a composition technology has been developed and experimented.}
}
@INPROCEEDINGS{Fan2010,
  author = {Fan, Zhiqiang and Gao, Hui and Shen, Jufang and Zhang, Li},
  booktitle = {Enterprise Interoperability IV, Making the Internet of the Future for the Future of Enterprise, Proceedings of {I-ESA} 2010, Coventry, {UK}},
  title = {A UML-based System Integration Modeling Language for the Application System Design of Shipborne Combat System},
  year = {2010},
  editor = {Popplewell, Keith and Harding, Jenny A. and Poler, Raul and Chalmeta, Ricardo},
  pages = {91--100},
  publisher = {Springer},
  doi = {10.1007/978-1-84996-257-5\_9},
  paper = {https://doi.org/10.1007/978-1-84996-257-5\_9}
}
@ARTICLE{Favalli2020,
  author = {Favalli, Luca and K\ hn, Thomas and Cazzola, Walter},
  journal = {Splc '20},
  title = {Neverlang and FeatureIDE Just Married: Integrated Language Product Line Development Environment},
  year = {2020},
  abstract = {Language development is inherently complex. With the support of a suitable language development environment most computer scientists could develop their own domain-specific language (DSL) with relative ease. Yet, when the DSL is the result of a configuration over a language product line (LPL)---a special software product line (SPL) of compilers/interpreters and corresponding IDE services---they fail to provide adequate support. An environment for LPL engineering should facilitate the underlying process involving three distinct roles: a language engineer developing the LPL, a language deployer configuring a language product, and a language user using the language product. Neither IDEs nor SPLE environments can cater all three roles and fully support the LPL engineering process with distributed, incremental development, configuration, and deployment of language variants. In this paper, we present an LPL engineering process for the distributed, incremental development of LPLs and an integrated language product line development environment supporting this process, catering the three roles, and ensuring the consistency among all artifacts of the LPL: language components implementing a language feature, the feature model, language configurations and the resulting language products. To create such an environment, we married the Neverlang language workbench and AiDE its LPL engineering environment with the FeatureIDE SPL engineering environment. While Neverlang supports the development of LPLs and deployment of language products, AiDE generates the feature model for the LPL under development, whereas FeatureIDE handles the feature configuration. We illustrate the applicability of the LPL engineering process and the suitability of our development environment for the three roles by showcasing its application for teaching programming with a growable language. In there, an LPL for Javascript was developed/refactored, 15 increasingly complex language products were configured/updated and finally deployed.},
  doi = {10.1145/3382025.3414961},
  paper = {http://dx.doi.org/10.1145/3382025.3414961}
}
@INPROCEEDINGS{Fehrenbach2013,
  author = {Fehrenbach, Stefan and Erdweg, Sebastian and Ostermann, Klaus},
  booktitle = {---},
  title = {Software Evolution to Domain-Specific Languages},
  year = {2013},
  address = {Cham},
  pages = {96--116},
  publisher = {Springer International Publishing},
  series = {Lecture Notes in Computer Science},
  abstract = {Domain-specific languages (DSLs) can improve software maintainability due to less verbose syntax, avoidance of boilerplate code, more accurate static analysis, and domain-specific tool support. However, most existing applications cannot capitalise on these benefits because they were not designed to use DSLs, and rewriting large existing applications from scratch is infeasible. We propose a process for evolving existing software to use embedded DSLs based on modular definitions and applications of syntactic sugar as provided by the extensible programming language SugarJ. Our process is incremental along two dimensions: A developer can add support for another DSL as library, and a developer can refactor more code to use the syntax, static analysis, and tooling of a DSL. Importantly, the application remains executable at all times and no complete rewrite is necessary. We evaluate our process by incrementally evolving the Java Pet Store and a deliberately small part of the Eclipse IDE to use language support for field-accessors, JPQL, XML, and XML Schema. To help maintainers to locate Java code that would benefit from using DSLs, we developed a tool that analyses the definition of a DSL to derive patterns of Java code that could be represented with a high-level abstraction of the DSL instead.},
  doi = {10.1007/978-3-319-02654-1_6},
  paper = {https://dx.doi.org/10.1007/978-3-319-02654-1_6}
}
@INPROCEEDINGS{Fleurey2012,
  author = {Fleurey, Franck and Haugen, \Oystein and M\oller-Pedersen, Birger and Svendsen, Andreas and Zhang, Xiaorui},
  booktitle = {---},
  title = {Standardizing Variability \endash Challenges and Solutions},
  year = {2012},
  address = {Berlin, Heidelberg},
  pages = {233--246},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {Any modeling language can be said to model variability, but our concern is how variability can be expressed generically and thus be standardized on its own and not as an add-on or profile to other languages. In product line engineering feature modeling has been applied to express variants of product models. This paper shows how the Common Variability Language can be designed to enhance feature modeling and automate the production of product models from a product line model.},
  doi = {10.1007/978-3-642-25264-8_18},
  paper = {https://dx.doi.org/10.1007/978-3-642-25264-8_18}
}
@INBOOK{Fritzsche2009,
  author = {Fritzsche, M. and Johannes, J. and Assmann, U. and Mitschke, S. and Gilani, W. and Spence, I. and Brown, J. and Kilpatrick, P.},
  pages = {134--+},
  publisher = {Springer-Verlag Berlin},
  title = {Systematic Usage of Embedded Modelling Languages in Automated Model Transformation Chains},
  year = {2009},
  address = {Berlin},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {5452},
  abstract = {Annotation of programs using embedded Domain-Specific Languages (embedded DSLs), such as the program annotation facility for the Java programming language, is a well-known practice in computer science. In this paper we argue for and propose a specialized approach for the usage of embedded Domain-Specific Modelling Languages (embedded DSMLs) in Model-Driven Engineering (MDE) processes that in particular supports automated many-step model transformation chains. It can happen that information defined at some point, using an embedded DSML, is not required in the next immediate transformation step, but in a later one. We propose a new approach of model annotation enabling flexible many-step transformation chains. The approach utilizes a combination of embedded DSMLs, trace models and a megamodel. We demonstrate our approach based on an example MDE process and an industrial case study.}
}
@ARTICLE{Giachetti2009,
  author = {Giachetti, G. and Mar\'{i}n, B. and Pastor, O.},
  journal = {International Journal of Computer Science and Applications},
  title = {Integration of domain-specific modeling languages and uml through uml profile extension mechanism},
  year = {2009},
  number = {5},
  pages = {145--174},
  volume = {6},
  abstract = {A key requirement for MDD solutions is to have a modeling language that allows the correct representation of conceptual models. Nowadays, there are two options that are the most widely used for the definition of these modeling languages: 1) the specification of a domain-specific modeling language (DSML) or 2) the customization of UML. In practice, these two modeling alternatives are viewed as opposite solutions. However, since both alternatives provide benefits for the application of MDD solutions, in this article, we present a proposal that uses UML profile extension mechanisms to interchange modeling information between DSML-based models and UML models. This proposal shows how these two modeling alternatives can be integrated in a unique MDD solution. \copyright Technomathematics Research Foundation.}
}
@ARTICLE{Giachetti2009,
  author = {Giachetti, Giovanni and Mar{\'{\i}}n, Beatriz and Pastor, Oscar},
  journal = {{IJCSA}},
  title = {Integration of domain-specific modelling languages and {UML} through {UML} profile extension mechanism},
  year = {2009},
  number = {5},
  pages = {145--174},
  volume = {6},
  paper = {http://www.tmrfindia.org/ijcsa/v6i56.pdf}
}
@INPROCEEDINGS{Gjos,
  author = {Gj\os\aeter, Terje and Prinz, Andreas},
  booktitle = {---},
  title = {LanguageLab - A Meta-modelling Environment},
  year = {2015},
  address = {Cham},
  pages = {91--105},
  publisher = {Springer International Publishing},
  series = {Lecture Notes in Computer Science},
  abstract = {In the LanguageLab language workbench, we build on a component-based approach to language specification that facilitates the specification of all aspects of a computer language in a consistent manner, taking into account best practices in meta-modelling and language design. The workbench allows operation on a suitable abstraction level, and also focuses on user-friendliness and a low threshold to getting started, in order to make it useful for teaching of meta-modelling and language design and specification. The platform is open for third party language modules and facilitates rapid prototyping of DSLs, re-use of language modules, and experiments with multiple concrete syntaxes. The platform also allows interested parties to develop LanguageLab modules that can further add to the features and capabilities of the LanguageLab platform.},
  doi = {10.1007/978-3-319-24912-4_8},
  paper = {https://dx.doi.org/10.1007/978-3-319-24912-4_8}
}
@INPROCEEDINGS{Goschnick2010,
  author = {Goschnick, Steve and Sonenberg, Liz and Balbo, Sandrine},
  booktitle = {Human-Computer Interaction - Second {IFIP} {TC} 13 Symposium, {HCIS} 2010, Held as Part of {WCC} 2010, Brisbane, Australia, September 20-23, 2010. Proceedings},
  title = {A Composite Task Meta-model as a Reference Model},
  year = {2010},
  editor = {Forbrig, Peter and Patern{\`{o}}, Fabio and Pejtersen, Annelise Mark},
  pages = {26--38},
  publisher = {Springer},
  series = {{IFIP} Advances in Information and Communication Technology},
  volume = {332},
  doi = {10.1007/978-3-642-15231-3\_4},
  paper = {https://doi.org/10.1007/978-3-642-15231-3\_4}
}
@INBOOK{Groher2009,
  author = {Groher, Iris and Voelter, Markus},
  pages = {111--152},
  publisher = {Springer},
  title = {Aspect-Oriented Model-Driven Software Product Line Engineering},
  year = {2009},
  address = {Berlin, Heidelberg},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  abstract = {Software product line engineering aims to reduce development time, effort, cost, and complexity by taking advantage of the commonality within a portfolio of similar products. The effectiveness of a software product line approach directly depends on how well feature variability within the portfolio is implemented and managed throughout the development lifecycle, from early analysis through maintenance and evolution. This article presents an approach that facilitates variability implementation, management, and tracing by integrating model-driven and aspect-oriented software development. Features are separated in models and composed of aspect-oriented composition techniques on model level. Model transformations support the transition from problem to solution space models. Aspect-oriented techniques enable the explicit expression and modularization of variability on model, template, and code level. The presented concepts are illustrated with a case study of a home automation system.}
}
@INPROCEEDINGS{Guan2018,
  author = {Guan, C. and Ao, Y. and Du, D. and Mallet, F.},
  booktitle = {2018 25th Asia-Pacific Software Engineering Conference (APSEC)},
  title = {xSHS: An Executable Domain-Specific Modeling Language for Modeling Stochastic and Hybrid Behaviors of Cyber-Physical Systems},
  year = {2018},
  pages = {683--687},
  abstract = {Cyber-Physical Systems (CPS) integrate discrete computational processes and continuous physical ones in a feedback loop. Design and analysis of CPS become difficult since their dynamic behaviors rely on heterogeneous descriptions from many fields. Domain-Specific Modeling Language (DSML) offers an effective and tailor-made solution for focusing on a specific field. However, to address CPS we need to bring together several DSMLs in a coordinated sensible way. The GEMOC Studio is meant to be an integration platform for putting together several DSMLs. This paper relies on it and brings a new DSML, called xSHS (for Executable Stochastic Hybrid Statechart), into the focus. It aims at modeling the stochastic and hybrid behaviors of CPS. We discuss here the abstract syntax, a proposed concrete syntax and an operational semantics that makes the language executable. We exploit both the language and modeling workbenches of the GEMOC Studio and we provide a simulation engine that implements the operational semantics. A temperature control system is used as a case study.},
  doi = {10.1109/APSEC.2018.00090},
  paper = {https://dx.doi.org/10.1109/APSEC.2018.00090}
}
@INPROCEEDINGS{Haav2015,
  author = {Haav, Hele{-}Mai and Ojamaa, Andres and Grigorenko, Pavel and Kotkas, Vahur},
  booktitle = {On the Move to Meaningful Internet Systems: {OTM} 2015 Workshops - Confederated International Workshops: {OTM} Academy, {OTM} Industry Case Studies Program, EI2N, FBM, INBAST, ISDE, META4eS, and {MSC} 2015, Rhodes, Greece, October 26-30, 2015, Proceedings},
  title = {Ontology-Based Integration of Software Artefacts for {DSL} Development},
  year = {2015},
  editor = {Ciuciu, Ioana and Panetto, Herv{\'{e}} and Debruyne, Christophe and Aubry, Alexis and Bollen, Peter and Valencia{-}Garc{\'{\i}}a, Rafael and Mishra, Alok and Fensel, Anna and Ferri, Fernando},
  pages = {309--318},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  volume = {9416},
  doi = {10.1007/978-3-319-26138-6\_34},
  paper = {https://doi.org/10.1007/978-3-319-26138-6\_34}
}
@INPROCEEDINGS{Haber2015,
  author = {Haber, Arne and Look, Markus and Nazari, Pedram Mir Seyed and P{\'{e}}rez, Antonio Navarro and Rumpe, Bernhard and V{\"{o}}lkel, Steven and Wortmann, Andreas},
  booktitle = {Model-Driven Engineering and Software Development - Third International Conference, {MODELSWARD} 2015, Angers, France, February 9-11, 2015, Revised Selected Papers},
  title = {Composition of Heterogeneous Modeling Languages},
  year = {2015},
  editor = {Desfray, Philippe and Filipe, Joaquim and Hammoudi, Slimane and Pires, Lu{\'{\i}}s Ferreira},
  pages = {45--66},
  publisher = {Springer},
  series = {Communications in Computer and Information Science},
  volume = {580},
  doi = {10.1007/978-3-319-27869-8\_3},
  paper = {https://doi.org/10.1007/978-3-319-27869-8\_3}
}
@INPROCEEDINGS{Haber2015a,
  author = {Haber, Arne and Look, Markus and P{\'{e}}rez, Antonio Navarro and Nazari, Pedram Mir Seyed and Rumpe, Bernhard and V{\"{o}}lkel, Steven and Wortmann, Andreas},
  booktitle = {{MODELSWARD} 2015 - Proceedings of the 3rd International Conference on Model-Driven Engineering and Software Development, ESEO, Angers, Loire Valley, France, 9-11 February, 2015},
  title = {Integration of Heterogeneous Modeling Languages via Extensible and Composable Language Components},
  year = {2015},
  editor = {Hammoudi, Slimane and Pires, Lu{\'{\i}}s Ferreira and Desfray, Philippe and Filipe, Joaquim},
  pages = {19--31},
  publisher = {SciTePress},
  doi = {10.5220/0005225000190031},
  paper = {https://doi.org/10.5220/0005225000190031}
}
@INPROCEEDINGS{Hagemann2020,
  author = {Hagemann, N. and Pr\"{o}ll, R. and Bauer, B.},
  booktitle = {8th International Conference on Model-Driven Engineering and Software Development, MODELSWARD 2020},
  title = {Towards abstract test execution in early stages of model-driven software development},
  year = {2020},
  editor = {Hammoudi, S. and Pires, L. F. and Selic, B.},
  pages = {216--226},
  publisher = {SciTePress},
  abstract = {Over the last decades, systems immanent complexity has significantly increased. In order to cope with the emerging challenges during the development of such systems, modeling approaches become an indispensable part. While many process steps are applicable to the model-level, there are no sufficient realizations for test execution yet. As a result, we present a semi-formal approach enabling developers to perform abstract test execution straight on the modeled artifacts to support the overarching objective of a shift left of verification and validation tasks. Our concept challenges an abstract test case (derived from test model) against a system model utilizing an integrated set of domain-specific models, i.e. the omni model. Driven by an optimistic dataflow analysis based on a combined view of an abstract test case and its triggered system behavior, possible test verdicts are assigned. Based on a prototypical implementation of the concept, the proof of concept is demonstrated and further on put in the context of related research. Copyright \copyright 2020 by SCITEPRESS - Science and Technology Publications, Lda. All rights reserved.}
}
@INPROCEEDINGS{Havinga2008,
  author = {Havinga, Wilke and Bergmans, Lodewijk and Aksit, Mehmet},
  booktitle = {---},
  title = {Prototyping and Composing Aspect Languages},
  year = {2008},
  address = {Berlin, Heidelberg},
  pages = {180--206},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {Domain specific aspect languages (DSALs) are becoming more popular because they can be designed to represent recurring concerns in a way that is optimized for a specific domain. However, the design and implementation of even a limited domain-specific aspect language can be a tedious job. To address this, we propose a framework that offers a fast way to prototype implementations of domain specific aspect languages. A particular goal of the framework is to be general enough to support a wide range of aspect language concepts, such that existing language concepts can be easily used, and new language concepts can be quickly created.We briefly introduce the framework and its underlying model, as well as the workflow used when implementing DSALs. Subsequently, we show mappings of several domain specific aspect languages to demonstrate the framework. Since in our approach the DSALs are mapped to a common model, the framework provides an integrating platform allowing us to compose programs that use aspects written in multiple DSALs. The framework also provides explicit mechanisms to specify composition of advices written in multiple DSALs.},
  doi = {10.1007/978-3-540-70592-5_9},
  paper = {https://dx.doi.org/10.1007/978-3-540-70592-5_9}
}
@INPROCEEDINGS{Heidenreich2011,
  author = {Heidenreich, Florian and Johannes, Jendrik and Karol, Sven and Seifert, Mirko and Thiele, Michael and Wende, Christian and Wilke, Claas},
  booktitle = {---},
  title = {Integrating OCL and Textual Modelling Languages},
  year = {2011},
  address = {Berlin, Heidelberg},
  pages = {349--363},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {In the past booktitle ={---}, years, many OCL tools achieved a transition of OCL from a language meant to constrain UML models to a universal constraint language applied to various modelling and metamodelling languages. However, OCL users still experience a discrepancy between the now highly extensible parsing and evaluation backend of OCL tools and the lack of appropriate frontend tooling like advanced OCL comments that adapt to the different application scenarios.We argue that this has to be addressed both at a technical and methodological level. Therefore, this paper provides an overview of the technical foundations to provide an integrated OCL tooling frontend and backend for arbitrary textual modelling languages and contributes a stepwise process for such an integration. We distinguish two kinds of integration: external definition of OCL constraints and embedded definition of OCL constraints. Due to the textual notation of OCL the second kind provides particularly deep integration with textual modelling languages. We apply our approach in two case studies and discuss the benefits and limitations of the approach in general and both integration kinds in particular.},
  doi = {10.1007/978-3-642-21210-9_34},
  paper = {https://dx.doi.org/10.1007/978-3-642-21210-9_34}
}
@INBOOK{Heim2016,
  author = {Heim, R. and Nazari, P. M. S. and Rumpe, B. and Wortmann, A.},
  pages = {67--82},
  publisher = {Springer Int Publishing Ag},
  title = {Compositional Language Engineering Using Generated, Extensible, Static Type-Safe Visitors},
  year = {2016},
  address = {Cham},
  series = {Lecture Notes in Computer Science},
  type = {Book Section},
  volume = {9764},
  abstract = {Language workbenches usually produce infrastructure to represent models as abstract syntax trees (AST) and employ processing infrastructure largely based on visitors. The visitor pattern suffers from the expression problem regarding extensibility and reuse. Current approaches either forsake static type safety, require features unavailable in popular object-oriented languages (e.g., open classes), or rely on procedural abstraction and thereby give up the object-oriented data encapsulation (the AST) itself. Our approach to visitors exploits knowledge about the AST and generation of statically type-safe external visitor interfaces that support extensibility in two dimensions: (1) defining new operations by implementing the interface and (2) extending the underlying data structure, usually without requiring adaptation of existing implemented visitors. We present a concept of visitor development for language engineering that enables an adaptable traversal and provides hook points for implementing concrete visitors. This approach is applicable to single DSLs and to language composition. It thus enables a transparent, easy to use, and static type-safe solution for the typical use cases of language processing.},
  doi = {10.1007/978-3-319-42061-5_5},
  paper = {https://dx.doi.org/10.1007/978-3-319-42061-5_5}
}
@INPROCEEDINGS{Heim2016,
  author = {Heim, R. and Rumpe, B. and Wortmann, A.},
  booktitle = {---},
  title = {Extending architecture description languages with exchangeable component behavior languages},
  year = {2016},
  pages = {351--356},
  publisher = {Knowledge Systems Institute Graduate School},
  volume = {2016-January},
  abstract = {Architecture description languages (ADLs) encapsulate domain concerns in components. Most ADLs enforce domain experts to use general purpose programming languages (GPLs) or an especially designed, fixed component behavior language. Domain-specific languages (DSLs), on the other hand, aim to reduce the conceptual gap between problem domain challenges and GPL solutions. Current ADLs focus on software engineering and disregard integration of domain-specific component behavior languages. We combine results from DSL-based software language engineering with component & connector ADLs to present a concept for the non-invasive and exchangeable integration of both. The concept is realized with the MontiArc- Automaton component & connector ADL. This liberates domain experts from using GPLs and facilitates their contribution.},
  doi = {10.18293/SEKE2016-13},
  paper = {https://dx.doi.org/10.18293/SEKE2016-13}
}
@MISC{Hemingway2007,
  author = {Hemingway, Graham and Su, Hang and Chen, Kai and Koo, T. John},
  title = {A Semantic Anchoring Infrastructure for the Design of Embedded Systems},
  year = {2007},
  doi = {10.1109/compsac.2007.39},
  paper = {https://dx.doi.org/10.1109/compsac.2007.39}
}
@INPROCEEDINGS{Hessellund2007,
  author = {Hessellund, Anders and Czarnecki, Krzysztof and Wasowski, Andrzej},
  booktitle = {---},
  title = {Guided Development with Multiple Domain-Specific Languages},
  year = {2007},
  address = {Berlin, Heidelberg},
  pages = {46--60},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  abstract = {We study the Apache Open for Business (OFBiz), an industrial-strength platform for enterprise applications. OFBiz is an example of a substantial project using model-driven development with multiple domain-specific languages (DSLs). We identify consistency management as one of its key challenges. To address this challenge, we present SmartEMF, which is an extension of the Eclipse Modeling Framework that provides support for representing, checking, and maintaining constraints in the context of multiple loosely-coupled DSLs. SmartEMF provides a simple form of user guidance by computing the valid set of editing operations that are available in a given context. We evaluate the prototype by applying it to the OFBiz project.},
  doi = {10.1007/978-3-540-75209-7_4},
  paper = {https://dx.doi.org/10.1007/978-3-540-75209-7_4}
}