In this paper, 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 programmer's 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.

: Artificial intelligence software has for many years made extensive use of graphics facilities. However, knowledge engineers have not had access to visual programming tools which assist them during the critical early phases of knowledge acquisition. Moreover, during later phases of knowledge base debugging, knowledge engineers have had to work with program tracing tools (whether graphical or textual) which are inherently incapable of scaling up to the monitoring demands imposed by large, heterogeneous knowledge bases. To address these deficiencies, and to satisfy the needs of knowledge engineers throughout the software design, development, and debugging cycle, we have developed several novel visual programming and program visualization techniques aimed at knowledge engineers. Foremost among these are (i) a hypertext transcript analyser from which conceptual models can be generated; (ii) a `direct graph manipulation' sketchpad which allows the knowledge engineer to sketch out objects a...

Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task still remains complex and difficult. Other than breakpoints and tracing, these tools provide little high level help. Programmers must perform many tasks manually that the tools could perform automatically, such as finding which statements in the program affect the value of an output variable under a given testcase, what was the value of a given variable when the control last reached a given program location, and what does the program do differently under one testcase it does not do under another. If the debugging tools provided explicit support for such tasks, the whole debugging process would be automated to a large extent.

We have a project currently underway that attempts to use 3D workstations to provide insight into programs, their structure and their execution, through the use of a variety of user-definable displays. We offer a variety of different presentation styles and utilize a variety of different layout methods and heuristics. This paper describes the underlying engine that we have developed to support this range of presentations.

: We describe a practical and enhanced implementation of a graphical Prolog tracer which not only provides a faithful (slow-motion) representation of the inner workings of the Prolog interpreter, but also allows a high-speed visual overview of execution for rapidly homing in on buggy code. The current work extends our original 'Transparent Prolog Machine' in the following ways: (a) complex unification histories for given variables can be displayed; (b) cross-variable dependencies (sharing) across widelydispersed sections of code can be highlighted; (c) an earlier defect, wherein a given user could write code which defeated the speed/size of the current fastest/largest display capability (i.e. a 'horizon effect') is dealt with; (d) users of textual (Byrd box) tracers are provided with an upward-compatible migration pathway; (e) code can be traced either 'live' or 'retrospectively' at different grains of detail. We distinguish among four different ways of manipulating the 'navigational s...

Software programs, especially legacy programs, are often large, complex and poorly documented. To maintain these programs software engineers require a variety of efficient analytical tools. Some software maintenance tools use visualizations (i.e. graphical views) to communicate information about software systems. Although many software visualization tools exist, the majority of them are not very effective in practice. Part of the problem is that they are designed in an ad hoc manner, with little empirical evaluation. They are often criticized because they try to force programmers to use a specific approach to understanding software rather than supporting their own approaches. The result is that current software visualization tools do not play as big a role in industry as was anticipated by some researchers. The tools that are used are very basic, consisting of mainly text editors and searching features. With increasingly fast computing platforms, there is great potential for the use of...

Parallel and distributed programming is intrinsically more difficult than sequential programming, yet few effective tools or methodologies have been developed to help programmers understand the behavior of their parallel programs. Browsing source code and tracing program output are tedious and often ineffective approaches for parallel program understanding. Program visualization, which relates a program's behavior to the programmer's model of the system's components and interactions, has been shown to be a novel and highly effective approach to program and algorithm comprehension. Extending and adapting program visualization to parallel programming can aid comprehension of the complex concurrent events and transitions that occur in parallel programs. We are defining a model for the capture and display of parallel program events and transitions, based upon the path-transition paradigm for animation, and partial ordering of events. Using this model, we are developing a prototype for vis...

The general term program visualization refers to graphical views or illustrations of the entities and characteristics of computer programs. This term along with many others including data structure display, program animation, algorithm animation, etc., have been used inconsistently in the literature, which has led to confusion in describing systems providing these capabilities. In this paper we present a scaled characterization of program visualization terms along aspect, abstractness, animation, and automation dimensions. Rather than placing existing systems into hard-and-fast categories, we focus on unique and differentiating aspects across all systems. Keywords: program visualization, algorithm animation, software understanding 1 Introduction A visualization tool provides graphical views of the entities and characteristics of a computer system or program. The purpose of such a visualization tool is stated nicely by Myers, et. al.: "Human information processing is clearly optimized...

Symmetric multiprocessor systems (SMPs) are the desktop systems of the future. As they become more widely used, application developers will need to make better use of them. Merely providing threading will be insufficient. Companies will need to provide applications that parallelize portions of code and use the processors in SMPs to their full extent. This will have a much more dramatic effect on improving performance. Before this can be achieved however, tools must be developed which aid programmers, who may have little or no experience in programming parallel systems, to debug and performance tune their applications. Our goal is to improve the technology available through interactive computational steering and to develop techniques that will be valuable for all types of concurrent systems not just SMPs. This will be done through integrated operation visualization, data highlighting, interactive computational steering, and by concentrating on the data in a parallel system rather than on the processors or code.

ABSTRACT.......................................................................