Margaret-Anne D. Storey

Cognitive design elements to support the construction of a mental model during software exploration

Abstract The scope of software visualization tools which exist for the navigation, analysis and presentation of software information varies widely. One class of tools, which we refer to as Software exploration tools , provides graphical representations of static software structures linked to textual views of the program source code and documentation. This paper describes a hierarchy of cognitive issues which should be considered during the design of a software exploration tool. The hierarchy of cognitive design elements is derived through the examination of program comprehension cognitive models. Examples of how existing tools address each of these issues are provided. In addition, this paper demonstrates how these cognitive design elements may be applied to the design of an effective interface for software exploration.

Manipulating and documenting software structures using SHriMP views

An effective approach to program understanding involves browsing, exploring, and creating views that document software structures at different levels of abstraction. While exploring the myriad of relationships in a multi-million line legacy system, one can easily loose context. One approach to alleviate this problem is to visualize these structures using fisheye techniques. This paper introduces Simple Hierarchical Multi-Perspective views (SHriMPs). The SHriMP visualization technique has been incorporated into the Rigi reverse engineering system. This greatly enhances Rigis capabilities for documenting design patterns and architectural diagrams that span multiple levels of abstraction. The applicability and usefulness of SHriMPs is illustrated with selected program understanding tasks.

How do program understanding tools affect how programmers understand programs

We explore the question of whether program understanding tools enhance or change the way that programmers understand programs. The strategies that programmers use to comprehend programs vary widely. Program understanding tools should enhance or ease the programmers preferred strategies, rather than impose a fixed strategy that may not always be suitable. We present observations from a user study that compares three tools for browsing program source code and exploring software structures. In this study, 30 participants used these tools to solve several high level program understanding tasks. These tasks required a broad range of comprehension strategies. We describe how these tools supported or hindered the diverse comprehension strategies used.

Structural redocumentation: a case study

Most software documentation typically describes the program at the algorithm and data-structure level. For large legacy systems, understanding the systems architecture is more important. The authors propose a method of reverse engineering through redocumentation that promises to extend the useful life of large systems. >

Theories, methods and tools in program comprehension: past, present and future

Program comprehension research can be characterized by both the theories that provide rich explanations about how programmers comprehend software, as well as the tools that are used to assist in comprehension tasks. During this talk the author review some of the key cognitive theories of program comprehension that have emerged. Using these theories as a canvas, the author then explores how tools that are popular today have evolved to support program comprehension. Specifically, the author discusses how the theories and tools are related and reflect on the research methods that were used to construct the theories and evaluate the tools. The reviewed theories and tools will be further differentiated according to human characteristics, program characteristics, and the context for the various comprehension tasks. Finally, the author predicts how these characteristics will change in the future and speculate on how a number of important research directions could lead to improvements in program comprehension tools and methods.

Cognitive design elements to support the construction of a mental model during software visualization

The scope of software visualization tools which exist for the navigation, analysis and presentation of software information varies widely. One class of tools, which we refer to as software exploration tools, provide graphical representations of software structures linked to textual views of the program source code and documentation. This paper describes a hierarchy of cognitive issues which should be considered during the design of a software exploration tool. The hierarchy of cognitive design elements is derived through the examination of program comprehension cognitive models. Examples of how existing tools address each of these issues are provided.

On integrating visualization techniques for effective software exploration

This paper describes the SHriMP visualization technique for seamlessly exploring software structure and browsing source code, with a focus on effectively assisting hybrid program comprehension strategies. The technique integrates both pan+zoom and fisheye-view visualization approaches for exploring a nested graph view of software structure. The fisheye-view approach handles multiple focal points, which are necessary when examining several subsystems and their mutual interconnections. Source code is presented by embedding code fragments within the nodes of the nested graph. Finer connections among these fragments are represented by a network that is navigated using a hypertext link-following metaphor. SHriMP combines this hypertext metaphor with animated panning and zooming motions over the nested graph to provide continuous orientation and contextual cues for the user. The SHriMP tool is being evaluated in several user studies. Observations of users performing program understanding tasks with the tool are discussed.

On designing an experiment to evaluate a reverse engineering tool

The Rigi reverse engineering system is designed to analyze and summarize the structure of large software systems. Two contrasting approaches are available for visualizing software structures in the Rigi graph editor. The first approach displays the structures through multiple, individual windows. The second approach, simple hierarchical multi-perspective (SHriMP) views, employs fisheye views of nested graphs. The paper describes the design of an experiment to evaluate these alternative user interfaces. Various results from a preliminary pilot study to test the experiment design are reported.

Graph Layout Adjustment Strategies

When adjusting a graph layout, it is often desirable to preserve various properties of the original graph in the adjusted view. Pertinent properties may include straightness of lines, graph topology, orthogonalities and proximities. A layout adjustment algorithm which can be used to create fisheye views of nested graphs is introduced. The SHriMP (SimpleHierarchicalMultiPerspective) visualization technique uses this algorithm to create fisheye views of nested graphs. This algorithm preserves straightness of lines and uniformly resizes nodes when requests for more screen space are made. In contrast to other layout adjustment algorithms, this algorithm has several variants to preserve additional selected properties of the original graph. These variants use different layout strategies to reposition nodes when the graph is distorted. The SHriMP visualization technique is demonstrated through its application to visualizing structures in large software systems.

Rigi: a visualization environment for reverse engineering

The Rigi reverse engineering system provides tNo contrasting approaches for presenting software structures in its graph editor. The first displays the structures through multiple, individual NindoNs. The second (neNer) approach, Simple Hierarchical MultiPerspective (SHriMP) views, employs fisheye views of nested graphs. We compare and contrast these tNo interfaces for visualizing software graphs, and provide results from user experiments.