Object Oriented and Rule-based Design of Visual Languages using Tiger

In this paper we present the state-of-the-art of the TIGER environment for the generation of visual editor plug-ins in Eclipse, with the focus on its Designer component, a visual environment for object oriented and rule-based design of visual languages. Based on an alphabet for finite automata we show how a visual language can be designed by defining the abstract and concrete syntax of the visual language and syntax directed editing operations in the generated editor plug-in. For the graphical layout we use the Graphical Editing Framework (GEF) of ECLIPSE which offers an efficient and standardized way for graphical layouting

Ludo: A Case Study for Graph Transformation Tools

In this paper we describe the Ludo case, one of the case studies of the AGTIVE 2007 Tool Contest (see [22]). After summarising the case description, we give an overview of the submitted solutions. In particular, we propose a number of dimensions along which choices had to be made when solving the case, essentially setting up a solution space; we then plot the spectrum of solutions actually encountered into this solution space. In addition, there is a brief description of the special features of each of the submissions, to do justice to those aspects that are not distinguished in the general solution space

Generation of Simulation Views for Domain Specic Modeling Languages based on the Eclipse Modeling Framework

The generation of tools for domain specific modeling languages (DSMLs) is a key issue in model-driven development. Various tools already support the generation of domain-specific visual editors from models, but tool generation for visual behavior modeling languages is not yet supported in a satisfactory way. In this paper we propose a generic approach to specify DSML environments visually by models and transformation rules based on the Eclipse Modeling Framework (EMF). Editing rules define the behavior of generated visual editors, whereas simulation rules describe a model's operational semantics. From a DSML definition (model and transformation rules), an Eclipse plug-in is generated, implementing a visual DSML environment including an editor and (possibly multiple) simulators for different simulation views on the model. We present the basic components of Tiger2, our EMF-based generation environment, and demonstrate the environment generation process for a small DSML modeling the behavior of ants in an ant hill

Refactoring of UML models using AGG

Model refactoring is an emerging research topic that is heavily inspired by refactoring of object-oriented programs. Current-day UML modeling environments provide poor support for evolving UML models and applying refactoring techniques at model level. As UML models are intrinsically graph-based in nature we propose to use graph transformations to specify and apply model refactoring. More in particular, we use a specific graph transformation tool, AGG, and provide recommendations of how AGG may be improved to better support model refactoring. These recommendations are based on a small experiment that we have carried out with refactoring of UML class diagrams and state machines

Graph Modelling and Transformation: Theory meets Practice

In this paper, we focus on the role of graphs and graph transformation for four practical application areas from software system development. We present the typical problems in these areas and investigate how the respective systems are modelled by graphs and graph transformation. In particular, we are interested in the usefulness of theoretical graph transformation results and graph transformation tools in order to solve these problems. Finally, we characterize concepts and tool features which are still missing in practice to solve the presented and related problems even better. Keywords: graph modelling, graph transformation, graph transformation tool

Semantic networks

AbstractA semantic network is a graph of the structure of meaning. This article introduces semantic network systems and their importance in Artificial Intelligence, followed by I. the early background; II. a summary of the basic ideas and issues including link types, frame systems, case relations, link valence, abstraction, inheritance hierarchies and logic extensions; and III. a survey of ‘world-structuring’ systems including ontologies, causal link models, continuous models, relevance, formal dictionaries, semantic primitives and intersecting inference hierarchies. Speed and practical implementation are briefly discussed. The conclusion argues for a synthesis of relational graph theory, graph-grammar theory and order theory based on semantic primitives and multiple intersecting inference hierarchies

VisualLISA: a domain specific visual language for attribute grammars

The focus of this paper is on the translation of AG formalisms into a new visual language, and on the development of the associated programming environment. We present a solution for rapid development of VisualLISA editor using DEViL . This tool uses traditional attribute grammars, to specify the language’s syntax and semantics, extended by visual representations to be associated with grammar symbols. From these specifications a visual programming environment is automatically generated. This environment allows us to edit a visual description of an AG that is automatically translated into textual notations. In this paper, we emphasize the design and implementation of VisualLISA that is intended to be helpful for beginners and rapid development of small AG s.CCTC - Universidade do Minh

Verification of Architectural Refactorings: Rule Extraction and Tool Support

Software in use needs to be adapted to changing requirements, otherwise it becomes obsolete. Often, this involves changing the architecture of the system. To avoid the introduction of unwanted or removal of desired behaviour, these changes need verification. While verifying large systems consumes considerable resources, the verification of only the changed parts can, under certain conditions, give the required assurance. This opens the possibility of creating formally verified, reusable refactoring patterns. However, a mechanism for extracting such patterns is needed. To address this problem, a theoretical framework is presented that allow to formally reason about the rule extraction process. In order to harness the theoretical results, a visual editor and tool chain are introduced to aid developers in extracting refactoring rules and prove their behavioural correctness