Generating tools from graph-based specifications

Abstract

This paper describes an approach for generating graphical, structure-oriented software engineering tools from graph-based specifications. The approach is based on the formal meta modeling of visual languages using graph rewriting systems. Besides the syntactical and semantical rules of the language, these meta models include knowledge from the application domains. This enables the resulting tools to provide the user with high level operations for editing, analysis and execution of models. Tools are constructed by generating source code from the meta model of the visual language, which is written in the very high level programming language PROGRES. The source code is integrated into a framework which is responsible for the invocation of commands and the visualization of graphs. As a case study, a visual language for modeling development processes together with its formal meta model is introduced. The paper shows how a process management tool based on this meta model is generated and reports on our experiences with this approach.

Introduction

Construction of software engineering tools has been a busy area of research and development. Over the years, a wide range of technologies has been developed to make tool construction easier. In particular, base technologies have attracted much attention. This includes, e.g. object management systems for data integration [1], distributed infrastructures for communication integration [2], user interface toolkits for presentation integration [3], and broadcast message servers [4] for control integration.

Even though base technologies provide considerable leverage, tool builders still face difficult problems in tool construction. In particular, this holds for the construction of structure-oriented, intelligent tools operating on complex objects. In the 1980s, this problem was partially addressed by integrated programming environments and meta environments for generating tools from language descriptions [5]. In these environments, programs are internally represented as abstract syntax trees. Syntax-aided editors manipulate the internal representation; incremental error checking and code generation is handled, e.g. by attribute grammars.

Integrated programming environments have a restricted focus in that they mainly address programs (or other textual documents which at least have a well-defined syntax). However, many software documents, in particular those produced in earlier phases of the software life cycle, are based on graphical languages (e.g. CASE tools for the UML). Often, these tools are constructed in an ad hoc manner on top of user interface tool kits. Usually, these tool kits have no understanding of the semantics of the objects which are handled by the tool.

Above this level, generators for graphical editors allow the generation of tools from a description of a graphical language. Often, the language description merely defines the types of objects and links as well as their visualization on the screen [6], [7]. The generated editor then offers basic commands for creating and deleting objects and links, for graph layout, etc.

There are also systems which are based on a formal specification of an underlying meta model [8]. By adapting the meta model, structural knowledge from the application domains can be incorporated into the generated tools. Though this approach supports the construction of domain specific tools and the automated checking of structural constraints, it is restricted in that it does not cover complex commands for analyzing and transforming graphs.

In this paper, we report on a framework which addresses these shortcomings. Our tool specifications are based on programmed graph rewriting. They are written in the specification language PROGRES [9], [10] which combines concepts from database systems, procedural and rule-based programming. The graph structure is specified by a graph schema which defines types of nodes, edges, and attributes. Graph transformations are described by graph rewrite rules which essentially consist of a left-hand side—the graph pattern to be replaced—and a right-hand side—the replacing graph pattern. Programming with graph rewrite rules is supported by control structures such as sequence, branch, loop. From PROGRES specifications, we may generate graphical tools offering complex commands for replacing subgraphs rather than commands operating at the level of single objects and links.

The writers of PROGRES specifications are supported by an integrated development environment which offers structure-oriented tools for editing, analysis, and interpreting. After the specifications has been developed and tested in the PROGRES meta environment, a graphical tool may be generated from the specification. Since the PROGRES development environment has been described extensively elsewhere [11], our presentation will focus on the tools generated from the specification.

As a case study, we will use tools for managing software development processes. It is widely known that software processes are difficult to manage and sophisticated tools are required for planning, enactment, monitoring, or tracing (see Ref. [12] for a survey). Our own approach is based on dynamic task nets, which continuously evolve during enactment due to changing product structures, feedback, alternative task realizations, concurrent/simultaneous engineering, etc. Commands for building up task nets, for enacting the tasks, or for analyzing the current state of the project are specified by a programmed graph rewriting system of considerable size and complexity [13].

This paper is structured as follows: Section 2 gives an introduction to the application domains of graph-based tools. Process modeling is taken as an example to show how to get from the informal concept of a visual language (Section 2.1) by formalizing the concept (Section 2.2) to a structure-oriented tool. Section 3 describes the architecture of our tools and how they are generated from a formal specification, Section 4 reports on our experiences. Section 5 is the conclusion.