501 research outputs found
Tool Modeling with Fujaba
AbstractThis paper is a small tutorial on tool building with Fujaba. With the help of a small case study, we exemplify how the different requirements of an environment for a visual language may be addressed using Fujaba graph transformations. This covers abstract and concrete syntax, static and operational semantics, and model transformations. This case study shows, how the more sophisticated language elements of Fujaba may be exploited in modeling complex aspects of the desired CASE tool. In addition, we address some not graph grammar related aspects in building such an environment, e.g. the graphical user interface and multi-user support
eDOBS - Graphical Debugging for Eclipse
This paper presents the eDOBS tool. eDOBS is the little brother of the Fujaba environment. While Fujaba is used to create graph grammar based specifications and programs, eDOBS is used to browse graphs, to edit graphs, and to execute graph transformations
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
Strategic programming on graph rewriting systems
We describe a strategy language to control the application of graph rewriting
rules, and show how this language can be used to write high-level declarative
programs in several application areas. This language is part of a graph-based
programming tool built within the port-graph transformation and visualisation
environment PORGY.Comment: In Proceedings IWS 2010, arXiv:1012.533
Modelling and Analysis Using GROOVE
In this paper we present case studies that describe how the graph transformation tool GROOVE has been used to model problems from a wide variety of domains. These case studies highlight the wide applicability of GROOVE in particular, and of graph transformation in general. They also give concrete templates for using GROOVE in practice. Furthermore, we use the case studies to analyse the main strong and weak points of GROOVE
Towards a Step Semantics for Story-Driven Modelling
Graph Transformation (GraTra) provides a formal, declarative means of
specifying model transformation. In practice, GraTra rule applications are
often programmed via an additional language with which the order of rule
applications can be suitably controlled.
Story-Driven Modelling (SDM) is a dialect of programmed GraTra, originally
developed as part of the Fujaba CASE tool suite. Using an intuitive,
UML-inspired visual syntax, SDM provides usual imperative control flow
constructs such as sequences, conditionals and loops that are fairly simple,
but whose interaction with individual GraTra rules is nonetheless non-trivial.
In this paper, we present the first results of our ongoing work towards
providing a formal step semantics for SDM, which focuses on the execution of an
SDM specification.Comment: In Proceedings GaM 2016, arXiv:1612.0105
Evaluation of Kermeta for Solving Graph-based Problems
Kermeta is a meta-language for specifying the structure and behavior of graphs of interconnected objects called models. In this paper,\ud
we show that Kermeta is relatively suitable for solving three graph-based\ud
problems. First, Kermeta allows the specification of generic model\ud
transformations such as refactorings that we apply to different metamodels\ud
including Ecore, Java, and Uml. Second, we demonstrate the extensibility\ud
of Kermeta to the formal language Alloy using an inter-language model\ud
transformation. Kermeta uses Alloy to generate recommendations for\ud
completing partially specified models. Third, we show that the Kermeta\ud
compiler achieves better execution time and memory performance compared\ud
to similar graph-based approaches using a common case study. The\ud
three solutions proposed for those graph-based problems and their\ud
evaluation with Kermeta according to the criteria of genericity,\ud
extensibility, and performance are the main contribution of the paper.\ud
Another contribution is the comparison of these solutions with those\ud
proposed by other graph-based tools
RePLEX: A Model-Based Reengineering Tool for PLEX Telecommunication Systems
Maintenance of complex legacy software systems is a challenging task. In the first place, maintenance requires understanding the system. Reverse engineering and reengineering tools, which make the design of the current system available on-line and which support planning and performing changes to the system, are urgently needed. We present a new tool for reengineering telecommunication systems, recovering the current architecture, and extracting state machines reflecting the system behavior. The tool is based on a structure graph of the architecture and allows architectural modifications with according code changes. The modifications are specified as graph transformations using FUJABA enabling the generation of a Java prototype, which is accessible via a GUI based on the Graphical Editor Framework (GEF) plug-in for the Eclipse workbench
Improved Flexibility and Scalability by Interpreting Story Diagrams
In this paper, we present an interpreter for Story Diagrams working on Eclipse Modeling Framework (EMF) models. The interpreter provides a more flexible and, under certain circumstances, a more scalable solution than the compiled Java code generated from Story Diagrams by Fujaba. of Dynamic EMF even allows the evolution of meta models at runtime. Story Diagrams can now be modeled and executed within Eclipse. They can be modified and re-executed by the Story Diagram interpreter immediately without recompiling the source code and restarting the application. Our implementation also supports higher-order transformations by using Story Diagrams to modify other Story Diagrams. generation is not applicable, like running systems. While interpretation obviously results in performance drawbacks, we demonstrate that the Story Diagram interpreter is able to improve the performance in certain worst-case situations compared to the average generated code. This is achieved by a dynamic ordering of the matching process, which considers the actual number of elements in an association at runtime. Such a dynamic ordering can minimize the matching effort considerably. In contrast, Fujaba generated code uses a static matching strategy. Whereas the Fujaba Story Diagrams have potentially high performance fluctuations, the performance of the Story Diagram interpreter is steadier and more scalable compared to the generated Java code
- âŚ