Figure 10 - uploaded by Georg Hinkel
Content may be subject to copyright.
![3.: The impact of the OR rule to the Petri Net and State Chart model [GR13]](profile/Georg-Hinkel/publication/282858064/figure/fig15/AS:613859391975425@1523366892443/The-impact-of-the-OR-rule-to-the-Petri-Net-and-State-Chart-model-GR13.png)
Source publication
In recent years, model-driven software development (MDSD) has gained
popularity among both industry and academia. MDSD aims to generate
traditional software artifacts from models. This generation process is
realized in multiple steps. Thus, before being transformed to software
artifacts, models are transformed into models of other metamodels. Such...
Citations
... Ever since the dawn of model-driven engineering at the beginning of the century, model transformations, supported by dedicated transformation languages [31], have been an integral part of model-driven development. Model transformation languages (MTLs), being domain-specific languages, have ever since been associated with advantages in areas like productivity, expressiveness and comprehensibility compared to general-purpose programming languages (GPLs) [50,55,60]. ...
There exists a plethora of claims about the advantages and disadvantages of model transformation languages compared to general-purpose programming languages. With this work, we aim to create an overview over these claims in the literature and systematize evidence thereof. For this purpose, we conducted a systematic literature review by following a systematic process for searching and selecting relevant publications and extracting data. We selected a total of 58 publications, categorized claims about model transformation languages into 14 separate groups and conceived a representation to track claims and evidence through the literature. From our results, we conclude that: (i) the current literature claims many advantages of model transformation languages but also points towards certain deficits and (ii) there is insufficient evidence for claimed advantages and disadvantages and (iii) there is a lack of research interest into the verification of claims.
... This in turn has implications for understandability and maintainability and therefore is very important. To get a better understanding of the advantages and disadvantages, we developed a model transformation language that follows this approach: the NMF Transformations Language (NTL) [19]. ...
... It may override the transformation rules contained in this transformation or add new transformation rules. The entire finite state machine to Petri nets transformation can be found in [19]. We have abbreviated it here. ...
... However, there are a couple of different SDKs for OPC UA and all these different SDKs have their own code generators that generate code in one language that is specific to this particular SDK. 19 The code generator is currently agnostic of the used SDK. In the intended scenario, it is extended by another code generator that is specific to the used SDK. ...
Model-driven engineering (MDE) has proved to be a useful approach to cope with today’s ever-growing complexity in the development of software systems; nevertheless, it is not widely applied in industry. As suggested by multiple studies, tool support is a major factor for this lack of adoption. In particular, the development of model transformations lacks good tool support. Additionally, modularization techniques are inevitable for the development of larger model transformations to keep them maintainable. Existing tools for MDE, in particular model transformation approaches, are often developed by small teams and cannot keep up with advanced tool support for mainstream general-purpose programming languages, such as IntelliJ or Visual Studio. Internal DSLs are a promising solution to these problems. In this paper, we investigate the impact of design decisions of an internal DSL to the reuse of tool support and modularization concepts from the host language. We validate our findings in terms of understandability, applicability, tool support, and extensibility using three case studies from academia, a model-driven engineering platform, and the industrial automation domain where we apply an implementation of an internal model transformation language on the .NET platform. The results confirm the value of inherited modularity and tool support while conciseness and understandability are still competitive.
... To solve both of these issues, internal languages offer a promising approach: Model transformation languages can be abstracted from, and integrated into general-purpose languages. This way, tool support for the host language is inherited, and developers may stick to the languages that they are used to. 1 Several languages follow this approach [4,20,29,41,47,63,64]. We have observed that most of these languages only operate in a rather imperative way, which means that they contain less control flow abstractions than declarative model transformation languages, such as, for example, QVT-R [54]. ...
... NMF stands for .NET Modeling Framework [32] and is an open-source project to support MDE on the .NET platform. NMF Transformations [29] is a sub-project of NMF that supports model transformation. It consists of a model transformation framework and internal DSL for C# on top of it (NMF Transformations Language, NTL). ...
... In the implementation, we use a concept we call synchronization rule instantiation, very similar to the transformation rule instantiation concept used in NTL [29,38]. Thus, whenever the synchronization engine is asked to create a new element for a given synchronization rule, it looks out for instantiations of that synchronization rule to create the element, because the target concept may also be different according to the true type of the source element. ...
Despite good results in several industrial projects, model-driven engineering (MDE) has not been widely adopted in industry. Although MDE has existed for more than a decade now, the lack of tool support is still one of the major problems, according to studies by Staron and Mohaghegi (Staron, in: Model driven engineering languages and systems, Springer, Berlin, 2006; Mohagheghi et al. in Empir Softw Eng 18(1):89–116, 2013). Internal languages offer a solution to this problem for model transformations, which are a key part of MDE. Developers can use existing tools of host languages to create model transformations in a familiar environment. These internal languages, however, typically lack key features such as change propagation or bidirectional transformations. In our opinion, one reason is that existing formalisms for these properties are not well suited for textual languages. In this paper, we present a new formalism describing incremental, bidirectional model synchronizations using synchronization blocks. We prove the ability of this formalism to detect and repair inconsistencies and show its hippocraticness. We use this formalism to create a single internal model transformation language for unidirectional and bidirectional model transformations with optional change propagation. In total, we currently provide 18 operation modes based on a single specification. At the same time, the language may reuse tool support for C#. We validate the applicability of our language using a synthetic example with a transformation from finite state machines to Petri nets where we achieved speedups of up to multiple orders of magnitude compared to classical batch transformations.
... The high abstraction level in the dynamic dependency graph is achieved by a manual incrementalization of analysis operators yielding valid results as a consequence of the underlying formalization as a categorial functor. NMF Expressions includes a library of such manually incrementalized operators, including most of the Standard Query Operators (SQO) 4 . As a consequence, developers can specify query analyses conveniently through the query syntax such as used in Listing 1. ...
... To support model transformation, NMF contains the NMF Transformations Language (NTL) [4], an internal model transformation language integrated in C#, reusing the tool support for C# [5]. This transformation language allows to specify extensible rule-based model transformations with explicit dependencies between the transformation rules. ...
... In this paper, we present a solution for the state elimination case using the .NET Modeling Framework (NMF, [Hin16]). However, the state elimination case does not fit either of the model transformation languages NTL [Hin13] or NMF Synchronizations [Hin15,HB17]. Both of these languages share the common assumption that it is a characterizing element of a model transformation that there is correspondence between elements of the source model and elements of some target model. ...
... Another, a later model transformation language using .NET technical space is NMF or .NET Modelling Framework (WEB, j). The best document describing this approach is Master thesis by Georg Hinkel (2013). The supported transformation language, NTL, has a structure similar to QVT-R (OMG, 2011a) and consists of rules, patterns and declarative rule dependency descriptions, however, fragments in plain C# can be easily incorporated. ...
... In this paper, we tackle this problem as we extract our experience with the design of the NMF Transformation Language (NTL) [Hin13] regarding design for tool support reuse. We discuss the design alternatives how to map model transformation concepts (in particular transformation rules) to code artifacts in an internal DSL and explain limitations and consequences. ...
... The entire finite state machine to Petri nets transformation can be found in [Hin13]. We abbreviate it here for space limitations. ...
Model-driven engineering (MDE) has proven to be a useful approach to cope with todays ever growing complexity in the development of software systems, yet it is not widely applied in industry. As suggested by multiple studies, tool support is a major factor for this lack of adoption. Existing tools for MDE, in particular model transformation approaches, are often developed by small teams and cannot keep up with advanced tool support for mainstream languages such as provided by IntelliJ or Visual Studio. In this paper, we propose an approach to leverage existing tool support for model transformation using internal model transformation languages and investigate design decisions and their consequences for inherited tool support. The findings are used for the design of an internal model transformation language on the .NET platform.
... NMF stands for .NET Modeling Framework 1 and is an open-source project to support MDE on the .NET platform. NMF Transformations [10] is a sub-project of NMF that supports model transformation. It consists of a model transformation framework and internal DSL for C# on top of it (NMF Transformations Language, NTL). ...
... Next, we use the same synchronization code without any modification and use it in incremental mode, i.e. from left to right with change propagation mode switched on to OneWay. Finally, we use an implementation for this transformation task in NTL, basically taken from previous work [10]. This solution works pretty similar to the batch mode version, but lacks some of the overhead implied by the NMF Synchronizations implementation. ...
... Model transformation languages as internal languages Some experiences exist with creating model transformation languages as internal languages like RubyTL [20], ScalaMTL [21], FunnyQT [22] or SDMLib 4 . The goals to use an existing language as host language are diverse and range from an easier implementation [23], reuse of the static type system [21], inherited tool support [10], reusing the expression evaluation, easier integration into the host language up to less learning points for developers. The degree in which these goals can be met depends very much on the selected host language, as e.g. ...
Despite good results, Model-Driven Engineering (MDE) has not been widely adopted in industry. According to studies by Staron and Mohaghegi [1], [2], the lack of tool support is one of the major reasons for this. Although MDE has existed for more than a decade now, tool support is still insufficient. An approach to overcome this limitation for model transformations, which are a key part of MDE, is the usage of internal languages that reuse tool support for existing host languages. On the other hand, these internal languages typically do not provide key features like change propagation or bidirectional transformation. In this paper, we present an approach to use a single internal model transformation language to create unidirectional and bidirectional model transformations with optional change propagation. In total, we currently provide 18 operation modes based on a single specification. At the same time, the language may reuse tool support for C#. We validate the applicability of our language using a synthetic example with a transformation from finite state machines to Petri nets where we achieved speedups of up to 48 compared to classical batch transformations.
... NMF Synchronizations is a bridge between the model transformation language NMF Transformations [6], [7] and NMF Expressions 5 , responsible for the incremental evaluation of arbitrary expressions. NMF Synchronizations uses NMF Expressions to make model transformations bidirectional and incremental, i.e. any changes of either left hand side (LHS) or right hand side (RHS) of the model can be propagated to the other. ...
... The idea of using internal DSLs [5] for model transformation has already been applied several times, but for different reasons. These reasons include a low implementation effort [6], type safety [7] or extensibility [8,7,9,10]. However, their implications on reusing underlying component models have not been analyzed so far. ...
To increase the development productivity, possibilities for reuse, maintainability and quality of complex model transformations, modularization techniques are indispensable. Component-Based Software Engineering targets the challenge of modularity and is well-established in languages like Java or C# with component models like .NET, EJB or OSGi. There are still many challenging barriers to overcome in cur-rent model transformation languages to provide comparable support for component-based development of model transformations. Therefore, this paper provides a pragmatic solution based on NMF Transformations, a model transformation language realized as an internal DSL embedded in C#. An internal DSL can take advantage of the whole expressiveness and tooling build for the well established and known host language. In this work, we use the component model of the .NET platform to rep-resent reusable components of model transformations to support inter-nal and external model transformation composition. The transformation components are hidden behind transformation rule interfaces that can be exchanged dynamically through configuration. Using this approach we illustrate the possibilities to tackle typical issues of integrity and ver-sioning, such as detecting versioning conflicts for model transformations.
