Claus Lewerentz

Voronoi treemaps for the visualization of software metrics

In this paper we present a hierarchy-based visualization approach for software metrics using Treemaps. Contrary to existing rectangle-based Treemap layout algorithms, we introduce layouts based on arbitrary polygons that are advantageous with respect to the aspect ratio between width and height of the objects and the identification of boundaries between and within the hierarchy levels in the Treemap. The layouts are computed by the iterative relaxation of Voronoi tessellations. Additionally, we describe techniques that allow the user to investigate software metric data of complex systems by utilizing transparencies in combination with interactive zooming.

Applying design-metrics to object-oriented frameworks

Presents a novel way of using object-oriented design metrics to support the incremental development of object-oriented programs. Based on a quality model (the factor-criteria-metrics model), so-called multi-metrics relate a number of simple structural measurements to design principles and rules. Single components of an object-oriented program like classes or subsystems are analyzed to determine whether they conform to specific design goals. Concise measurement reports, together with detailed explanations of the obtained values, identify problem spots in system design and give hints for improvement. This allows the designer to measure and evaluate programs at an appropriate level of abstraction. This paper details the use of the multi-metrics approach for the design and improvement of a framework for industry and its use for graphical applications. Multi-metrics tools were used with several versions of the framework. The measurement results were used in design reviews to quantify the effects of efforts to reorganize the framework. The results showed that this approach was very effective at giving good feedback, even to very experienced software developers. It helped them to improve their software and to create stable system designs.

Efficient relational calculation for software analysis

Calculating with graphs and relations has many applications in the analysis of software systems, for example, the detection of design patterns or patterns of problematic design and the computation of design metrics. These applications require an expressive query language, in particular, for the detection of graph patterns, and an efficient evaluation of the queries even for large graphs. In this paper, we introduce RML, a simple language for querying and manipulating relations based on predicate calculus, and CrocoPat, an interpreter for RML programs. RML is general because it enables the manipulation not only of graphs (i.e., binary relations), but of relations of arbitrary arity. CrocoPat executes RML programs efficiently because it internally represents relations as binary decision diagrams, a data structure that is well-known as a compact representation of large relations in computer-aided verification. We evaluate RML by giving example programs for several software analyses and CrocoPat by comparing its performance with calculators for binary relations, a Prolog system, and a relational database management system.

Formal Development of Reactive Systems

This chapter presents a case study in the field of control systems. The task consists of developing verified control software for a model representing a production cell installed in a metal-processing plant in Karlsruhe. The paper describes the functionality of the model, explains how the control program relies on the systems sensors, discusses the possibilities for driving the model with the help of various actuators, and finally defines the requirements that are to be fulfilled by the control software. 2.1 Description of the Production Cell The Forschungszentrum Informatik has created a model of a production cell for mounting frames which was built as part of a study in microcomputer technology in 1989. This is not a model only in theory: it represents an actual industrial installation in a metal-processing plant in Karlsruhe. The case study presents a realistic industry-oriented problem, where safety requirements play a significant role and can be met by the application of formal methods. The manageable size of the task allows for experimenting with several approaches. The production cell processes metal blanks which are conveyed to a press by a feed belt. A robot takes each blank from the feed belt and places it into the press. The robot arm withdraws from the press, the press processes the metal blank and

Rabbit: A Tool for BDD-Based Verification of Real-Time Systems

This paper gives a short overview of a model checking tool for real-time systems. The modeling language are timed automata extended with concepts for modular modeling. The tool provides reachability analysis and refinement checking, both implemented using the data structure BDD. Good variable orderings for the BDDs are computed from the modular structure of the model and an estimate of the BDD size. This leads to a significant performance improvement compared to the tool RED and the BDD-based version of Kronos.

Software landscapes: visualizing the structure of large software systems

Modern object-oriented programs are hierarchical systems with many thousands of interrelated subsystems. Visualization helps developers to better comprehend these large and complex systems. This paper presents a three-dimensional visualization technique that represents the static structure of object-oriented programs using landscape-like distributions of three-dimensional objects on a two-dimensional plane. The familiar landscape methaphor facilitates intuitive navigation and comprehension. The visual complexity is reduced by adjusting the transparency of object surfaces to the distance of the viewpoint. An approach called Hierarchical Net is proposed for a clear representation of the relationsships between the subsystems.

Simple and efficient relational querying of software structures

Many analyses of software systems can be formalized asrelational queries, for example the detection of design patterns,of patterns of problematic design, of code clones, ofdead code, and of differences between the as-built and theas-designed architecture. This paper describes the conceptsof CrocoPat, a tool for querying and manipulating relations.CrocoPat is easy to use, because of its simple query andmanipulation language based on predicate calculus, and itssimple file format for relations. CrocoPat is efficient, becauseit internally represents relations as binary decisiondiagrams, a data structure that is well-known as a compactrepresentation of large relations in computer-aided verification.CrocoPat is general, because it manipulates not onlygraphs (i.e. binary relations), but n-ary relations.

CrocoPat: efficient pattern analysis in object-oriented programs

CrocoPat is a new tool for efficient pattern-based analysis of large object-oriented programs. Patterns can be flexibly specified by expressions based on standard mathematics provided by the tool language. It is easy to specify patterns in different variants in a compact form, adapted to specific situations.

Impact of Inheritance on Metrics for Size, Coupling, and Cohesion in Object-Oriented Systems

In todays engineering of object oriented systems many different metrics are used to get feedback about design quality and to automatically identify design weaknesses. While the concept of inheritance is covered by special inheritance metrics its impact on other classical metrics (like size, coupling or cohesion metrics) is not considered; this can yield misleading measurement values and false interpretations. In this paper we present an approach to work the concept of inheritance into classical metrics (and with it the related concepts of overriding, overloading and polymorphism). This is done by some language dependent flattening functions that modify the data on which the measurement will be done. These functions are implemented within our metrics tool Crocodile and are applied for a case study: the comparison of the measurement values of the original data with the measurement values of the flattened data yields interesting results and improves the power of classical measurements for interpretation.

Representing development history in software cities

In this paper we describe a systematic approach to utilize the city metaphor for the visualization of large software systems as evolving software cities. The main contribution is a new layout approach which explicitly takes the development history of software systems into account and makes history directly visible in the layouts. These layouts incrementally evolve in a very smooth and stable way during the development of the represented software system. They are used as a visualization platform for integrating a large variety of product and process data and thus create a coherent set of specialized visualizations. To illustrate this we present some example maps capturing specific development history aspects.