László Lengyel

A Systematic Approach to Metamodeling Environments and Model Transformation Systems in VMTS

Highly configurable metamodeling environments and graph transformation techniques have been applied successfully in software system modeling and other areas. In this paper a uniform treatment of these two methods is illustrated by a tool called Visual Modeling and Transformation System. The concepts of an n-layer metamodeling environment is outlined with the related topological and attribute issues. Built on metamodeling techniques two alternatives for model transformation are elaborated, namely, the traversal and the graph-rewriting approaches. In our implementation all of the aforementioned mechanisms use metamodel as a common formalism, which can be considered as a uniform basis for storing, creating and transforming visual languages. The feasibility of the approach is illustrated by a transformation which generates C/C++ code from UML statecharts.

Towards Automated, Formal Verification of Model Transformations

Verification of models and model processing programs are inevitable in real-world model-based software development. Model transformation developers are interested in offline verification methods, when only the definition of the model transformation and the metamodels of the source and target languages are used to analyze the properties and no concrete input models are taken into account. Therefore, the results of the analysis hold for each output model not just particular ones, and we have to perform the analysis only once. Most often, formal verification of model transformations is performed manually or the methods can be applied only for a certain transformation or for the analysis of only a certain property. Previous work has presented a formalism to describe the characteristics of model transformations in separate formal expressions called assertions. This description is based on the first-order logic, therefore, if deduction rules are provided, a reasoning system can use an assertion set to automatically derive additional assertions describing additional properties of model transformations. In this paper, we propose deduction rules and present the verification of a model transformation of processing business process models.

Supporting domain-specific model patterns with metamodeling

Metamodeling is a widely applied technique in the field of graphical languages to create highly configurable modeling environments. These environments support the rapid development of domain-specific modeling languages (DSMLs). Design patterns are efficient solutions for recurring problems. With the proliferation of DSMLs, there is a need for domain-specific design patterns to offer solutions to problems recurring in different domains. The aim of this paper is to provide theoretical and practical foundations to support domain-specific model patterns in metamodeling environments. In order to support the treatment of premature model parts, we weaken the instantiation relationship. We provide constructs relaxing the instantiation rules, and we show that these constructs are appropriate and sufficient to express patterns. We provide the necessary modifications in metamodeling tools for supporting patterns. With the contributed results, a well-founded domain-specific model pattern support can be realized in metamodeling tools.

Metamodel-Based Model Transformation with Aspect-Oriented Constraints

Model transformation means converting an input model available at the beginning of the transformation process to an output model. A widely used approach to model transformation uses graph rewriting as the underlying transformation technique. In case of diagrammatic languages, such as the Unified Modeling Language (UML), the exclusive topological matching is found to be not enough. To define precisely the transformation steps beyond the topology of the visual models, additional constraints must be specified which ensures the correctness of the attributes, or other properties to be enforced. Dealing with OCL constraints provides a solution for these unsolved issues, because topological and attribute transformation methods cannot perform and express the problems which can be addressed by constraint validation. The use of OCL as a constraint and query language in modeling is essential. We have shown that it can be applied to model transformations as well. Often, the same constraint is repetitiously applied in many different places in a transformation. It would be beneficial to describe a common constraint in a modular manner, and to designate the places where it is to be applied. This paper presents the problem of crosscutting constraints in transformation rules, and provides an aspect-oriented solution for it. Our approach makes it possible to define constraints separately from the transformation steps, and facilitates specifying their propagation assignment to graph transformation rules. To illustrate the conceptual results, a case study is also provided, which introduces (i) how our approach generates user interface handler source code for mobile platform from a resource model and a statechart diagram, and (ii) how it validates specific properties during the transformation steps using aspect-oriented constraints.

A Synchronizing Technique for Syntactic Model-Code Round-Trip Engineering

The introduction of UML class diagrams has not raised the abstraction level of development to the extent that was intended: class diagrams are only the visual representations of source class skeletons implemented in a programming language. To improve the productivity, domain-specific languages are applied, which cover a narrow domain, and their high abstraction makes use of the domain experts easier. The simultaneous evolution of the source code and the software models causes the loss of synchronization. Round-tripping the domain-specific models is not supported by model-driven development tools, because the abstraction gap between the models and the generated code prevents the use of general approaches. However, developers should have the opportunity of choosing between the artifacts that are more efficient for applying the modifications. This paper introduces how different tools achieve the preservation of manually written code while the model is evolving. In contrast, we present our approach that allows the customization of the generated code. The abstraction gap is closed by performing model transformations and an incremental merge.

Validated model transformation-driven software development

Model-driven Software Engineering is one of the most focused research fields. Model processors automatically generate the lower level artefacts. Graph transformation is a widely used technique for model transformations. Especially visual model transformations can be expressed by graph transformations. This paper presents a visual control flow support of the Visual Modelling and Transformation System and discusses the principles of the constraint-driven validated model transformation. The presented approach helps to validate, preserve or guarantee certain model properties not only for individual transformation rules but also for the whole transformation.

Control Flow Support in Metamodel-Based Model Transformation Frameworks

This paper presents the visual control flow support of Visual Modeling and Transformation System (VMTS), which facilitates composing complex model transformations out of simple transformation steps and executing them. The VMTS control flow language (VCFL) uses stereotyped activity diagrams to specify control flow structures and OCL constraints to choose between different control flow branches. In general, a control structure language needs are the sequence, the conditional branch, hierarchism, parallel executions and the iteration. VCFL has all these control structures in a deterministic version

A formalism for describing modeling transformations for verification

Verification of models and model processing programs are inevitable in model-based software development in order to apply them in real-world solutions. Verification of properties of model transformations means to prove that the application of a model transformation generates the expected output models from the input models. Model transformation developers are interested in offline methods for the verification process. Offline analysis means that only the definition of the model transformation and the metmodels of the source and target languages are used to analyze the properties and no concrete input models are taken into account. Therefore, the results of the analysis hold for each output model not just particular ones, and we have to perform the analysis only once. Most often, formal verification of model transformations is performed manually or the methods can be applied only for a certain transformation or for the analysis of only a certain property. In this paper, we propose a formalization to describe model transformation. A formal description can be automatically generated, and can be extended by the experts. An automated reasoning system may prove some properties of model transformations by deriving new assertions from the original description.

Formal specification and analysis of functional properties of graph rewriting-based model transformation

Model processing programs are regularly used when working with models or synthetizing the code from them; therefore, their verification has become an essential component of constructing reliable software in model‐based software engineering. Models are usually formalized and visualized as graphs; therefore, model processing programs based on algebraic graph rewriting systems—such programs are called model transformations—are often applied, and their verification has become an important research area. The goal of our research is to support offline transformation analysis by automated methods, where offline means that only the definition of the program itself, the language definitions of its source and target models are used during the analysis. Therefore, the results are independent from concrete source models, and the analysis needs to be performed only once. Based on previous work, this paper provides the synthesis and of a set of individual components and improves them to provide a complete verification solution: (i) a language is introduced to specify the properties to be verified; (ii) a formalism to describe model transformations in a declarative way; and (iii) automated algorithms that can analyse the declarative transformations as well as the properties expressed by the language. Besides its theoretical basis, the implementation of a verification framework is presented, and its operation is illustrated on a case study. Although the formal verification of model transformation properties is algorithmically undecidable in general, our goal is to provide a practically usable, scoped framework that can largely facilitate the manual verification of model transformations. Copyright

Incremental Model Synchronization by Bi-Directional Model Transformations

Model transformation is a focused area in model-driven software development. With the help of model transformations we can generate source code, other models and documentation from the source models. During the development, a recurring problem is that the source and target artifacts coexist and they evolve independently. This means that after the transformation the target artifacts can be changed by the developer. The problem in this case is that the target artifact will not be consistent with the source model. One option to maintain consistency is by synchronizing our artifacts with model transformation. With the help of synchronization, the developer can work on each artifact, because they are consistent. However the synchronization can be quite complex and cannot be applied in many cases. Usually the inverse transformation does not exist, or it cannot be determined uniquely. This paper presents how we can track the modifications of the transformation, and how we can use this information in the synchronization process.