|
|
Copyright on this material is held by the author(s).
However, the object-oriented paradigm is somewhat of a double-edged sword. The powerful features of inheritance, dynamic binding, and polymorphism make object-oriented programs harder to understand and maintain. Functionality is distributed among classes, often through collaborations that may not be implicit in the static code. The behavior of object-oriented systems can only be completely determined at run-time. It is the dynamics of the program, in terms of object interactions, associations, collaborations, or whatever you want to call them that are of first-class importance.
Recent research in the area of program comprehension has identified the important role of program understanding in debugging, testing, maintenance, reuse, and reverse engineering of software. In the object-oriented arena, program understanding typically evolves from an analysis of the relationships or dependencies between objects in the program, often in terms of inheritance, aggregation, and association. Current tools that provide such information do so through textual lists and graphs. Graphical visualization techniques, which have proven useful for depicting information about computer algorithms, multi-dimensional data, networks, etc., have not yet been fully exploited in this area.
This work proposes that visualizing patterns in the dynamic behavior of object-oriented systems can increase program understanding. By analyzing program executions, patterns of interaction can be uncovered. These patterns are manifested as repeated sequences of messages and recurring instantiation of objects. Message patterns will occur when similar semantic operations are performed on the same or different objects, or as a result of iteration. (Recent work in uncovering pattern languages in program design corroborates the existence of these implementation patterns[1].)
Using various filtering and abstraction techniques, the high-level program behavior can be abstracted from the low-level patterns. Interactive visualizations can present this voluminous information much more effectively than textual representations, allowing the user to control the filtering and abstraction of available information. Visualizations of abstract behavior can then be compared with design level information, such as execution scenarios or interaction diagrams. Through the interactive views of the program, understanding may then proceed in a selective top-down manner as high-level behavior is broken down into successively lower-level patterns.
The following list summarizes goals of this research:
The second generation used multiple views to present various aspects of the program, including inheritance and association relationships between classes, message traffic, and object instantiation[2]. This system was still animated, and while the gathering of the static and dynamic program information was still done by hand, larger programs were used.
In the third generation it was recognized that step-wise animation of program execution is not really required to understand the program's behavior. It is more important to have views that inherently capture the historical nature of the execution by displaying information about the entire execution. To handle real-world sized software systems, this requires a means for displaying large amounts of information in the limited space on the screen.
As one means to accomplish this, a display and navigation technique for large information spaces called the Information Mural has been developed[3]. An Information Mural is a reduced representation of an entire information space that fits entirely within a display window or screen. Intensity, pixel size, and color variation are used along with anti-aliasing techniques to encode the overlap and compression of information as it is scaled into the available space. An Information Mural should convey the same visual patterns as would a view of the entire information space, if one could be created.
Information Murals have been used to display and navigate several different types of information, not only related to software. Murals of sun spot numbers, river flows, and stock market prices show large amounts of data in a small space without discarding information. A Mural of a text file drawn in a scrollbar can be used to display the position of various attributes throughout the entire file. A Mural of an entire data set in a "data slider" gives the observer a feel for the distribution of data visible in the focus area relative to the rest of the data not currently shown on the screen.
Most of the current prototypical views utilize the Information Mural technique. The Execution Mural shows a graphical depiction of the messages sent during the program's execution. A Mural is used to present a global overview of this sequence, which can easily number in the hundreds of thousands. A Pattern Mural view depicts the execution in terms of message patterns rather than individual messages. These patterns are repeated sequences of messages that are automatically identified in the message trace. In order to relate the higher level abstractions found in the views back to the source code, a Code View shows the source code of the system at the class and function level. All of the views are interdependent; interaction with one view can be seen in the others as well.
