Albert Zündorf

Story Diagrams: A New Graph Rewrite Language Based on the Unified Modeling Language and Java

Graph grammars and graph rewrite systems improved a lot towards practical usability during the last years. Nevertheless, there are still major problems to overcome in order to attract a broad number of software designers and developers to the usage of graph grammars and graph rewrite systems. Two of the main problems are, (1) that current graph grammar notations are too proprietary and (2) that there exists no seamless integration of graph rewrite systems with common (OO) design and implementation languages like UML and C++ or Java.

The FUJABA environment

Fujaba is an acronym for From UML to Java And Back Again. The Fujaba environment aims to provide round-trip engineering support for UML and Java. The main distinction to other UML tools is its tight integration of UML class and UML behavior diagrams to a visual programming language. Our use of UML allows to model operations on graph-like object structures on a high-level of abstraction and leverages the user from programming with plain references at code level. Code generation from class diagrams is widely known and supported by most modern CASE tools. However, code generation from class diagrams creates class frames and method declarations without bodies, only. The actual work remains unsupported. The paper considers how Fujaba generates code from collaboration diagrams. It presents an example session.

Integrating UML diagrams for production control systems

The paper proposes to use SDL block diagrams, UML class diagrams, and UML behavior diagrams like collaboration diagrams, activity diagrams, and statecharts as a visual programming language. We describe a modeling approach for flexible, autonomous production agents, which are used for the decentralization of production control systems. In order to generate a (Java) implementation of a production control system from its specification, we define a precise semantics for the diagrams and we define how different (kinds of) diagrams are combined to a complete executable specification. Generally, generating code from UML behavior diagrams is not well understood. Frequently, the semantics of a UML behavior diagram depends on the topic and the aspect that is modeled and on the designer that created it. In addition, UML behavior diagrams usually model only example scenarios and do not describe all possible cases and possible exceptions. We overcome these problems by restricting the UML notation to a subset of the language that has a precise semantics. In addition, we define which kind of diagram should be used for which purpose and how the different kinds of diagrams are integrated to a consistent overall view.

Graph Grammar Engineering with PROGRES

Graph-like data structures and rule-based systems play an important role within many branches of computer science. Nevertheless, their symbiosis in the form of graph rewriting systems or graph grammars are not yet popular among software engineers. This is a consequence of the fact that graph grammar tools were not available until recently and of the lack of knowledge about how to use graph grammars for software development purposes. “Graph grammar engineering” is a first attempt to establish a new graph and rule centered methodology for the development of information system components. Having its roots in the late 80s it gradually evolved from a “paper and pencil” specification formalism to a tool-assisted specification and rapid prototyping approach.

A study on the current state of the art in tool-supported UML-based static reverse engineering

Today, software-engineering research and industry alike recognize the need for practical tools to support reverse-engineering activities. Most of the well-known CASE tools support reverse engineering in some way. The Unified Modeling Language (UML) has emerged as the de facto standard for graphically representing the design of object-oriented software systems. However, there does not yet exist a standard scheme for representing the reverse-engineered models of these systems. The various CASE tools usually adopt proprietary extensions to UML and, as a result, it is difficult, or even impossible, to ensure that model semantics remains unambiguous when working with different tools at the same time. In this paper, we examine the capabilities of the two most successful industrial-strength CASE-tools in reverse engineering the static structure of software systems and compare them to the results produced by two academic prototypes. The comparisons are carried out both manually and automatically using a research prototype for manipulating and comparing UML models.

Graph Pattern Matching in PROGRES

The work reported here is part of the PROGRES (PROgrammed Graph Rewriting Systems) project. PROGRES is a very high level multi paradigm language for the specification of complex structured data types and their operations. The data structures are modelled as directed, attributed, node and edge labeled graphs (diane graphs). The basic programming constructs of PROGRES are graph rewriting rales (productions and tests) and derived relations on nodes (paths and restrictions).

Tool integration at the meta-model level: the Fujaba approach

Today’s development processes employ a variety of notations and tools, e.g., the Unified Modeling Language UML, the Standard Description Language SDL, requirements databases, design tools, code generators, model checkers, etc. For better process support, the employed tools may be organized within a tool suite or integration platform, e.g., Rational Rose or Eclipse. While these tool-integration platforms usually provide GUI adaption mechanisms and functional adaption via application programming interfaces, they frequently do not provide appropriate means for data integration at the meta-model level. Thus, overlapping and redundant data from different “integrated” tools may easily become inconsistent and unusable. We propose two design patterns that provide a flexible basis for the integration of different tool data at the meta-model level. To achieve consistency between meta-models, we describe rule-based mechanisms providing generic solutions for managing overlapping and redundant data. The proposed mechanisms are widely used within the Fujaba Tool Suite. We report about our implementation and application experiences .

Using Graph Transformation for Practical Model Driven Software Engineering

Model transformations are one of the core technologies needed to apply OMG’s model-driven engineering concept for the construction of real-world systems. Several formalisms are currently proposed for the specification of these model transformations. A suitable formalism is based on graph transformation systems and graph transformation rules. The chapter provides an overview about the needed concepts to apply graph transformations in the context of model driven engineering and we show the technical feasibility based on several tools and applications.

Generic fuzzy reasoning nets as a basis for reverse engineering relational database applications

Object-oriented technology has become mature enough to satisfy many new requirements coming from areas like computer-aided design (CAD), computer-integrated manufacturing (CIM), or software engineering (SE). However, a competitive information management infrastructure often demands to merge data from CAD-, CIM-, or SE-systems with business data stored in a relational system. One approach for seamless integration of objectoriented and relational systems is to migrate from a relational to an objectoriented system. The first step in this migration process is reverse engineering of the legacy database. In this paper we propose a new graphical and executable language called Generic Fuzzy Reasoning Nets for modelling and applying reverse engineering knowledge. In particular, this language enables to define and analyse fuzzy knowledge which is usually all what is available when an existing database schema has to be reverse engineered into an object-oriented one. The analysis process is based on executing a fuzzy petri net which is parameterized with the fuzzy knowledge about a concrete database application.

Visual programming with graph rewriting systems

The multi-paradigm language PROGRES is the first rule-oriented visual language which has a well-defined type concept and supports programming with graph rewriting systems. To some extent, it has the flavor of a visual database programming language with powerful pattern matching and replacing facilities as well as backtracking capabilities. Until now, it was mainly used for specifying and rapid prototyping of abstract data types in software engineering environments. An integrated set of language-specific tools supports intertwined editing, analyzing, browsing, and debugging of specifications as well as generating prototypes in C (Modula-2) with Tcl/Tk-based user interfaces.