Pattern-based model transformation: a metamodel-based approach to model evolution

Software systems continue to grow in complexity at a rapid pace, creating systems that are complex to build and evolve. The problems that accompany changes in requirements, system upgrades, and error correction produce a desire for software evolution methods that increase the efficiency and effectiveness of adapting complex software to changes. As software systems evolve, design models must be modified to accommodate the required changes. Techniques that control the changes to models in a systematic manner are a key to model evolution. A process that improves the ability to effectively modify a design, thereby enhancing design qualities, supports the need for improved model evolution techniques. Design patterns are common forms of reusable design experiences. They offer solutions to common design problems, reduce complexity by naming and defining abstractions, and provide a foundation for building reusable software. Well-known pattern solutions are expressed in a natural language as fragments of code which are sometimes difficult to understand and implement by software modelers. With increased focus on development of model-driven approaches, rigorous descriptions of design patterns that capture solutions during design instead of implementation are needed. This research defines an approach for the transformation of models that supports controlled model evolution. More precisely, a process for capturing design patterns in UML class diagrams is defined. This process involves defining a metamodel-level representation which specifies how a software developer can introduce design patterns into existing design models. We defined transformation patterns as an extension of the UML metamodel to characterize source and target model elements. The transformation pattern consists of specialized metamodel elements that specify the structure of source and target metamodels. Transformation patterns were specified for the Abstract Factory, Bridge and Visitor design patterns to show how the model-level transformations can be perform on patterns that represent different functionalities. We developed an action language to specify constructs which add, delete, retrieve and connect model elements. We used the constructs of the action language to define transformation specifications that implement model-level transformations on class diagrams. To determine the potential of this approach we manually implemented the transformation specification on a UML design

Enforcement of Patterns by Constraint-Aware Model Transformations

Patterns are descriptions and solutions for recurring problems in software design and implementation. In this paper, some ideas towards a formal approach to the specification of patterns in model-driven engineering (MDE) is presented. The approach is based on the Diagram Predicate Framework which provides a formal approach to (meta)modelling, model transformation and model management in MDE. In particular, patterns are defined as diagrammatic specifications and constraint-aware model transformations are adapted to enforce patterns. Moreover, running examples are used to illustrate the facade design pattern in structural models

Formal and efficient verification techniques for Real-Time UML models

The real-time UML profile TURTLE has a formal semantics expressed by translation into a timed process algebra: RT-LOTOS. RTL, the formal verification tool developed for RT-LOTOS, was first used to check TURTLE models against design errors. This paper opens new avenues for TURTLE model verification. It shows how recent work on translating RT-LOTOS specifications into Time Petri net model may be applied to TURTLE. RT-LOTOS to TPN translation patterns are presented. Their formal proof is the subject of another paper. These patterns have been implemented in a RT-LOTOS to TPN translator which has been interfaced with TINA, a Time Petri Net Analyzer which implements several reachability analysis procedures depending on the class of property to be verified. The paper illustrates the benefits of the TURTLE->RT-LOTOS->TPN transformation chain on an avionic case study

Category Theory and Model-Driven Engineering: From Formal Semantics to Design Patterns and Beyond

There is a hidden intrigue in the title. CT is one of the most abstract mathematical disciplines, sometimes nicknamed "abstract nonsense". MDE is a recent trend in software development, industrially supported by standards, tools, and the status of a new "silver bullet". Surprisingly, categorical patterns turn out to be directly applicable to mathematical modeling of structures appearing in everyday MDE practice. Model merging, transformation, synchronization, and other important model management scenarios can be seen as executions of categorical specifications. Moreover, the paper aims to elucidate a claim that relationships between CT and MDE are more complex and richer than is normally assumed for "applied mathematics". CT provides a toolbox of design patterns and structural principles of real practical value for MDE. We will present examples of how an elementary categorical arrangement of a model management scenario reveals deficiencies in the architecture of modern tools automating the scenario.Comment: In Proceedings ACCAT 2012, arXiv:1208.430

On the Verification of a WiMax Design Using Symbolic Simulation

In top-down multi-level design methodologies, design descriptions at higher levels of abstraction are incrementally refined to the final realizations. Simulation based techniques have traditionally been used to verify that such model refinements do not change the design functionality. Unfortunately, with computer simulations it is not possible to completely check that a design transformation is correct in a reasonable amount of time, as the number of test patterns required to do so increase exponentially with the number of system state variables. In this paper, we propose a methodology for the verification of conformance of models generated at higher levels of abstraction in the design process to the design specifications. We model the system behavior using sequence of recurrence equations. We then use symbolic simulation together with equivalence checking and property checking techniques for design verification. Using our proposed method, we have verified the equivalence of three WiMax system models at different levels of design abstraction, and the correctness of various system properties on those models. Our symbolic modeling and verification experiments show that the proposed verification methodology provides performance advantage over its numerical counterpart.Comment: In Proceedings SCSS 2012, arXiv:1307.802

UML Transformation to Java-based Software Product Lines

Software product line engineering (SPLE) is an emerging approach that enables variability management in software development. SPLE offers tremendous benefits, but lack of tool support becomes a barrier in the adoption of SPLE. Variability modules for Java (VMJ) is an implementation approach that is defined based on the variability modules (VM) concept to support SPLE. VMJ combines Java modules system and design patterns that are commonly used by software developers. VMJ is accompanied by a UML profile, called UML-VM profile, which extends UML notation to model variability in the UML diagram. UML-VM diagram is used to model the problem domain, and VMJ is used in the domain implementation. In this research, we design a model transformation from Unified Modeling Language (UML) diagram into VMJ. The transformation rules are defined based on the UML-VM profile and implemented in the Eclipse Acceleo model to text transformation. As a result, a UML diagram can be transformed automatically into Java-based software product lines. The transformation tool is evaluated using a case study by comparing the generated code and the actual implementation

Motrusca : interactive model transformation use case repository

Modeling and model transformations tools are maturing and are being used in larger and more complex projects. The advantage of a modeling environment and its transformation tools cannot be easily exploited by non-expert users as many subtle intricacies determine the efficiency of transformation languages and their tools. We introduce transformation use case examples that highlight such language/tooling properties. These simple, non-trivial examples have been extracted from an experiment with transformations of Design Space Exploration models. These examples show some typical modeling patterns and we give some insight how to address the examples. We make a case for initiating an interactive, on-line repository for model transformation use cases. This repository is aimed to be example-centric and should facilitate the interaction between end-users and tooling developers, while providing a means for comparing the applicability, expressivity, and efficiency of transformation tools