Generating tools from graph-based specifications
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.
Section snippets
Application domains of graph-based tools
Our approach has been applied in several domains during recent years. Among these is the reengineering of information systems [14] within the Varlet project. It is aimed at the development of tool support for an explorative and evolutionary reengineering process and the automatic generation of a middleware for object-oriented client/server information systems.
The redesign of legacy applications written in COBOL is another research area where our approach has been applied [15]. The generated
Tool implementation
A specification written in PROGRES is executable. The PROGRES programming environment is able to interpret PROGRES specifications step by step and construct a graph in the underlying graph database GRAS. This means, while executing the specification of the DYNAMITE meta model and constructing graphs according to it, the PROGRES environment already acts as a process modeling tool. For three reasons, this is not the kind of tool we would like to have.
Firstly, interpreting a PROGRES specification
Experiences and lessons learned
At the beginning of the design, we had to decide whether to use commercial software within our framework or found it completely on free software (e.g. public domain or under GNU license). There are commercial toolkits that offer a variety of functions for handling and displaying huge graph structures. The use of such toolkits significantly reduces the development effort and increases the performance but usually the resulting tools may not be distributed as free software. Therefore, we decided
Conclusion
I presented our approach of generating structure-oriented software engineering tools from graph-based specifications of visual languages and reported on our experiences. The tools incorporate knowledge from their application domains and provide complex commands for constructing and manipulating graphical models. These commands preserve the consistency of the models and go beyond the operations usually offered by graphical editors.
For the realization of this approach, problems from various
References (27)
- et al.
GRAS: a graph-oriented software engineering database system
Information Systems
(1995) - et al.
PCTE—The Standard for Open Repositories
(1993) - et al.
Inside CORBA
(1997) - et al.
X Window System: Core Library and Standards
(1996) Interacting with the FIELD environment
Software Practice and Experience
(1990)- et al.
Synthesizer Generator: A System for Constructing Language-Based Editors
(1988) GENGED—a generic graphical editor for visual languages based on algebraic graph grammars
(1998)- et al.
DiaGen: a generator for diagram editors
(1995) - MetaCase Consulting. MetaEdit+, Version 2.0: Method Workbench User's Guide. MetaCase Consulting, Micro Works Finland,...
- et al.
Graph grammar engineering with PROGRES
Specification of logical documents and tools
The PROGRES approach: language and environment
Software Process Modelling and Technology. Advanced Software Development Series
Cited by (11)
Review from academic success perspective
2008, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)E-CARES* -Telecommunication re- and reverse engineering tools
2004, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)Behavioral analysis of telecommunication systems by graph transformations
2004, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)Authoring support based on user-serviceable graph transformation
2004, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)Fire3: Architecture refinement for A-posteriori integration
2004, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)A proved component-oriented approach for managing dynamic software architectures
2003, Proceedings of the IASTED International Conference on Software Engineering and Applications