Software visualization is the use of interactive computer graphics, typography, graphic design, animation, and cinematography to enhance the interface between the software engineer or the computer science student and their programs. Although several taxonomies of software visualization have been proposed, they use few dimensions and do not span the space of important distinctions between systems. We attempt to fill this gap in the literature by proposing a novel and systematic taxonomy of six areas making up thirty characteristic features of software visualization technology. The taxonomy is presented and illustrated in terms of its application to seven systems of historic importance and technical interest.

The monitoring of distributed systems involves the collection, interpretation, and display of infor-mation concerning the interactions among concurrently executing processes. This information and its display can support the debugging, testing, performance evaluation, and dynamic documentation of distributed systems. General problems associated with monitoring are outlined in this paper, and the architecture of a general purpose, extensible, distributed monitoring system is presented. Three approaches to the display of process interactions are described: textual traces, animated graphical traces, and a combination of aspects of the textual and graphical approaches. The roles that each of these approaches fulfill in monitoring and debugging distributed systems are identified and compared. Monitoring tools for collecting communication statistics, detecting deadlock, controlling the non-deterministic execution of distributed systems, and for using protocol specifications in monitoring are also described. Our discussion is based on experience in the development and use of a monitoring system within a distributed programming environment called Jade. Jade was developed within the Computer Science

This annotated bibliography reviews current research in dynamic and interactive program steering. In particular, we review systems-related research addressing dynamic program steering, raising issues in operating and language systems, mechanisms and algorithms for dynamic program adaptation, program monitoring and the associated data storage techniques, and the design of dynamically steerable or adaptable programs. We define program steering as the capacity to control the execution of long-running, resource-intensive programs. Dynamic program steering consists of two separable tasks: monitoring program or system state (monitoring) and then enacting program changes made in response to observed state changes (steering). College of Computing Georgia Institute of Technology Atlanta, Georgia 30332--0280 1 Introduction The intent of program steering may be illustrated with the following quote from [114]: Scientists not only want to analyze data that results from super-computations; they ...

(to appear in Software-Practice and Experience) A signi cant amount of software development isevolutionary, involving the modi cation of already existing programs. To a large extent, the modi ed programs produce the same results as the original program. This similarity between the original program and the development program is utilized by relative debugging. Relative debugging is a new concept that enables the user to compare the execution of two programs by specifying the expected correspondences between their states. A relative debugger concurrently executes the programs, veri es the correspondences, and reports any di erences found. We describe our novel debugger, called Guard, and its relative debugging capabilities. Guard is implemented by using our library of debugging routines, called Dynascope, which provides debugging primitives in heterogeneous networked environments. To demonstrate the capacity of Guard for debugging in heterogeneous environments, we describe an experiment in which the execution of two programs is compared across Internet. The programs are written in di erent programming languages and executing on di erent computing platforms.

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.

This paper provides an architectural framework for modeling third-party application integrations with open hypermedia systems, which collects and extends the integration experience of the open hypermedia community. The framework is used to characterize applications prior to integration, and describe the qualities of a complete integration. Elements of the architectural model are artists, which are used to manipulate anchors, links, and native application objects; communicators, which manage information flow to and from the open hypermedia system; and containers which group the other elements. Prior integration experience is collected in a standard way using the model. Guidance in selecting the final integration architecture is provided by this prior integration experience, in conjunction with the degree of difficulty of an integration, which is related to the integration architecture.

Object orientation and concurrency are inherent to computer animation. Since the pieces of an animation can come from various media such as computer-generated imagery, video, and sound, the case for object orientation is all the stronger. However, languages for expressing the temporal co-ordination of animated objects have been slow in coming. We present such a language in this paper. Since the movements that an animated object can perform are also encapsulated as objects in our system, the scripting language can also be used to specify motion co-ordination. Such "motion objects" can be applied to any animated object. The syntax, semantics, and implementation of this language will be described, and we shall show how to specify device-independent computer animation. 1 Introduction The term "object" has become a very popular buzzword. Interpretations vary as to what precisely constitutes an object-oriented system. We view an object as being an encapsulation of activities and data. Its b...

Computer science educators have traditionally used algorithm visualization (AV) software to create graphical representations of algorithms for use as visual aids in lectures, or as the basis for interactive labs. Typically, such visualizations are high fidelity in the sense that (a) they depict the target algorithm for arbitrary input, and (b) they tend to have the polished look of textbook figures. In contrast, low fidelity visualizations illustrate the target algorithm for a few, carefully chosen input data sets, and tend to have a sketched, unpolished appearance. Drawing on ethnographic field studies of a junior-level algorithms course, we motivate the use of low fidelity AV technology as the basis for an alternative learning paradigm in which students construct their own visualizations, and then present those visualizations to their instructor and peers for feedback and discussion. To explore the design space of low fidelity AV technology, we present SALSA (Spatial ALgorithmic Language for StoryboArding) and ALVIS (ALgorithm VIsualization Storyboarder), a prototype end-user language and system firmly rooted in empirical studies in which students constructed and presented visualizations made out of simple art supplies. Our prototype end-user language and system pioneer a novel technique for programming of visualizations based on spatial relations, and a novel presentation interface that supports human discussions about algorithms by enabling reverse execution and dynamic mark-up and modification. Moreover, the prototype provides an ideal foundation for what we see as the algorithms classroom of the future: the interactive "algorithms studio."

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. 1 Introduction Software Visualization is the use of visualization and animation techniques to help people understand the characteristics and exec...

macgnome @ cs.cmu.edu Previous work has demonstrated that presenting the data structures from programs in a graphical manner can significantly help programmers understand and debug their programs. In most previous systems, however, the graphical displays, called data visualizations, had to be laboriously hand created. The Amethyst system, which runs on Apple Macintosh computers, provides attractive and appropriate default displays for data structures. The default displays include the appropriate forms for literals of the simple types inside type-specific shapes, and stacked boxes for records and arrays. In the near future, we plan to develop rules for layout of simple dynamic data structures (like linked lists and binary trees), and simple mechanisms for creating