Improving Bigraph Rewriting with GrGen.NET to Enable Efficient System Simulation

An important requirement of model transformations is the preservation of the behavior of the original model. A model transformation is semantically correct if for each simulation run of the source system we find a corresponding simulation run in the target system. Analogously, we have semantical completeness, if for each simulation run of the target system we find a corresponding simulation run in the source system. In our framework of graph transformation, models are given by graphs, and graph transformation rules are used to define the operational behavior of visual models (called simulation rules). In order to compare the semantics of source and target models, we assume that in both cases operational behavior can be defined by simulation rules. The model transformation from source to target models is given by another set of graph transformation rules. These rules are also applied to the simulation rules of the source model. The result of this rule transformation is compared with the given simulation rules of the target language.The main result in this paper states the conditions for model and rule transformations to be semantically correct and complete. The result is applied to analyze the behavior of a model transformation from a domain-specific visual language for production systems to Petri nets.

A survey and comparison of transformation tools based on the transformation tool contest

An important requirement of model transformations is the preservation of the behavior of the original model. A model transformation is semantically correct if for each simulation run of the source system we find a corresponding simulation run in the target system. Analogously, we have semantical completeness, if for each simulation run of the target system we find a corresponding simulation run in the source system.In our framework of graph transformation, models are given by graphs, and graph transformation rules are used to define the operational behavior of visual models (called simulation rules). In order to compare the semantics of source and target models, we assume that in both cases operational behavior can be defined by simulation rules. The model transformation from source to target models is given by another set of graph transformation rules. These rules are also applied to the simulation rules of the source model. The main result in this paper states the conditions for model and rule transformations to be semantically correct and complete. The result is applied to analyze the behavior of a model transformation from a domain-specific visual language for production systems to Petri nets.KeywordsModel TransformationRule TransformationOperational SemanticTarget ModelGraph TransformationThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The design of programming languages has always been an important topic in the field of programming language theory. However, most attention on programming language research focuses on compiler technology, while much less on language design. In this paper, we select multiple modern programming languages (MPLs) and systematically analyzed their designs from an application-oriented view. Concretely, we conduct the evaluation of their programming paradigms, type systems, and language performances based on benchmarking tests. Through these analyses combining theory and practice, the relationship between programming language design and its application scenarios is revealed, and the future developing trend of programming languages can be disclosed.

Applying a Model Transformation Taxonomy to Graph Transformation Technology

Current software development practices, including those specified in DOD-STD-2167, frequently prescribe the use of program design languages (PDLs) during preliminary and critical design. Lockheed has developed an Ada design language (ADL) that supports management goals such as cost reduction, process control, and evaluation by customers during the entire software development life-cycle.The literature shows the many ways that Ada-based PDLs support software engineering goals1 like modularity, readability, loose coupling, strong cohesion, and data abstraction2. A negative aspect of many previous Ada-based PDLs is that the languages tend to allow developers and designers to provide too much detail early in the life-cycle, as the full Ada language is allowed by these design languages. This detail can cause harmful early focus on “how” the functionality is implemented, at the expense of considering “what” functionality is required. Managers and their customer counterparts may find it impractical to master all the facets of the full Ada programming language, and therefore may not understand the designs represented by a full Ada-based design language. Other deficiencies of full Ada-based design languages include the lack of a clear distinction between ADL as a language, and support for that language via tools, as well as the absence of clear connection to life-cycle milestones. Industry writers recently3 have observed that the connectivity of the PDL and milestones remains unclear.

1. Introduction. Much of the software life cycle is realized through ProgrammQ ~guages. The structure of the particular programming language used to implement a system can influence the effort expended at some of the different phases of the life cycle. This impact is particularly evident in phases such as maintenance that deal with completed code. For example, the presence of certain code structuring units in a language is generally thought to improve the readability of programs that employ them [l]. However, the impact that language structure has on the design process is less clear cut. The stepwise refmement of pseudocode is a common mechanism for program design in a variety of languages. Yet, the effects of a language’s structure on the refinement process has not been quantitatively docu- mented. The need for such assessment is particularly acute in light of the fact that many new program design languages (PDL) support the syntactic constructs of a particular target language. For example, the Ada programming language is the basis for at least six available or planned program design languages [2]. parisons were based upon language properties such as syntac- tic structure [3], semantic psychological com- plexity [4,5,6], and relevance to particular application do- mains [7]. Here, the comparison between languages will be made using syntactic complexity, as measured in terms of the context free grammar for the languages. The motivation using context free grammars is that the stepwise refinement process takes place in the context of a language’s syntactic structure. That is, the replacement of a stub in pseudocode program is constrained by the grammar in the target language. The nature of these constraints will be described in terms the following model of the stepwise refinement process. The general question addressed in the paper is: how does the syntactic structure of a program design language affect the decision making effort associated with the stepwise refinement process. A model. of the stepwise refinement process is presented that explicitly ties the grammatical strut- ture of the pseudocode design language into the stepwise refinement activity. This allows the development of refme- ment metrics that assess the decision making complexity of a refinement step in terms of the underlying syntactic structure of the grammar for the program design language. In this model it is assumed that the program design language employed in the stepwise refinement process is based upon a context free grammar for the target language. This is consistent with our current objective of measuring target language support for the stepwise refinement process. However, in general the model does not require that program design language correspond precisely with the gram- mar for the target language. A context free language is defined as G =cT,N,P,S> where T is the set of terminals, N is the set of nonterminals, P is set productions form A::=w where A is an element of N and w is in V* where the vocabu- lary V = (T U N), and S is the start symbol. A pseudocode program can therefore be considered as a collection of termi- nal symbols in the target language along with a collection of stub names. Each stub in the pseudocode corresponds to a high level implementation goal that still needs to be achieved by the designer. It is also assumed that the designer associates each high level implementation goal with a low level goal of implementing a corresponding language structure taken from the set of nonterminals in the grammar for the language. As a result the stepwise refinement process can be viewed as taking place at both a semantic level and a syntactic one. 2. Metrics to Measure Language Support for the Stepwise Refinement Process. Historically, programming languages have been compared from several different perspectives. These com-

Preface: Volume 16, Issue 3

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.

Triple Graph Grammars (TGGs) are a rule-based technique with a formal background for specifying bidirectional model transformation and, hence, can be applied to transform a given model into another and vice versa. In practice, models are either created from scratch by using a single input model, or incrementally synchronized by propagating changes between integrated models. The outstanding property of incremental model synchronization is that in average only small portions of the whole model have to be retransformed as mostly only a subset of a model has been changed. Hence, we have the opportunity to (i) improve efficiency of model transformations and (ii) to retain as much information as possible. Regarding information preserving capabilities, this offers the chance to qualitatively improve the results of model transformations. This is because additional model content (e.g., model elements or user specific decision during the actual transformation process), which is not covered by the model transformation itself, will be mostly retained. In practical scenarios, unidirectional rules for incremental forward and incremental backward transformation are automatically derived from the specified TGG rules, and the overall transformation process is governed by a control algorithm. Current incremental approaches either have a runtime complexity that depends on the size of related models and not on the number of changes and their affected elements, or do not pursue formalization to give reliable predictions regarding the expected results, or impose such restrictions on the language of TGGs that the remaining expressiveness is not capable of certain real-world scenarios. For these reasons, the aim of this thesis is to develop a novel approach to incremental model synchronization with TGGs that (i) is efficient regarding the number of changes, (ii) retains as much information as possible, (iii) complies with important formal properties, and (iv) is expressive enough for real-world scenarios. Therefore, we introduce an incremental model synchronization algorithm for TGGs, which employs a static analysis on TGG specifications to efficiently determine the range of influence of model changes at runtime and, thus, to regard only these elements for synchronization. Together with further improvements and critical discussions we will be able to show that this approach is a suitable means for complex model synchronization tasks.

Computer automated multi-paradigm modelling based on meta-modelling and graph transformation is presented. The syntax of a class of models of interest is graphically meta-modelled in an appropriate formalism such as entity-relationship diagrams. From this abstract syntax, augmented with concrete (visual) information, an interactive, visual modelling environment is generated. As the abstract syntax of all models is graph-like, graph rewriting is used to perform model transformation. Graph grammar models thus allow for model transformation specification. Graph rewriting provides a rigourous basis for specifying and analyzing model transformations such as simplification, simulation, and code generation. AToM/sup 3/, a tool for multi-formalism and meta-modelling, is introduced. Meta-modelling and graph transformation concepts are introduced through a simple reactive system example: a timed automata model of a traffic light. Meta-modelling, generating the visual modelling environment, and modelling transformations as graph grammars, as well as executing them, are performed in AToM/sup 3/. The model transformations include simulation, transformation into timed transition Petri nets, and code generation.

In this paper we define recursive rules in the double pushout approach (DPO) to graph transformation. Classical DPO rules are extended with a base case condition and a recursion condition. Mechanisms are provided to pass the match from both conditions to the rule's left hand side, and also between two consecutive steps in the recursion. The approach is useful when recursive structures (such as inheritance hierarchies, nested component hierarchies, networks of functional blocks, etc.) have to be processed. Although we present the recursion for DPO, it can also be adapted to other approaches to graph and model transformation. We present examples for model transformation, model simulation and model optimization in different application domains.

Model transformation is one of the key activities in model-driven software development. An increasingly popular technology to define modeling languages is provided by the Eclipse Modeling Framework (EMF). Several EMF model transformation approaches have been developed, focusing on different transformation aspects. To validate model transformations with respect to functional behavior and correctness, a formal foundation is needed. In this paper, we define consistent EMF model transformations as a restricted class of typed graph transformations using node type inheritance. Containment constraints of EMF model transformations are translated to a special kind of graph transformation rules such that their application leads to consistent transformation results only. Thus, consistent EMF model transformations behave like algebraic graph transformations and the rich theory of algebraic graph transformation can be applied to these EMF model transformations to show functional behavior and correctness. Furthermore, we propose parallel graph transformation as a suitable framework for modeling EMF model transformations with multi-object structures. Rules extended by multi-object structures can specify a flexible number of recurring structures. The actual number of recurring structures is dependent on the application context of such a rule. We illustrate our approach by selected refactorings of simplified statechart models. Finally, we discuss the implementation of our concepts in a tool environment for EMF model transformations.

Many software applications involve models of data that are manipulated by the application. There is often a need to transform (or translate) the data from one model, into another in which the data is differently structured. In addition, there is an increasing requirement to pass data between different applications, which invariably have different formats for their data models. Both of these issues require a translation of the modelled data from one form to another. The process of translating a model from one form to another is known as model transformation or model translation. The literature on model transformation includes a number of techniques for specifying transformations. However, the majority of these techniques are grammar-based specifications, many of which use a textual grammar, although some make use of graphical (graph) grammars. These subsequently lead to a monolithic one-step implementation process that performs the transformation. This thesis addresses two issues that are related to the area of model transformation. Firstly, it addresses the need for a standard notation that can be used for writing model translator specifications. Secondly, a technique for implementing model translators is developed that actively performs the transformation. Rather than a single step process, that must be executed every time the source model changes, the active implementation approach presented performs a continuous translation updating the target model every time a change is made to the source model. The specification technique makes use of the standardised Unified Modelling Language (UML) and Object Constraint Language (OCL) for specifying a transformation relationship between two object-oriented models, each of which is also specified using UML and OCL. The implementation approach uses an event-based version of the observer pattern enabling the construction of translator to be formed from a number of mini-translator parts, each of which monitors a small set of components. These mini-translators act upon events generated by the model components and update the transformed components to reflect the changes. The specification and implementation techniques described can be applied to many problem areas. In particular this thesis discusses their application to Multiple View Visual Languages (i.e. the UML itself) and automatic performance model generation.

Topological consistency preservation with graph transformation schemes