Kai Koskimies

Automatic synthesis of state machines from trace diagrams

The automatic synthesis of state machines describing the behaviour of a class of objects in object‐oriented software modelling is studied. It is shown that the synthesis can be carried out on the basis of trace diagrams giving possible sequences of events during the execution of the system. An algorithm originally developed for the automatic construction of programs on the basis of their execution traces is applied to the problem, and an experimental state machine synthesizer is implemented. It is demonstrated that such a synthesizer is a highly useful component in a practical object‐oriented CASE system.

Scene: using scenario diagrams and active text for illustrating object-oriented programs

Scenario diagrams are a well-known notation for visualizing the message flow in object-oriented systems. Traditionally, they are used in the analysis and design phases of software development to prototype the expected behavior of a system. We show how they can be used in reverse for understanding and browsing existing software. We have implemented a tool called Scene (SCENario Environment) that automatically produces scenario diagrams for existing object-oriented systems. The tool makes extensive use of an active text framework providing the basis for various hypertext-like facilities. It allows the user to browse not only scenarios but also various kinds of associated documents, such as source code (method definitions and calls), class interfaces, class diagrams and call matrices.

Designing a Framework by Stepwise Generalization

Frameworks are class collections that capture the common aspects of applications in a certain problem domain. It is argued that conventional object-oriented design methods do not suit well to frameworks. As an alternative, we suggest a two-phase design method. The first phase is a stepwise generalization of a problem to its most general form. The second phase proceeds in the opposite direction, giving an implementation for every generalization level. The implementation of a certain level can be regarded as a framework for implementing the next more specific level. The main advantage of our method is that it enhances the generality (and therefore reusability) of the framework architecture, and explains the design decisions in the simplest possible context. As a case study, we describe a framework supporting the analysis of formal languages.

Object-Orientation in Attribute Grammars

Object-orientation is a language design and programming paradigm aiming at better structuring, reusing, and maintaining properties of software. This paradigm has been successfully combined with conventional programming languages, as well as with functional and logic programming languages; it seems obvious that object-orientation has come to stay. Recently, some suggestions to extend the attribute grammar formalism with features supporting object-orientation have been proposed. These proposals are reviewed, and the approach taken in the TOOLS system is described and motivated. It is demonstrated that object-orientation contributes to the uniformity and applicability of attribute grammar descriptions.

Active Text for Structuring and Understanding Source Code

Programs are not read sequentially like a book but rather selectively like an encyclopedia. Instead of linear text we therefore suggest non‐linear active text as a medium for structuring and browsing source code. Although common program editors are mainly character based we believe that non‐textual information such as pictures, links, folds, and annotations can improve the readability of programs. In this paper we show how a text editor can be extended to include active text elements and give examples for how to apply these facilities to source code. Our approach is different from that of syntax‐oriented editors in that our structuring is not based on the syntax of the edited texts. The implementation was done in the Oberon system which offers powerful mechanisms for extending software in an object‐oriented way.

The design of a language processor generator

Language processor generators are systems that produce various language processors (including compilers) on the basis of a high‐level specification. The design of language processor generators is discussed on the basis of experiments with a traditional compiler writing system (HLP78) employing pore LALR parsing and general attribute grammars. It is argued that these methods are too primitive from the practical point of view. The design of a new language processor generator, HLP84, is based on this view. This system is an attempt to provide high‐level tools for a restricted class of applications (one‐pass analysis). The syntactic facilities include regular expressions on the right‐hand sides of productions, a disambiguating mechanism that is integrated with regular expressions, and a mechanism for using semantic information to aid parsing. The semantic facilities include automatic support for semantic error handling and for symbol tables. Early experiences with the new system show that in spite of the general overhead caused by the higher automation level, the system allows the generation of reasonably efficient processors.

Compiler construction using attribute grammars

The adequacy of attribute grammars as a compiler writing tool is studied on the basis of the experiences on attribute grammars for Pascal and a subset of Euclid. A qualitative assessment of the grammars shows that the compiler oriented view in the design of an attribute grammar tends to make the grammar hard to understand. A design discipline is proposed to improve the comprehensibility of the grammar. Quantitative measurements of the automatically generated compilers suggest that an efficient compiler can be produced from an attribute grammar. To achieve this, a carefully optimized implementation of the compiler-compiler is required.

Extracting State Diagrams from Legacy Systems

A basic problem of reverse engineering is to understand legacy systems and derive abstract characterizations of poorly documented software. In the case of objectoriented software, the static structure (e.g. inheritance and association relationships) can usually be understood easily, and it can be extracted from existing software using automated tools. This is due to the fact that the static aspects of object-oriented programs are more or less explicitly indicated in the source. Understanding and characterizing the dynamic behavior of such systems, in contrast, is usually much more difficult because of the gap between the static source text and the run-time behavior of the executable program. However, the dynamic behavior of a program is equally important as its static specification for understanding the software. Dynamic characterization is particularly important for those parts of a system which are mainly understood by their dynamic behavior, like various kinds of controllers, drivers, etc.

A Language Implementation Framework in Java

An object-oriented language implementation environment called TaLE is presented. TaLE consists of an OO framework that provides basic language implementation mechanisms, and of a graphical editor that supports visual syntactic specifications and various kinds of language-oriented specializations, generating the desired subclasses for the framework. Parsing is based on a model in which parsing information is distributed at runtime among the metaobjects representing language structures. The TaLE approach facilitates the reuse of both syntactic and semantic classes.

Searching neural network structures with L systems and genetic algorithms

We present a new method for using genetic algorithms and L systems to grow up efficient neural network structures. Our L rules operate directly on 2-dimensional cell matrix. Lrules are produced automatically by genetic algorithm and they have“age”that controls the number of firing times, i.e., times we can apply each rule. We have modified the conventional neural network model so that it is easy to present the knowledge by birth (axon weights) and the learning by experience (dendrite weights). A connection is shown to exist between the axon weights and learning parameters used e.g., in back propagation. This system enables us to find special structures that are very fast for both to train and to operate comparing to conventional, layered methods.