An algorithm or a program can be animated by a movie that graphically represents its dynamic execution. Such animations are useful for developing new programs, for debugging, and for explaining how programs work. This paper describes ANIM, a basic system for algorithm animation. The output is crude, but ANIM is easy to use; a novice user can animate a program in an hour or two. ANIM currently produces movies with the X window system, among others; it also renders movies into stills that can be included in TROFF or TeX documents. (15 Refs.)

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 widely-dispersed 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 space" produced by large Prolog programs: (a) by granularity i.e. coarse-grained vs fine-grained; (b) by scale, i.e. close-up vs far away (c) by compression, i.e. the use of a single compact display region or symbol to indicate "additional territory", at the same granularity and scale; (d) by abstraction, i.e. a movement away from the raw Prolog code and towards a representation closer to the programmer's own plans and intentions. The paper includes detailed examples of the tracer in action.

This paper presents five abstract characteristics of the mental representation of computer programs: hierarchical structure, explicit mapping of code to goals, foundation on recognition of recurring patterns, connection of knowledge, and grounding in the program text. An experiment is reported in which expert and novice programmers studied a Pascal program for comprehension and then answered a series of quiestions about it designed to show these characteristics if they existed in the mental represenations formed. Evidence for all of the abstract characteristics was found in the mental representations of expert programmers. Novices' representations generally lacked th characteristics, but there was evidence that they had the beginnings, although poorly developed.

Animation is a useful tool in teaching and developing algorithms. The idea of animating algorithm executions was suggested in the sixties, but the technology for producing real-time animatins with reasonable cost matured in the early eighties. Since then several animation systems have been developed. The most influential of these systems are surveyed in this paper. A closer look will be taken at the animation system Aladdin which is being developed in the University of Tampere.

The University of Washington illustrating compiler (UWPI) automatically illustrates the data structures used in simple programs written in a subset of Pascal. A UWPI user submits a program to UWPI, and can then watch a graphical display show time varying illustrations of the data structures and program source code. UWPI uses the information latent in the program to determine how to illustrate the program. UWPI infers the abstract data types directly from the declarations and operations used in the source program, and then lays out the illustration in a natural way by instantiating well-known layouts for the abstract types. UWPI solves program illustration using compile-time pattern matching and type inferencing to link anticipated execution events to display events, rather than relying on user assistance or specialized programming techniques. UWPI has been used to automatically illustrate didactic sorting and searching examples, and can be used to help teach basic data structures, or to help when debugging programs.

The last decade has been a very active period of designing systems for program visualization. Without proper means for describing and evaluating both existing and new systems further development may be delayed. Recently, several researchers have been working for creating taxonomies for program visualization systems. During the active period of system development benefits of visualization were often praised without criticism, and scientific references were rarely presented. What do we really know about the usefulness of program visualization? We first present the terminology and the state of the work for developing a taxonomy for the discipline. Moreover, we review the existing empirical studies on the benefits of graphical presentation of programs. We also give a reference list to the existing program visualization systems.

This paper identifies ways that visualization can increase program understanding, and presents a means for characterizing both static and dynamic aspects of an object-oriented program.

This article describes a study involving the use of algorithm animations in classroom and laboratory settings. Results indicated that allowing students to create their own examples in a laboratory session led to higher accuracy on the post-test examination of understanding of the algorithm as compared to students who viewed prepared examples or no laboratory examples.

Understanding and interpreting a large data source is an important but challenging operation in many technical disciplines. Computer visualization has become a valuable tool to help capture and portray characteristics of large data sets. In software visualization, illustrating the operation of very large programs or programs working on very large data sets has remained one of the key open problems. Here, we introduce an approach that uses semantic zooming to depict large program executions. Our method utilizes abstract, clustered graphics to portray program operations on the entire data set. Then, by interacting with the presentation, a viewer can zoom in to examine details and individual values. At this "magnified" level, the presentation adjusts to reflect displays common in existing algorithm animation and program visualization systems.

The Garnet User Interface Development Environment contains a comprehensive set of tools that make it significantly easier to design and implement highly-interactive, graphical, direct manipulation user interfaces. The toolkit layer of Garnet provides a prototype-instance object system, automatic constraint maintenance, an efficient retained-object graphics output model, a novel input model, two complete widget sets, and complete debugging tools. Garnet also contains a set of interactive user interface editors that aim to make it possible to create the user interface without programming. Instead, the user draws examples of the desired graphics and demonstrates their behaviors. The associated video provides an overview of the entire Garnet system.

Although there has been important progress in models and packages for the output of graphics to computer screens, there has been little change in the way that input from the mouse, keyboard, and other input devices is handled. New graphics standards are still using a fifteen-year-old model even though it is widely accepted as inadequate, and most modern window managers simply return a stream of low-level, device-dependent input events. This paper presents a new model that handles input devices for highly interactive, direct manipulation, graphical user interfaces, which could be used in future toolkits, window managers, and graphics standards. This model encapsulates interactive behaviors into a few ``Interactor'' object types. Application programs can then create instances of these Interactor objects which hide the details of the underlying window manager events. In addition, Interactors allow a clean separation between the input handling, the graphics, and the application programs. This model has been extensively used as part of the Garnet system and has proven to be convenient, efficient, and easy to learn. Myers provides a well-written discussion of a model for describing interactions with highly interactive, graphical, direct manipulative input devices. This model has been implemented as part of the Garnet user interface development environment at CMU. It allows for the specification and implementation of interactive behaviors separate from considerations of graphics and application programs. The key idea is that interactive behaviors are categorized by, and encapsulated in, a set of ``interactor'' object types. The six types of interactors are menu interactor, move-grow interactor, new-point interactor, angle interactor, text interactor, and trace interactor. Although no widely accepted taxonomy of input operations is extant, these six interactors seem to cover most input operations that are possible with a keyboard and a mouse. Interactor parameters (described in the paper) allow the interactions to be customized for many purposes. Default parameters handle common uses; a constraint-driven interface to application programs is provided for more complex behaviors. One of the best features of this paper is that Myers's description of this model for handling input is well illustrated and therefore quite understandable. It is replete with examples and sample screens. This paper would be useful for researchers in computer system interfaces as well as professional developers of such interfaces. The reference list provides a useful summary of related work.

Garnet helps to implement highly-interactive, graphical, direct manipulation applications for X Windows in CommonLisp. The system is in the public domain, and there are over 40 projects involving over 100 people actively using Garnet today, including many in Europe. An Usenet newsgroup, comp.windows.garnet, allows discussion of Garnet issues. This meeting will allow developers, users and people interested in the Garnet technology to meet, exchange information, and discuss future directions.

This report describes textscAnim3D, a 3D animation library targeted at visualizing combinatorial structures. In particular, we are interested in algorithm animation. Constructing a new view for an algorithm typically takes dozens of design iterations, and can be very time-consuming. Our library eases the programmer's burden by providing high-level constructs for performing animations, and by offering an interpretive environment that eliminates the need for recompilations. This report also illustrates textscAnim3D's expressiveness by developing a 3D animation of Dijkstra's shortest-path algorithm in just 70 lines of code. An accompanying videotape shows the library in use.

Program visualization is defined as a mapping from programs to graphical representations. Simple forms of program visualization are frequently encountered in software engineering. For this reason current advances in program visualization are likely to influence future developments concerning software engineering tools and environments. The authors provide a new taxonomy of program visualization research. The proposed taxonomy becomes the vehicle through which they carry out a systematic review of current systems, techniques, trends, and ideas in program visualization.

Algorithm animations are dynamic graphical illustrations of computer algorithms, and they are used as teaching aids to help explain how the algorithms work. Although many people believe that algorithm animations are useful this way, no empirical evidence has ever been presented supporting this belief. We have conducted an empirical study of a priority queue algorithm animation, and the study's results indicate that the animation only slightly assisted student understanding. In this article, we analyze those reults and hypothesize why algorithm animations may not be as helpful as was initially hoped. We also develop guidelines for making algorithm animations more useful in the future.

Beschreibung der Datenstrukturen und der Funktionen von TANGO

Algorithm animation is the process of abstracting a program's data, operations, and semantics, and creating dynamic graphical views of those abstractions [Sta90]. Algorithm animation systems have been used for both instructional purposes such as augmenting classroom lectures and for "visually documenting" complex programs. To now, algorithm animation systems have supported only 2-D black-and-white or color views. Our work extends algorithm animation to three-dimensional computer graphics.

Tango supports a clean separation between programs and animations, resulting in a flexibility to map one or several programs to more than one animation view --- a feature useful not only for experimenting with many views of a simple program, but also for more sophisticated animations such asw parallel process visualization.

Dance is a tool that facilitates direct manipulation, demonstrational development of animations for the Tango algorithm animation system. Designers sketch out target actions in a graphical-editing fashion, then Dance automatically generates the code that will carry out those actions. Dance promotes ease-of-design, rapid prototyping, and increased experimentation. It also introduces a methodology that could be used to incorporate demonstrational animation design into areas such as computer assisted instruction and user interface development.

This report describes the current status of the PARADE visualization environment. PARADE supports the design and implementation of software visualizations of parallel and distributed programs. It contains primary components for monitoring a program's execution, building the software visualization, and mapping the execution to the visualization. In this report we provide brief descriptions of many of the projects that comprise the PARADE environment, and we provide references to more detailed information on the projects.

Theis document describes the views and code instrumentation involved in using Gthread, a visualization package for KSR Pthread programs. This package consists of two parts: a KSR C library gathering trace information, and a visualizer possibly running on another platform illustrating the structure and execution of the program. The Gthread package will help programmers developing and debugging multi-threaded programs with little extra work.