re-implement the old system to be more objected-oriented. The idea of separation

Chapter 1 Introduction

DIVA (Debugging Information Visualization Assistant) is a system for

visualizing large software data structures in 3D space. This system has been

described in the past under the name DIVINE [1]. In this thesis, we improve and

re-implement the old system to be more objected-oriented. The idea of separation

of visualization programming and visualization system is the main emphasis.

1.1. Overview

Debugger is a helpful tool for programmers to debug program. When

debuggers are not available, programmers debug the program by inserting some

statements like “print” or save program states to log files to probe the internal states

of a program. Programmers now can get the program information during execution

through the help of the debugger: watch the value of variables, set break point at the

line of the program that might get wrong, and execute the program line by line or

function by function.

Because debugger is of great help, it is becoming a part of the programming

environment. In many IDE (Integrated Development Environment), debugger is

easier to manipulate with graphical interface: if programmers want to set break point,

they only have to click mouse once at the line number of the program; if

graphic of the meaning “step by step” repeatedly.

Although debuggers are very useful for debugging, it has limitation: traditional

debugger could only show textual debugging information such like variable’s

numerical values. It could not show the relation between two classes to be clear at a

glance or could not show in different way but only text.

Debugger could let programmers understand the variation of variables step by

step but often upon reaching the new break point, the values of variables are updated

and washed out. If the scale of the program is small, programmers could still manage

to find the temporal relation by collecting and remembering variable changes of their

own,. However, when a program becomes large and complicated, it is difficult for

programmers to manage such temporal relation from today’s debuggers. So we must

have another way to understand the program of large scale by another tool or

debugger in advanced.

Software visualization is a way to visualize the program through the graphics

and animation to help programmers understand the program quickly. Humans are

visual animal. Most of the time, a picture is worth a thousand words. Besides,

software is dynamic not static. If one program execution could be animated as a

video, we believe it can achieve much better understanding than code reading.

There are many software visualization tools which could help programmers to

understand the program such like CodeCrawler [2], BLOOM [3] and etc. These tools

can visualize the program in many ways such as tree map, point map and so on [2].

These tools make the program display in other ways but not just in text. Programmers

can choose the representation by themselves to help them understand the program

execution. But there isn’t still something enough: those software visualization tools

introduced above are all static visualization of the program, not updating the display

dynamically. Programmers could only get a snap-shot of the program state but not the

state updated consecutively.

Most of software visualization tools developed could visualize program in the

visualization browser written inside the tools. The design of the visualization tool is

often designed by the programmers who also design the whole visualization system.

In DIVA, we call the visualization browser as “visualization metaphor (VM).” One

goal of DIVA is to separate the implementation of the metaphor from DIVA. People

who are responsible for implementing VM do not need to worry too much details of

DIVA. To accomplish this goal, a well-designed object-oriented framework is needed.

Beside the separation of VM programming, DIVA provides ability for

programmers to compose existing metaphors into new ones. A uniqueness of DIVA is

the discovering of the basic building blocks of metaphor and their rule of

composition.

Most existing software visualization tools visualize program’s static

characteristics. There is little interaction for tool users. DIVA, on the other hand,

uses 3-D game engine named OGRE [28] to do the visualization. One of the

characteristics of game engine is its rendering entities are object-based. For example,

in DIVA, a tool user can click on a 3D object and trace back to its variable or objects

in their program. This characteristic is also one of the contributions of DIVA.

Finally, beside the design and implementation of DIVA’s modules and

framework, we present a layout algorithm called tree layout metaphor under the

framework for visualizing tree-like data structures.

In this paper, we present a 3D software visualization tool called DIVA that could

visualize different kinds of the program execution data dynamically and allow

programmers to interact with the visualized program data. The software visualization

tool we present has some characteristics:

(1) it could visualize program execution data in 3D environment;

(2) it could let programmers to interact with the data visualized in the 3D

environment;

(3) it separates the design of visualization metaphor (see section 3.2) from whole

the system;

(4) it is the software visualization tool for general-purpose but not just for

specified field.

We also design and implement a layout algorithm for tree data structure to

arrange the tree nodes visualized by DIVA in 3D environment well.

The main contributions of this paper are:

The software visualization tool we present could visualize programs for general-purpose.

The design of the visualization metaphor is separated from the whole system.

The compositionality from building blocks increases the usability of visualization tools..

1.2. Organization

The remainder of the thesis is structured as follows: Chapter 2 describes the

related research, including debugger, software visualization, layout algorithm and

related technologies. Chapter 3 introduces the architecture of the DIVA and shows

how the interaction between debuggee and DIVA components. Chapter 4 describes

one layout VM for tree data structure. Finally, Chapter 5 summarizes the conclusions

and future works.