Abstract: The Multi-Paradigm Modeling (MPM) approach of model-based development emphasizes the specification of a system by multiple models. We use transformations to automatically transform, integrate and synchronize models. Verification and validation of model transformations are fundamental issues: we need to express what a valid model is and how a valid model transformation may transform the models; otherwise, we have to analyze each transformed model individually, which makes it difficult to automate the process of using models. We have formally analyzed various model transformations in several case studies and industrial projects. From this experience, we have distilled the frequently recurring techniques and solutions, referred to as Model Transformation Analysis (MTA) methods. These instances, similarly to design patterns in object-oriented programming, define special constructions as solutions for recurring problems that arise when one implements a model transformation. Moreover, MTA methods contain special techniques and language features that should be taken into account when one designs a model transformation framework or a model transformation language. We hope that MTA methods may be the basis of automated formal analysis techniques of model transformations. This paper contributes the concept and instances of MTA methods and provides a case study based on an industrial project of mobile application development. With this real-world example, we want to demonstrate the role and use of MTA methods. The case study is implemented in Visual Modeling and Transformation System (VMTS), which is a tool that realizes the MPM concept to provide a model and model transformation-based environment for software development.
Abstract: Verification of the transformations is a fundamental issue for applying
them in real world solutions. We have previously proposed a formalization to declaratively
describe model transformations and proposed an approach for the verification.
Our approach consists of a reasoning system that works on the formal transformation
description and deduction rules for the system. The reasoning system can
automatically generate the proof of some properties. In this paper, we present a case
study, to demonstrate our approach of automated verification of model transformations
in a multi-paradigm environment.
Abstract: Model transformation is a crucial aspect of Model-Driven Software Development. With the help of model transformation, we can generate source code or other artifacts from software models. However, a recurring problem in software development is the fact that source and target models coexist and they evolve independently. In general, a modeled system is composed of several models that are often related to one another. Consequently, the related models will not be consistent anymore if one of them is altered in the development process. For that reason, a model synchronization method is necessiated to resolve inconsistency between the modified models. Performing synchronization manually can be an error prone task due to the number and complexity of model elements. In model-driven technologies, where processing is carried out as a series of model transformations, applying model transformations can also be a reasonable option for the reconciliation. This paper presents an approach that uses trace models and model transformations to facilitate incremental model synchronization.
Abstract: 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.
Abstract: 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.
Abstract: Metamodeling techniques are popular in describing the rules of special domains, but these techniques do not support defining presentation for these domains , namely the concrete syntax. The aim of our research is to provide a method to create the concrete syntax for metamodeling systems in a flexible, efficient way. Several domain-specific languages have been created that support defining the concrete syntax, i.e. the visualization. The main concern of this paper is to present a model transformation method that processes our presentation definitions and transforms them automatically into source code. The source code implements a plug-in capable of editing the models. A termination analysis for the presented method is also provided.
Abstract: Model transformation has become one of the most focused research field, motivated by for instance the OMGâs Model-Driven Architecture (MDA). Metamodeling is a central technique in the design of visual languages, and it reuses existing domains by extending the metamodel level. Metamodel-based software development requires the transformation of the models between various stages. These transformation steps must be formally and precisely specified, which can be accomplished along with constraints enlisted in transformation steps. Our metamodel-based approach uses graph rewriting techniques for model transformation. This paper summarizes our results related to the metamodel-based constraint validation during the model transformation. This work presents the Rule Constraint Validator (RCV) algorithm, the Invariant Analysis (IA) algorithm, the Persistent Analysis (PA) algorithm and the combination of the RCV and PA algorithms which results the Optimized Rule Constraint Validator (ORCV) algorithm. An illustrative case study for constraint validation in rewriting rules is also provided.
Abstract: 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.
Abstract: Model-based development is an increasingly applied method in producing software artifacts that is driven by model transformation. For instance, OMG's Model-Driven Architecture as a model-based approach to software development facilitates the synthesis of application programs from models created using customized, domain-specific model processors. Meta Object Facility 2.0 Query/ Views/ Transformation (QVT) is the OMG's standard for specifying model queries, views, and transformations. Extensive research of graph transformation provides a strong formal background for model transformation. The main contribution of this paper is to show how high-level constraint constructs facilitate to realize transformations specified in QVT with metamodel-based model transformation. As a result we can reuse the graph transformation constructs, and its formal background, which facilitates to make QVT transformations validated.
Abstract: Graph rewriting-based visual model processing is a widely used technique for model transformation. Visual model transformations often need to follow an algorithm that requires a strict control over the execution sequence of the transformation steps. Therefore, in Visual Model Processors (VMPs) the execution order of the transformation steps is crucial. This paper presents the visual control flow support of Visual Modeling and Transformation System (VMTS), which facilitates composing complex model transformations of simple transformation steps and executing them. The VMTS Visual Control Flow Language (VCFL) uses stereotyped activity diagrams to specify control flow structures and OCL constraints to choose between different control flow branches. This paper introduces VCFL, discusses its termination properties and provides an algorithm to support the termination analysis of VCFL transformations.
Abstract: Models and model-based software development is one of the most focused research fields. Flexible, highly customizable models are required. Metamodeling is a proven solution for this problem, but the information represented by metamodels has a tendency to be incomplete, informal, imprecise, and sometimes even inconsistent. Object Constraint Language (OCL) is a wide-spread formalism to express model constraints, and it is also useful in graph transformation-based model transformation. There exist several interpreters and compilers that handle OCL constraints in modeling, but these tools do not support constraint optimization, therefore, the model validation is not always efficient. This paper presents efficient algorithms to optimize OCL compilers with respect to the traversing steps of the generated code, and accelerate the validation process by normalizing the OCL constraints. Proofs are also provided to show that the optimized and the unoptimized code are functionally equivalent.
Abstract: A widely applied 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 the transformation steps precisely beyond the structure 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. The use of OCL as a constraint and query language in modelling 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 mark the places where it is to be applied. This paper discusses (i) the problem of crosscutting constraints in visual model transformation steps, and provides an aspect-oriented solution for a consistent constraint management. It introduces the concepts of aspect-oriented constraints and a new type of aspect, the constraint aspects. (ii) In general, it is difficult to require a whole transformation to validate, preserve or guarantee certain properties because transformations are built form isolated transformation steps ordered by a control structure. This problem is solved by the provided constraint weaver methods, which weave the constraints into the model transformation steps prior to the execution. (iii) Furthermore, the work presents offline constraint optimization (normalization) algorithms, which are part of the presented weaving process.
Abstract: Model-Driven Architecture (MDA) standardized by OMG facilitates to separate the platform independent part and the platform specific part of a system model. Due to this separation Platform-Independent Model (PIM) can be reused across several implementation platforms of the system. Platform-Specific Model (PSM) is ideally generated automatically from PIM via model transformation steps. Because of the appearance of high level languages, object-oriented technologies and CASE tools, metamodeling becomes more and more important. Metamodeling is one of the most central techniques both in design of visual languages, and reuse existing domains by extending the metamodel level. The creation of model compliers on a metamodeling basis is illustrated by a software package called Visual Modeling and Transformation System (VMTS), which is an n-layer multipurpose modeling and metamodel-based transformation system. VMTS is able to realize an MDA model compiler. This paper (i) addresses the relationship between the constraints enlisted in metamodel-based rewriting rules and the pre- and postconditions, (ii) it introduces the concepts of general validation, general preservation and general guarantee, which facilitate that if a transformation step is specified adequately with the help of constraints, and the step has been executed successfully for the input model, then the generated output model is in accordance with the expected result, which is described by the transformation step refined with the constraints. An illustrative case study based on constraint specification in rewriting rules is also provided.
Abstract: 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 Visual Control
Flow Language (VCFL) uses stereotyped activity diagrams to specify
control flow structures and OCL constraints to choose between
different control flow branches. This work discusses the termination
properties of VCFL and provides an algorithm to support the
termination analysis of VCFL transformations.
Abstract: Model transformation systems are an important contribution to the field of automated software engineering. This paper summarizes the theoretical background implemented in Visual Modeling and Transformation System (VMTS) to validate the topology of the transformation steps. The mathematical formalism is based on the double pushout approach, which is extended to rewriting steps consisting of metamodel elements. Firstly the instantiation relationship is transformed to a homomorphic mapping, then the theorems from DPO approach is applied in conjunction with the validation-related propositions. The theoretical results are accompanied with practical considerations throughout the paper, and the propositions are turned into algorithms to facilitate their applications.
Abstract: 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.
Abstract: Model transformation methods are vital in several applications such as OMGÃÂs Model-Driven Architecture and Visual Model Processors. This paper contributes a metamodel-based rewriting rule representation similar to the UML class diagram and the supporting algorithms to determine valid instances of the patterns. The proposed algorithms are illustrated by specific examples throughout the paper. The results turn out to be useful not only for UML class diagram-based rewriting rule formulation patterns, but it provides a method for checking valid instantiation of UML class diagrams in modeling environments.
Abstract: With the proliferation of the OMGâs Model-Driven Architecture metamodel- based storage systems and software model transformation has become a crucial issue considering novel technologies. This paper illustrates the techniques and consideration related to the implementation of the Visual Modeling and Transformation System focusing the implementation of the core functionality called AGSI. Graph rewriting and theoretical achievements are outlined, then architectural decisions, and detailed design trade-offs are presented. The algorithmic solutions have a special emphasis; the metamodel-related techniques are elaborated and illustrated with pseudo code.
Abstract: Model-Based Design of complex software systems is an activity that requires the use of different modeling formalisms, with different perspectives of the system, to cover all relevant aspects of the system, to avoid over-design, to employ manageable models and to support system integration The comprehensive use of models in design has created a set of challenges beyond those of supporting one isolated design task In particular, the need to combine, couple, and integrate models at different levels of abstraction and in different formalisms is posing a set of specific problems that must be tackled Multi-Paradigm Modeling is precisely the research field to focus on developing an appropriate set of concepts and tools to address the challenge of integrating models of different aspects of a software system specified using different formalisms and eventually at different levels of abstraction This paper summarizes the results of the 3rd Workshop on Multi-Paradigm Modeling: Concepts and Tools
Abstract: Graph rewriting is a widely used approach to model transformation. In general, graph rewriting rules parse graphs only by topological concerns, but they are not sophisticated enough to match a graph with a node which has a special property. In case of diagrammatic languages, such as the Unified Modeling Language (UML), the exclusive topological parsing is found to be not enough. To define the transformation steps in a more refined way additional constraints must be specified, which ensures the correctness of the attributes among others. Dealing with OCL constraints provides a solution for the unsolved issues. 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 the crosscutting constraints in graph transformation steps, provides an aspect-oriented solution for it, and introduces the weaving algorithms used to propagate aspect-oriented constraints to graph transformation steps.
Abstract: Verification of models and model processing programs are inevitable in real world model-based software development. Model transformation developers are often interested in offline verification methods, when only the definition of the model transformation and the specification 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 formal and algorithmic background for a possible verification framework. Based on this background, this paper introduces a realization of an automated verification framework for graph rewriting-based model transformations. We illustrate the operation of the framework and demonstrate its applicability on a case study. Our goal is to further improve our approach in order to be able to be applied in more complex industrial solutions as well.
Abstract: 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.
Abstract: Model transformation is a crucial aspect of model-driven software development. With the help of model transformation, we can generate source code or other models from software models. However, a recurring problem in software development is the fact that source and target models coexist and they evolve independently. This means that after the initial transformation phase the target models are often changed by the developers and the target model will no longer be consistent with the source model. Therefore, the models need to be synchronized. Model transformation is one option to implement the synchronization process. However, it is very complex because the transformation has to recognize which elements should be updated and which elements should be left unaltered during synchronization. In addition, a clear backward transformation usually does not exist from the target to the source domain. In this paper, we present an algorithm that facilitates incremental model synchronization in model transformation systems. The feasibility of the approach is also illustrated by a real world case study; we synchronize user interfaces of different mobile platforms.
Abstract: Model-driven approaches try to improve the productivity of the traditional software development by focusing on a special problem using high abstraction models. Comparing to the source code, specific visualization of models inspired by these domains is very advantageous and closer to the human thinking. Though, in many cases the details can be efficiently edited only in textual form: visual models are sometimes not expressive or effective enough, and could be circumstantial to use. The common problem of typical modeling tools is that they provide support for only one kind of model representation, but it would be more effective if two or more representation possibilities could be mixed. In this paper, we suggest an approach, which supports the concurrent evolution of the artifacts in both textual and visual way. The declarative textual syntax mapping is defined in a way to facilitate bi-directional conversion. To synchronize, and merge the changes of the different kinds of artifacts incrementally, a three-way comparison is applied.
Abstract: Verification of models and model processing programs are fundamental issues
and are inevitable in model-based software development in order to apply them in realworld
solutions. Verification concerns the analysis of non-functional and functional
properties as well. 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, but automated or semi-automated approaches have gained focus
recently. We have previously presented a method to formally describe the main
characteristics of model transformations. Our concept consists of two steps: (i) The
automatic generation of a formal description from a concrete transformation, which is
manually extended by formal assertions by transformation experts. (ii) A reasoning system
is used to automatically derive the proof of certain properties from the previous formal
description. In this paper, we show how deduction rules of the reasoning system can be
defined.
Abstract: This paper presents the design, architecture, and implementation experiences related to building a multipurpose modeling and model transformation frameworks. We examine the usual expectations related to model-driven development tools, then we present the architecture and design decisions of a new modeling framework capable of fulfilling all these expectations. The suggested architecture and the provided implementation offer an approach that (i) has an efficient data structure, (ii) can be easily customized and (iii) optimized for different purposes of modeling.
Abstract: This Model-Driven Development (MDD) facilitates the synthesis of application programs from models created using customized, domain-specific model processors. Model compilers can be realized by graph rewriting-based model transformation. In Visual Modeling and Transformation System (VMTS), metamodel-based rewriting rules facilitate to assign OCL constraints to model transformation rules. This approach supports validated model transformation. Unfortunately, the validation introduces a new concern that often crosscuts the functional concern of the transformation rules. To separate these concerns, an aspect-oriented solution is applied for constraint management. This paper introduces the identification method of the crosscutting constraints in metamodel-based model transformation rules. The presented algorithms facilitate the better understanding of the transformation, their easier constraint-based configuration, and make both the constraints and the rewriting rules reusable.
Abstract: 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.
Abstract: Developing software for mobile devices requires special attention, and it is still a larger effort compared to the development for desktop computers and servers. With the introduction and the popularity of wireless devices, the diversity of the platforms has also been increased. There are different platforms and tools from different vendors such as Microsoft, Sun, Nokia, SonyEricsson and many more. Therefore, generative techniques underpinned by model-driven development can be applied extensively in this field. This paper introduces the Mobile Toolkit for the tool Visual Modeling and Transformation System (VMTS). This toolkit provides a bridge between the different mobile platforms with respect to the user interface and network communication development.
Abstract: 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.
Abstract: way of increasing productivity in software engineering. Model-based development is driven by model transformations that attempt to bridge the large semantic gaps between high-level models and low-level languages. There is a demand for researching the ways in which model transformation can become more flexible, efficient, highly-configurable as well as validated. This paper addresses issues of visually defined metamodel-based model transformations that support validated model transformations. We introduce our model transformation framework, visual modeling and transformation system (VMTS), and a list of applications realized with VMTS on metamodel-based model transformation basis. Furthermore, a comprehensive comparison is given related to other model transformation approaches.
Abstract: Domain-specific model processors facilitate the efficient synthesis
of application programs from software models. Often, model
compilers are realized by graph rewriting-based model transformation.
In Visual Modeling and Transformation System (VMTS),
metamodel-based rewriting rules facilitate to assign Object Constraint
Language (OCL) constraints to model transformation rules.
This approach supports validated model transformation. Unfortunately,
the validation introduces a new concern that often crosscuts
the functional concern of the transformation rules. To separate
these concerns, an aspect-oriented solution is applied for constraint
management. This paper introduces the identification method of
the crosscutting constraints in metamodel-based model transformation
rules. The presented algorithms make both the constraints and
the rewriting rules reusable, furthermore, supports the better understanding
of model transformations.
Abstract: The transformation from UML activity diagrams to CSP models is a helpful
model transformation, which can be used to analyze and verify some aspects of a UML
activity diagrams. A working solution has been developed with our tool, the Visual
Modeling and Transformation System, and in this work we formally prove that the
transformation terminates for every valid input activity diagram model, and therefore it can
be used in practice.
Abstract: Model-Driven Architecture (MDA) as a model-based approach to
software development facilitates the synthesis of application
programs from models created using customized, domain-specific
model processors. MDA model compilers can be realized by graph
rewriting-based model transformation. In Visual Modeling and
Transformation System (VMTS), metamodel-based transformation steps
facilitate to assign OCL constraints to model transformation
steps. Based on this facility the paper proposes a novel validated
model transformation approach that can ensure to validate not only
the individual transformation steps, but the whole transformations
as well. The discussed approach provides a visual control flow
language to define transformations visually in a simple way that
results more efficient development process. The presented methods
are illustrated using a case study from the field of model-based
development.
Abstract: With the introduction and popularity of wireless devices, the diversity of the platforms has also been increased. There are different platforms and tools from different vendors such as Microsoft, Sun, Nokia, SonyEricsson and many more. Because of the relatively low-level programming interface, software development for Symbian platform is a tiresome and error prone task, whereas .NET CF contains higher level structures. This paper introduces the problem of the software development for incompatible mobile platforms, moreover, it provides a model-driven architecture (MDA) and Domain Specific Modeling Language (DSML)-based solution. We also discuss the relevance of the model-based approach that facilitates a more efficient software development, because the reuse and the generative techniques are key characteristics of model-based computing. In the presented approach, the platform-independence lies in the graph rewriting-driven visual model transformation. This paper illustrates the creation of model compilers on a metamodeling basis by a software package called Visual Modeling and Transformation System (VMTS), which is an n-layer multipurpose modeling and metamodel-based transformation system. A case study is also presented how model compilers can be used to generate user interface handler code for different mobile platforms from the same platform-independent input models
Abstract: Model-based approaches in software development are widely
recognized as a potential way of increasing productivity in
software engineering. Model-based development is driven by
model transformations. There is a demand for researching the
ways how model transformation can become more flexible,
efficient, and highly-configurable as well as validated. Extensive
research of graph transformation provides a strong formal
background for graph rewriting-based model transformation. In
the tool Visual Modeling and Transformation System (VMTS),
metamodel-based transformation rules enable assigning OCL
constraints to model transformation rules that facilitate constraintdriven
online validated model transformations. Using aspectoriented
methods, this paper introduces the separation of the
refining and validation constraints that crosscut the transformation
rules, and discusses the constraint realization possibilities with
negative and positive application conditions (NAC, PAC). As a
result of the constraint-driven validation, we can not only ensure
the validation of the whole transformation, but the transformation
becomes more modular and applicable in larger projects as well.
Abstract: Constraint handling is one of the most focused research field in both model validation and model transformation. Constraints are often simple topological conditions such as multiplicity checks, but the main strength of the constraint validation lies in the textual constraints defined in high-level languages. Object Constraint Language (OCL) is a wide-spread formalism to express model constraints. We have found that OCL is also useful in graph transformation-based model transformation rules. There exist several interpreters and compilers that handle OCL constraints in modeling, but these tools do not support constraint optimization, therefore, the model validation is not always efficient. This paper presents algorithms to optimize OCL compilers, and accelerate the validation process. The presented algorithms were implemented in the OCL Compiler of Visual Modeling and Transformation System, and they were tested in both metamodels and transformation rules.
Abstract: Model-Driven Architecture (MDA) as a model-based approach to
software development facilitates the synthesis of application
programs from models created using customized, domain-specific
model processors. MDA model compilers can be realized by
graph rewriting-based model transformation. In Visual Modeling
and Transformation System (VMTS), metamodel-based rewriting
rules facilitate to assign OCL constraints to model transformation
steps. This approach supports validated model transformation.
The goal is to validate not only the individual transformation
steps, but the whole transformations as well. Unfortunately, the
validation introduces a new concern that often crosscuts the
functional concern of the transformation steps. To separate these
concerns and make them reusable, an aspect-oriented solution is
presented for constraint management. This paper introduces a new
type of aspect, the constraint aspect to separate the crosscutting
constraints from model transformation steps. Moreover,
algorithms are given to create and weave constraint aspects to
model transformation steps prior to the execution of the
transformation. The presented method results in a more efficient
and optimized weaving, furthermore, we can require that not only
a single transformation step, but a whole transformation validates,
preserves or guarantees certain properties about the output of the
transformation.
Abstract: Graph rewriting-based visual model processing is a widely used technique for model transformation. Visual model transformations often need to follow an algorithm that requires a strict control over the execution sequence of the transformation steps. Thus, in Visual Model Processors (VMPs) the execution order of the rewriting rules is crucial. This paper presents the visual control flow support of Visual Modeling and Transformation System (VMTS), which facilitates composing complex model transformations of simple transformation steps and executing them. The VMTS Visual Control Flow Language (VCFL) uses stereotyped activity diagrams to specify control flow structures and OCL constraints to choose between different control flow branches. This paper introduces VCFL, discusses its termination properties and provides an algorithm to support the termination analysis of VCFL transformations. Furthermore, an illustrative case study is also provided.
Abstract: With the introduction and popularity of wireless
devices, the diversity of the platforms has also been
increased. There are different platforms and tools from
different vendors such as Microsoft, Sun, Nokia,
SonyEricsson and many more. This paper introduces the
problem of the software development for incompatible
mobile platforms, and provides a Model-Driven
Architecture (MDA)-based solution. In the presented
approach the platform-independence lies in the graph
rewriting-driven visual model transformation. This work
illustrates the creation of model compliers on a
metamodeling basis by a software package called Visual
Modeling and Transformation System (VMTS), which is
an n-layer multipurpose modeling and metamodel-based
transformation system. A case study is also presented how
model compilers can be used to generate user interface
handler code for different mobile platforms from the same
platform-independent input models.
Abstract: Model- Driven Architecture (MDA) standardized by OMG facilitates to separate the platform independent part and the platform specific part of a system model. Due to this separation PIM can be reused across several implementation platforms of the software. PSM is ideally generated automatically from PIM via model transformation steps performed by model compilers. Because of the appearance of high level languages object-oriented technologies and wide spreading of CASE tools. metamodeling has become more and more important. Metamodeling is one of the most central techniques in the design of visual languages, and it reuses existing domains by extending the metamodel level. In this paper the creation of model compliers on a metamodeling basis is illustrated by a software package called Visual Modeling and Transformation System (VMTS) [1] [2], which is an n-layer multipurpose modeling and metamodel-based transformation system. This paper has two main subjects: (i) checking constraints contained by metamodels during the metamodel instantiation, and (ii) checking rewriting rules containing constraints during the graph transformation process. Besides these the paper addresses the relation between constraints and pre- and postconditions. These constraints are specified on the meta-layer and impose restrictions on the models residing on the instance layer of the rules. An illustrative case study for constraint validation in rewriting rules is also provided.
Abstract: Supporting the vision of Model-Driven Architecture (MDA), model compilers are an important area of software engineering research. Model transformation systems built on graph rewriting transformation steps can be used as a natural approach to implement model compilers. The rewriting rules can be described in terms of the metamodel elements. Validating these metamodel-based rules is addressed in this paper. A metamodel-based rule can be validated against the metamodels. The uniqueness of the application of the transformation rule is guaranteed in case of well-defined conditions. Two conditions are given in the form of categorical equations for validation, derived from the double pushout approach. A brief introduction to the categorical graph rewriting is also provided.
Abstract: Following the evolution of the high-level languages the conception of metamodeling became natural. The metamodel defines the constraints for the model, it can be used as a rule for the model level objects, the attributes of the objects, and the connection between them. The metamodel contains every rule, that the modeling environment has to follow. We use metamodels as the model of the modeling tools. Our system, the Visual Modeling and Transformation System (VMTS) [1] unifies the metamodeling techniques used by the common modeling tools, and the model transformation used by graph rewriting. The fundamental underlying data structure is a mathematical object: a labeled directed graph. The modeling objects are modeled as nodes, and the connection between them are modeled as edges. This method makes possible to use the well-known and the new graph traversing and transforming algorithms. The other benefit of the VMTS is that it extends the metamodel-model concepts of MOF [2] to an n-layer model-hierarchy. This paper is made to introduce the steps of metamodeling using a case study. For the case study we have chosen the MetaClass Diagram - Class Diagram - Object diagram models of UML. The reason of this choice is the three layer depth of this model-row, so the n-layer capabilities can be illustrated as well.
Abstract: Graph transformation has been widely used for expressing model transformations. Especially transformations of visual models can be naturally formulated by graph transformations, since graphs are well suited to describe the underlying structures of models. Based on a common sample model transformation, four different model transformation approaches are presented which all perform graph transformations. At first, a basic solution is presented and crucial points of model transformations are indicated. Subsequent solutions focus mainly on the indicated problems. Finally, a first comparison of the chosen approaches to model transformation is presented where the main ingredients of each approach are summarized.
Abstract: Following the evolution of the high-level languages the conception of metamodeling became natural. The metamodel defines the constraints for the model, it can be used as a rule for the model level objects, the attributes of the objects, and the connection between them. The metamodel contains every rule, that the modeling environment has to follow. We use metamodels as the model of the modeling tools. Our system, the Visual Modeling and Transformation System (VMTS) [1] unifies the metamodeling techniques used by the common modeling tools, and the model transformation used by graph rewriting. The fundamental underlying data structure is a mathematical object: a labeled directed graph. The modeling objects are modeled as nodes, and the connection between them are modeled as edges. This method makes possible to use the well-known and the new graph traversing and transforming algorithms. The other benefit of the VMTS is that it extends the metamodel-model concepts of MOF [2] to an n-layer model-hierarchy. This paper is made to introduce the steps of metamodeling using a case study. For the case study we have chosen the MetaClass Diagram - Class Diagram - Object diagram models of UML. The reason of this choice is the three layer depth of this model-row, so the n-layer capabilities can be illustrated as well.
Abstract: Metamodeling techniques facilitate the efficient reuse of the elements of design tools and environments. This paper provides a flexible approach to store and instantiate the attributes in multilayer metamodeling environments. An XML-based representation and the related algorithms are presented as a technique for maintaining the attribute relationships between the model and the metamodel levels. The commonly applied two-layer instantiation mechanisms are generalized to n-layer environments. Nowadays the significance of the Unified Modeling Language is unquestionable. UML is widely adopted both in software and hardware system design. The concepts of the attribute instantiation are illustrated by creating metamodels for UML diagrams. The background and the implementation framework for the discussed constructs are the Visual Modeling and Transformation System (VMTS).
Abstract: Aspect-Oriented Software Development (AOSD) is an emerging area with the goal of promoting advanced separation of concerns throughout the software development lifecycle. AOSD started on programming language level, but it must be applicable on a higher abstraction level as well. This paper provides an overview of aspect-oriented software development, discusses the key AOSD concepts, and presents the aspect-oriented programming and aspect-oriented modeling. Furthermore, introduces an aspect-oriented constraint management approach applied in a metamodel-based model transformation system.
Abstract: Software modeling means producing diagrams. A software diagram, such as a UML class diagram, in general, not refined enough to provide all the relevant aspects of a specification. We need a mechanism to describe additional constraints about the objects in the model. The Object Constraint Language (OCL) is a formal language, OCL expressions are unambiguous and make the model more precise and more detailed. The navigations contained by the constraints increase the complexity of the constraint evaluation. This paper introduces the concept of AND/OR Clauses and provides algorithms ÃÂ constraint relocation and constraint decomposition ÃÂ to eliminate navigation steps from the OCL constraints appearing in UML class diagram-based models.
Abstract: This paper presents the aspect-oriented constraint management of the Visual Control Flow Language (VCFL) applied in the Visual Modeling and Transformation System (VMTS). To define the transformation steps precisely, additional constraints must be specified beyond the structure of the visual models (such as UML models). Structural and attribute transformation methods cannot perform and express the issues, which can be addressed by constraint validation. The use of OCL as a constraint and query language in modeling is a suitable choice. In our experience, constraints are proven to be useful in model transformations as well: VCFL uses OCL constraints to define constraints on the nodes of the transformation steps and to choose between different control flow branches. Often, the same constraint is repetitiously applied in many different places in a transformation and crosscuts it. It would be beneficial to describe a common constraint in a modular manner and designate the places where it will be applied. Using an illustrative case study, this paper introduces the problem of crosscutting constraints in visual model transformation steps, and provides an aspect-oriented solution for it, applying aspect-oriented constraints and constraint weaving methods. Finally, the similarities between AOP and the AO constraint concepts are also discussed.
Abstract: Visual Model Processors consume visual models with graph representation using graph transformation techniques as opposed to Traversing Model Processors which traverse the graph representation in order to produce the output. This paper addresses open issues related to the attribute transformations of metamodel-based model transformation systems which use graph rewriting as the underlying technique. Among others these transformations facilitate the efficient reuse of MDA PIM model artifacts across several platform specific implementations. To illustrate the achievements a case study is presented which has been built on easy-to- formalize labeled directed graph structures. The implementation concepts are also delineated using the Visual Modeling and Transformation System (VMTS) [1] software package.
Abstract: Model-Driven Architecture standardized by OMG facilitates separating the platform-independent part (PIM) and the platform-specific part (PSM) of a system model. The platform-independent artifacts are mainly UML models created with CASE tools. Due to this separation, PIM specified by the developers can be reused across several implementation platforms of the software. PSM is ideally generated automatically from PIM via model transformation steps performed by model compilers. Beyond the topology of the visual models additional constraints must be specified, which ensure the correctness of the attributes among others. Dealing with OCL constraints provides a solution for the unsolved issues, because topological and attribute transformation methods cannot perform and express the problems that can be addressed by constraint validation. This paper discusses the need for combining UML and OCL, it introduces the compilers in general, it shows the architecture of our OCL Compiler for .NET, and it presents the lexical and syntactic analysis as well as the semantic analysis and code generation techniques in detail. The OCL Compiler has been implemented as a module of our n-layer multipurpose modeling and metamodel-based transformation system called Visual Modeling and Transformation System (VMTS). The OCL Compiler module facilitates validating (i) constraints contained by the metamodels at the time of the model instantiation process, and (ii) constraints contained by the transformation steps during the metamodel-based graph transformation. An illustrative case study is also provided, which introduces how VMTS generates source code from a statechart diagram, and how it validates specific properties using the OCL Compiler.
Abstract: Programming for the Symbian OS assumes that developers invest particular and uncommon work, therefore the development lifecycle is rather longer and the costs are usually higher than these of common C++ software development. Dealing with user interface, database or communication, programming is not so straightforward as expected. However, am appropriate developer tool can help the developers to be more efficient and solve the designing and programming difficulties. In this paper we will introduce a rapid application development tool set on the Symbian OS. We model the user interface and the statechart of the mobile applications with a novel tool (Visual Modeling and Transformation System). After this design phase, source code can be generated. We describe a class library that helps the programmers or code generators to produce Symbian source code that is easy to read and maintain.
Abstract: 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.
Abstract: Examining round-trip engineering in the software engineering process, we can realize that they have common parts, which we have to do in all cycles, such as model-code and code-model conversions. This paper presents a method and related algorithms, which generate those parts of model-code relation that can be automated, and makes possible to concentrate solely on the semantic information during the implementation. The method contains an automatic schema generation, which makes possible for the method to be practically adaptable for any models. In the proposed way an Universal Representation is generated which facilitates the separation of the original representation and the transformation steps in an automated yet checked way. A case study based on a complete implementation is provided as well.
Abstract: Generative software composition is an extraordinary efficient ways to design software for reuse and also addresses the problem of tool-supported system integration. Domain modeling lies at the heart of the generative approach which directly underpins the opportunity of reuse. This paper describes a multipurpose modeling and transformation system which facilitates creating, storing feature models and other UML diagrams, including built-in transformation framework based on graph rewriting with tree-based notation. Relation to the OMG Meta-Object Facility and an illustrative case study is also provided.
