Search

Model transformation plays a central role in Model-Driven Engineering. In application scenarios such as tool integration or view specification, bidirectionality is a crucial requirement. Triple Graph Grammars (TGGs) are a formally founded, bidirectional transformation language, which has been used successfully in various case studies from different applications domains. In practice, supporting the maintainability of TGGs is a current challenge and existing modularity concepts, e.g., to avoid pattern duplication in TGG rules, are still inadequate. Existing TGG tools either provide no support at all for modularity, or provide limited support with restrictions that are often not applicable. In this paper, we present and formalize a novel modularity concept for TGGs: Rule refinement, which generalizes existing modularity concepts, solves the problem of pattern duplication, and enables concise, maintainable specifications. [ABSTRACT FROM AUTHOR]

Agent-Oriented Software Engineering is currently deeply influenced by the techniques and concepts of Model-Driven Development. In this context, the use of automated transformations to support software processes is not explored enough. Models are supposed to be created following the activities of a process, which standard transformations could partially perform. The reduced use of transformations for this purpose is largely due to the high effort required for their development. To overcome this limitation, this paper presents an algorithm to generate model transformations by-example. It overcomes two common limitations of these approaches: the generation of many-to-many transformation between arbitrary graphs of elements; dealing with transformation languages that do not directly support graphs of elements in their source or target models. The algorithm has been implemented for the ATLAS transformation language in the MTGenerator tool. The paper also illustrates how to use this tool to facilitate the support for a software process, in this case for the INGENIAS methodology. [ABSTRACT FROM AUTHOR]

Model-Driven Engineering places models as first-class artifacts throughout the software lifecycle requiring the availability of proper transformation languages. Although numerous approaches are available, they lack convenient facilities for supporting debugging and understanding of the transformation logic. This is because execution engines operate on a low level of abstraction, hide the operational semantics of a transformation, scatter metamodels, models, transformation logic, and trace information across different artifacts, and provide limited verification support. To tackle these problems, we propose a Domain-Specific Language (DSL) on top of Colored Petri Nets (CPNs)–called Transformation Nets–for the execution and debugging of model transformations on a high level of abstraction. This formalism makes the afore hidden operational semantics explicit by providing a runtime model in terms of places, transitions and tokens, integrating all artifacts involved into a homogenous view. Moreover, the formal underpinnings of CPNs enable comprehensive verification of model transformations. [ABSTRACT FROM AUTHOR]

The use of several view models is a common practice to specify diverse concerns of a complex system. It is advantageous to use appropriate Domain-Specific Modeling Languages, at high-level of abstraction, to specify each concern. To actually produce the running application, it is necessary not only to transform the view-models into code, but also to compose them. We can establish at the high-level correspondence relationships between the concepts in the different concerns, but it is a complex task to compose the models at this level because we face a heterogeneous composition problem. Therefore, our strategy is to independently transform each view model into a common low-level language to perform a homogeneous composition. We create a mechanism to automatically derive correspondence relationships between the generated low-level models. These new correspondences contain the information to guide a homogeneous composition. [ABSTRACT FROM AUTHOR]

Telecom service development process followed at Orange consists of a sequence of interrelated tasks. We present an MDA tool which describes this process using SPEM 2.0 compatible graphical editor, and then associates a model to each defined task for its execution. These models are validated for conformance to functional rules embedded inside the tool. Task automation is achieved using MDA model transformations, which use Orange knowledge model as the basis to extract the existing reusable functional components and their interdependencies. Graphical editor and model transformations have been integrated together in an ECLIPSE environment. Finally, the validated functional design model is transformed towards a UML2 profile, so as the telecom architect can manipulate it in an environment he is familiar. [ABSTRACT FROM AUTHOR]

Multiformalism approaches and automatic model generation are challenging issues in the context of the analysis of critical systems for which formal verification and validation are mandatory. Reusable model transformations may reduce the skill level required in formal modeling, time and cost of the analysis process, and they may support the integration among different formal languages. This paper investigates how the relationship existing between different classes of formal languages may be exploited to define new model transformations by extending existing definitions. Specifically, the inheritance relationship is considered with the ultimate goal of achieving formalisms integration also by developing proper reusable model transformations. This idea is applied to the integration between Repairable Fault Trees and Generalized Stochastic Petri Nets, where the inheritance relationship between Fault Trees and Repairable Fault Trees is the basis to define inheritable model transformations. The described techniques are demonstrated on the availability model of a modern railway controller. [ABSTRACT FROM AUTHOR]

One of the advantages of following a MDA-based approach in the development of interactive applications is the possibility of generating multiple platform-specific user interfaces (UI) from the same platform independent UI model. However, the effort required to create the UI model may be significant. In the case of data-intensive applications, a large part of the UI structure and functionality is closely related with the structure and functionality of the domain entities described in the domain model, and the access rules specified in the use case model. This paper presents an approach to reduce the effort required to create platform independent UI models for data intensive applications, by automatically generating an initial UI model from domain and use case models. For that purpose, UML-aligned metamodels for domain and use case models are defined, together with a MOF-based metamodel for user interface models. The transformation rules that drive the UI model generation are introduced. It is also proposed a MDA-based process for the development of data intensive interactive applications based on the proposed model architecture and transformations. [ABSTRACT FROM AUTHOR]

Triple Graph Grammars (TGGs) are a well-established concept for the specification of model transformations. In previous work we have formalized and analyzed already crucial properties of model transformations like termination, correctness and completeness, but functional behaviour is missing up to now. In order to close this gap we generate forward translation rules, which extend standard forward rules by translation attributes keeping track of the elements which have been translated already. In the first main result we show the equivalence of model transformations based on forward resp. forward translation rules. This way, an additional control structure for the forward transformation is not needed. This allows to apply critical pair analysis and corresponding tool support by the tool AGG. However, we do not need general local confluence, because confluence for source graphs not belonging to the source language is not relevant for the functional behaviour of a model transformation. For this reason we only have to analyze a weaker property, called translation confluence. This leads to our second main result, the functional behaviour of model transformations, which is applied to our running example, the model transformation from class diagrams to database models. [ABSTRACT FROM AUTHOR]

Realization of Model-Driven Engineering (MDE) vision of software development requires a comprehensive and user-friendly tool support. This paper presents a UML-based approach for building trustful C# applications. UML models are refined using profiles for assigning class model elements to C# concepts and to elements of implementation project. Stereotyped elements are verified on life and during model to code transformation in order to prevent creation of an incorrect code. The Transform OCL Fragments into C# system (T.O.F.I.C.) was created as a feature of the Eclipse environment. The system extends the IBM Rational Software Architect tool. [ABSTRACT FROM AUTHOR]

This position paper describes an approach to predict the performances of a Web application already in the early stages of application development. It leverages the wealth of information of MDWE solutions to automatically obtain accurate representations of the running application in terms of layered queue networks (LQNs), i.e., analytical models simulating the behavior of the system and computing the performances mathematically. In particular, the paper discusses how a MDWE methodology can be exploited to generate such performance models and presents a proof of concept example. [ABSTRACT FROM AUTHOR]

Model-based testing can be hampered by the fact that a model depicting the system as designed does not necessarily correspond to the product as it is during development. Tests generated from such a model may be impossible to execute due to unimplemented features and already known errors. This paper presents a solution in which parts of the model can be filtered out and the remainder used to generate tests for the implemented portion of the product. In this way model-based testing can be used to gradually test the implementation as it becomes available. This is particularly important in incremental testing commonly used in industry. [ABSTRACT FROM AUTHOR]

In this paper, we propose the integrated technique related to metrics in a Model Driven Development context. More concretely, we focus on the following three topics; 1) the application of a meta modeling technique to specify formally model-specific metrics, 2) the definition of metrics dealing with semantic aspects of models (semantic metrics) using domain ontologies, and 3) the specification technique for the metrics of model transformations based on graph rewriting systems. [ABSTRACT FROM AUTHOR]

Currently, there are many problems of the application development of E-Learning platform such as the difficulty to use learning object from an LMS in another one, and the domain model reuse rate is low in various application systems, and hardness to ensure the consistency between designs and codes. These problems have constrained the development efficiency of E-Learning application software and its quality. In this paper, we proposed a model-driven development approach for E-Learning platform. First, establish the domain model (CIM) through the analysis of business logic, and then establish robustness diagram of the system after the robustness analysis. Then we stratified on the PIM under the J2EE framework, and proposed the method of transformation from PIM to PSM layer by layer. This approach not only effectively solves the above problems, but also improves the efficiency of software development through the automatically generated code. [ABSTRACT FROM AUTHOR]

Version management of business process models requires that changes can be resolved by applying change operations. In order to give a user maximal freedom concerning the application order of change operations, position parameters of change operations must be computed dynamically during change resolution. In such an approach, change operations with computed position parameters must be applicable on the model and dependencies and conflicts of change operations must be taken into account because otherwise invalid models can be constructed. In this paper, we study the concept of partially specified change operations where parameters are computed dynamically. We provide a formalization for partially specified change operations using graph transformation and provide a concept for their applicability. Based on this, we study potential dependencies and conflicts of change operations and show how these can be taken into account within change resolution. Using our approach, a user can resolve changes of business process models without being unnecessarily restricted to a certain order. [ABSTRACT FROM AUTHOR]

Dynamic UML models like sequence diagrams (SD) lack sufficient formal semantics, making it difficult to build automated tools for their analysis, simulation and validation. A common approach to circumvent the problem is to map these models to more formal representations. In this context, many works propose a rule-based approach to automatically translate SD into colored Petri nets (CPN). However, finding the rules for such SD-to-CPN transformations may be difficult, as the transformation rules are sometimes difficult to define and the produced CPN may be subject to state explosion. We propose a solution that starts from the hypothesis that examples of good transformation traces of SD-to-CPN can be useful to generate the target model. To this end, we describe an automated SD-to-CPN transformation method which finds the combination of transformation fragments that best covers the SD model, using heuristic search in a base of examples. To achieve our goal, we combine two algorithms for global and local search, namely Particle Swarm Optimization (PSO) and Simulated Annealing (SA). Our empirical results show that the new approach allows deriving the sought CPNs with at least equal performance, in terms of size and correctness, to that obtained by a transformation rule-based tool. [ABSTRACT FROM AUTHOR]

Modern business is going to be global and more complicated, rapidly evolving and requiring frequent changes. This leads the software systems growing and going more complex, widely distributed and being pressed by business for continual changes at the same time. This result the need of new methods and methodologies used for modern software development. One of such relatively new additions in the field of traditional software development is business rules and model transformation driven approach. The paper discusses existing business information systems engineering issues arising out of such additions based on running researches in the field also carried out by the authors. [ABSTRACT FROM AUTHOR]

We present the roadmap of the development of the rCOS theory and its tool support for component-based model driven software development (CB-MDD). First the motivation for using CB-MDD, its needs for a theoretical foundation and tool support are discussed, followed by a discussion of the concepts, techniques and design decisions in the research of the theory and the development of the prototype tool. The concepts, techniques and decisions discussed here have been formalized and published. References to those publications are provided with explanations. Based on the initial experiences with a case study and the preliminary rCOS tool development, further development trajectory leading to further integration with transformation and analysis plug-ins is delineated. [ABSTRACT FROM AUTHOR]

This paper presents a chain of model transformations to guide and support the application of the INGENIAS development process. The MTGenerator tool generates these transformations with a Model Transformation By-Example approach, that is, automatically from pairs of model prototypes. The MTGenerator has the advantage over similar approaches and tools of being able to generate many-to-many transformation rules between non-connected graphs of elements. The work in this paper sets the foundation for future research on software processes aided by integrated standard transformations. Two case studies illustrate the generation of transformations with the MTGenerator and its use in the process. They also show the applicability of the approach to different application domains. [ABSTRACT FROM AUTHOR]

Technological and business changes influence the evolution of software systems. When this happens, the software artifacts may need to be adapted to the changes. This need is rapidly increasing in systems built using the Model-Driven Engineering (MDE) paradigm. An MDE system basically consists of metamodels, terminal models, and transformations. The evolution of a metamodel may render its related terminal models and transformations invalid. This paper proposes a three-step solution that automatically adapts terminal models to their evolving metamodels. The first step computes the equivalences and (simple and complex) changes between a given metamodel, and a former version of the same metamodel. The second step translates the equivalences and differences into an adaptation transformation. This transformation can then be executed in a third step to adapt to the new version any terminal model conforming to the former version. We validate our ideas by implementing a prototype based on the AtlanMod Model Management Architecture (AMMA) platform. We present the accuracy and performance that the prototype delivers on two concrete examples: a Petri Net metamodel from the research literature, and the Netbeans Java metamodel. [ABSTRACT FROM AUTHOR]

Service choreographies describe the global communication protocols between services and testing these choreographies is an important task in the context of service-oriented architectures (SOA). Formal modeling of service choreographies makes a model-based testing (MBT) approach feasible. In this paper we present an MBT approach for SOA integration testing based on SAP proprietary choreography models called Message Choreography Models (MCM). In our approach, MCMs are translated into executable UML models using Java as action language. These UML models are used by a UML model execution engine developed by IBM for test generation and model debugging. We describe the achievements and challenges of our approach based on first experimental evaluation conducted at SAP. [ABSTRACT FROM AUTHOR]

Constraint programming holds many promises for model driven software development (MDSD). Up to now, constraints have only started to appear in MDSD modeling languages, but have not been properly reflected in model transformation. This paper introduces constraint programming in model transformation, shows how constraint programming integrates with QVT Relations - as a pathway to wide spread use of our approach - and describes the corresponding model transformation engine. In particular, the paper will illustrate the use of constraint programming for the specification of attribute values in target models, and provide a qualitative evaluation of the benefit drawn from constraints integrated with QVT Relations. [ABSTRACT FROM AUTHOR]

The UML-based Specification Environment (USE) tool supports syntactic analysis, type checking, consistency checking, and dynamic validation of invariants and pre-/post conditions specified in the Object Constraint Language (OCL). Due to its animation and analysis power, it is useful when checking critical non-functional properties such as security policies. However, the USE tool requires one to specify (i.e., ˵write″) a model using its own textual language and does not allow one to import any model specification files created by other UML modeling tools. Hence, to make the best use of existing UML tools, we often create a model with OCL constraints using a modeling tool such as the IBM Rational Software Architect (RSA) and then use the USE tool for model validation. This approach, however, requires a manual transformation between the specifications of two different tool formats, which is error-prone and diminishes the benefit of automated model-level validations. In this paper, we describe our own implementation of a specification transformation engine that is based on the Model Driven Architecture (MDA) framework and currently supports automatic tool-level transformations from RSA to USE. [ABSTRACT FROM AUTHOR]

Triple graph grammars (TGGs) are a formal and intuitive concept for the specification of model transformations. Their main advantage is an automatic derivation of operational rules for bidirectional model transformations, which simplifies specification and enhances usability as well as consistency. In this paper we continue previous work on the formal definition of model transformations based on triple graph rules with negative application conditions (NACs). The new notion of partial source consistency enables us to construct consistent model transformations on-the-fly instead of analyzing consistency of completed model transformations. We show the crucial properties termination, correctness and completeness (including NAC-consistency) for the model transformations resulting from our construction. Moreover, we define parallel independence for model transformation steps which allows us to perform partial-order reduction in order to improve efficiency. The results are applicable to several relevant model transformations and in particular to our example transformation from class diagrams to database models. [ABSTRACT FROM AUTHOR]

A transformation chain (TC) generates applications from high-level models that are defined in terms of problem domain concepts. The result is a low-level model that is rooted in the solution domain. The evolution of a TC is a complex and expensive endeavor since there are intricate dependencies between all its constituent parts. More specific, an evolution problem arises when we need to add an unanticipated concern (e.g., security) that does not fit the expressiveness of the high-level metamodel, because such an addition forces us to adapt existing assets (i.e., metamodels, models, and transformations). We present a solution that adds a new concern model to the TC, in an independent way. [ABSTRACT FROM AUTHOR]

Model transformations provide a powerful capability to automate model refinements. However, the use of model transformation languages may present challenges to those who are unfamiliar with a specific transformation language. This paper presents an approach called model transformation by demonstration (MTBD), which allows an end-user to demonstrate the exact transformation desired by actually editing a source model and demonstrating the changes that evolve to a target model. An inference engine built into the underlying modeling tool records all editing operations and infers a transformation pattern, which can be reused in other models. The paper motivates the need for the approach and discusses the technical contributions of MTBD. A case study with several sample inferred transformations serves as a concrete example of the benefits of MTBD. [ABSTRACT FROM AUTHOR]

Model transformations are a key technique in model-driven engineering. If several transformations are composed into a model transformation chain, an approach is needed that allows software engineers to incrementally improve the quality of the model transformation chain. In this paper, we propose incremental development of model transformation chains based on automated testing. We present four test design techniques and a test framework architecture for testing transformation chains and report on the validation of our approach when developing a transformation chain for model version management. [ABSTRACT FROM AUTHOR]

The usability of model transformation languages depends on the level of abstractions one can work with in rules to perform complex operations on models. Recently, we have introduced a novel operator for our model transformation language GReAT that allows the concise specification of complex model (graph) rewriting operations that manipulate entire subgraphs. In this paper we show how the new operator can be used to implement non-trivial model manipulations with fewer and simpler rules, while maintaining efficiency. The examples were motivated by problems encountered in real-life model transformations. [ABSTRACT FROM AUTHOR]

Meta-modeling is well known to define the basic concepts of domain-specific languages in an object-oriented way. Based on graph transformation, an abstract meta-model may be enhanced with information on concrete visualization of objects and relations, and the language syntax is defined by a graph grammar. Moreover, graph transformation can also formalize the semantic aspects of models, thus providing a basis for model validation by simulation. Apart from editing and simulating the behavior of a system, there may be necessary reconfiguration operations which change the underlying system structure at runtime. In this paper, we focus on the interrelation of simulation and reconfiguration operations using formal verification techniques based on graph transformation. Our approach is demonstrated by the definition of a domain-specific language for building, simulating and reconfiguring small railway systems, using the Tiger tool environment. For further verification, we define a model transformation from the railway domain to Petri nets. [ABSTRACT FROM AUTHOR]

Object-oriented modelling is an established approach to document the information systems. In an object model, a system is captured in terms of object types and associations, state machines, collaboration diagrams, etc. Process modeling on the other hand, provides a different approach whereby behaviour is captured in terms of activities, flow dependencies, resources, etc. These two approaches have their relative advantages. In object models, behaviour is split across object types, whereas in process models, behaviour is captured along chains of logically related tasks. Also, object models and process models lend themselves to different styles of implementation. There is an opportunity to leverage the relative advantages of object models and process models by creating integrated meta-models and transformations so that modellers can switch between these views. In this paper we define a transformation from a meta-model for object behavior modeling to a meta-model for process modeling. The transformation relies on the identification of causal relations in the object model. These relations are encoded in a heuristics net from which a process model is derived. [ABSTRACT FROM AUTHOR]

Plastic User Interfaces (UI) are able to adapt to their context of use while preserving usability. Research efforts have focused so far, on the functional aspect of UI adaptation, while neglecting the usability dimension. This paper investigates how the notion of mapping as promoted by Model Driven Engineering (MDE), can be exploited to control UI adaptation according to explicit usability criteria. In our approach, a run-time UI is a graph of models related by mappings. Each model (e.g., the task model, the Abstract UI, the Concrete UI, and the final UI) describes the UI from a specific perspective from high-level design decisions (conveyed by the task model) to low-level executable code (i.e. the final UI). A mapping between source and target models specifies the usability properties that are preserved when transforming source models into target models. This article presents a meta-model for the notion of mapping and shows how it is applied to plastic UIs. [ABSTRACT FROM AUTHOR]

Triple graph grammars (TGGs) have been invented 15 years ago as a formalism for the declarative specification of bidirectional graph-to-graph translations. In this paper we present a list of still open problems concerning the interpretation and the expressiveness of TGGs. We will comment on extensions proposed to improve the original approach and the drawbacks that arise thereof. Consequently a more precise formalization of compulsory properties of the translation of triple graph grammars into forward and backward graph translation functions is given. Regarding these properties an interpretation and implementation of negative application conditions is derived that does not destroy the benefits of the original approach. Additionally a new demand-driven forward/backward translation rule application strategy is proposed. It guarantees for the first time automatically a correct ordering of rule applications without imposing any additional requirements on the structure of the regarded graphs. [ABSTRACT FROM AUTHOR]

This paper presents a model-driven approach to the development of web applications based on the Ubiquitous Web Application (UWA) design framework, the Model-View-Controller (MVC) architectural pattern and the JavaServer Faces technology. The approach combines a complete and robust methodology for the user-centered conceptual design of web applications with the MVC metaphor, which improves separation of business logic and data presentation. The proposed approach, by carrying the advantages of Model-Driven Development (MDD) and user-centered design, produces Web applications which are of high quality from the user΄s point of view and easier to maintain and evolve. [ABSTRACT FROM AUTHOR]

In advanced XML transformer tools, XSLT rules are generated automatically after relating simple source and target XML documents. In this paper, we generalize this approach for the design of model transformations: transformation rules are derived semi-automatically from an initial prototypical set of interrelated source and target models. These initial model pairs describe critical cases of the model transformation problem in a purely declarative way. The derived transformation rules can be refined later by adding further source-target model pairs. The main advantage of the approach is that transformation designers do not need to learn a new model transformation language, instead they only use the concepts of the source and target modeling languages. [ABSTRACT FROM AUTHOR]

This paper presents a formal but practical approach for defining and using design patterns. Initially we formalize the concepts commonly used in defining design patterns using Object-Z. We also formalize consistency constraints that must be satisfied when a pattern is deployed in a design model. Then we implement the pattern modeling language and its consistency constraints using an existing modeling framework, EMF, and incorporate the implementation as plug-ins to the Eclipse modeling environment. While the language is defined formally in terms of Object-Z definitions, the language is implemented in a practical environment. Using the plug-ins, users can develop precise pattern descriptions without knowing the underlying formalism, and can use the tool to check the validity of the pattern descriptions and pattern usage in design models. In this work, formalism brings precision to the pattern language definition and its implementation brings practicability to our pattern-based modeling approach. [ABSTRACT FROM AUTHOR]