Visualization of computer programs, particularly parallel programs, promises to help programmers better understand, develop, and debug their code, especially if the visualizations are relatively easy to create. We have developed a visualization methodology being used as a component in a comprehensive parallel program visualization system. The focus of the system is on application-specific user-tailored program views. An application-specific visualization of a parallel program presents the inherent application domain, semantics, and data being manipulated by the program in a manner natural to one's understanding of the program. In this paper we discuss why application-specific views are necessary for program debugging, and we list several requirements and challenges that a system for applicationspecific viewing should meet. The visualization methodology that we introduce includes primitives for designing smooth animation scenarios, and most importantly, for allowing designers to visuali...

and Pictorial Data Satoshi Matsuoka Shin Takahashi Tomihisa Kamada 3 Akinori Yonezawa y Department of Information Science, the University of Tokyo 7-3-1 Hongo, Bunkyo-ku, Tokyo, 113 Japan Research and Development, ACCESS CO., LTD. 1-7-1 Sarugaku-cho, Chiyoda-ku, Tokyo, 101 Japan Abstract The merits of direct manipulation are now widely recognized. However, direct manipulation interfaces incur high cost in their creation. To cope with this problem, we present a model of bi-directional translation between pictures and abstract application data, and a prototype system TRIP2 based on this model. Using this model, general mapping from abstract data to pictures, and from pictures to abstract data, is realized merely by giving declarative mapping rules, allowing fast and easy creation of direct manipulation interfaces. We apply the prototype system to the generation of the interfaces for kinship diagrams, Graph Editors, E-R diagrams, and an Othello game. Categories and Subject Descriptors:...

Graphical user interfaces (GUI) provide intuitive and easy means for users to communicate with computers. However, construction of GUI software requires complex programming that is far from being intuitive. Because of the "semantic gap" between the textual application program and its graphical interface, the programmer himself must conceptually maintain the correspondence between the textual programming and the graphical image of the resulting interface. Instead, we propose a programming environment based on the programming by visual example (PBVE) scheme, which allows the GUI designers to "program" visual interfaces for their applications by "drawing" the example visualization of application data with a direct manipulation interface. Our system, TRIP3, realizes this with (1) the bi-directional translation model between the (abstract) application data and the pictorial data of the GUI, and (2) the ability to generate mapping rules for the translation from example application data and ...

Animation is useful in user interfaces, especially for representing dynamic features. However, it is often difficult and laborious to create animation in an existing user interface environment. In this research, we extend our bi-directional translation model to deal with animations. The new model incorporates the notion of time, and includes operations defined for each representation in the model. Using this model, animation is basically achieved by interpolating successive visualized pictures of application data. Other than specifying the way of visualizing application data, programmers have only to provide mapping rules between abstract operations and interpolating methods, and as a result, complex animation effects can be easily specified. We have developed a prototype system based on this model, and applied it to several algorithm animations, such as sorting algorithms, the tower of Hanoi, and Kruskal’s algorithm. 1

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

As distributed algorithms may involve a large amount of data describing local state information and complex interactions between elements, it is often very di cult to achieve anunderstanding of their control ow (and performance behaviour) only from a pseudo-code description or from data streams (e.g. execution traces). This paper is on our project which constitutes a systematic e ort to explore the use of visualisation and animation aids to illuminate the key ideas of distributed protocols and algorithms. In particular, it involves: development of a database of distributed protocols and concurrent data objects implementations� availability of an animation program for each entry of the database (i.e. each protocol or concurrent object implementation), which, given the (on- or o-line) trace of any execution, it animates it in a way that demonstrates the key ideas of the respective protocol or concurrent object implementation� development of a database of network descriptions. The integrated library, Lydian, will be of big help for educational purposes, such as for teaching distributed computing, computer networks, communication protocols, operating systems � students will be able to gain a direct impression of the behaviour of the protocol and teachers will be able to illustrate concepts that can otherwise be explained concisely only in a technical paper. For the protocols and data objects implementation part we use simulation platforms for network and multiprocessor systems. Since distributed protocols are designed to execute on any type of system that can be described as a set of interconnected processing units, the use of these platforms enables the implementation of a wide range of protocols. For the creation of network descriptions and their tra c behaviour a simple and nice graphical editor was used accompanied by a set of drawing algorithms. For the animation part we use a powerful toolkit, which, like the simulation platforms, is appropriate for many di erent architectures. 1

We report on the development of a visual programming environment for building applications for execution on a range of parallel computing platforms. This work exploits the dataflow and list-processing parallelism naturally exposed in the Prograph language, by providing annotations to indicate that operations can be remotely executed, supported by a task-pooling model for parallel execution that preserves the sequential semantics of the language. The goal is a practical system that builds on the comprehensive tools in the Prograph CPX environment in a consistent manner. This will be achieved via high-level editors for hardware configurations, annotations and program analysis, and an underlying kernel that implements the pooling model. 1

Program visualization has been successfully applied to alleviate the complexities of parallel software development. However, those program visualization tools which utilize the more advanced visualization techniques tend to be too complex and specialpurpose to be generally useful. The use of meta-tools, or tools that construct and manipulate other tools, can be applied to simplify the use of complex environments, but meta-tools for program visualization can still require extensive specification for views and information processing details. This proposal provides a design methodology for program visualization meta-tools for parallel software that simplifies the use of such tools while maintaining a high degree of flexibility and expressive power. The approach is based on a meta-tool circulation architecture model that organizes the details of the user specification, and provides a circulation of information which supports a formal means for indicating relationships among ...

Introduction We have implemented a Prolog execution engine for the shared-dataspace language Swarm extended with visualization capabilities. We call this execution engine SwarmExec. SwarmExec runs on a Macintosh Ò IIfx under Advanced A. I. Systems' Prolog (AAIS) and communicates over an Ethernet connection with a Silicon Graphics Personal Iris Ò which serves as a graphical engine and renders the visualizations. This paper describes the major design elements of SwarmExec. A basic familiarity with Swarm and its visualization extensions is assumed; the interested reader is referred to the referenced papers. Section 2 of this paper briefly discusses the translation of Swarm programs into the form used by SwarmExec, called SwarmProlog; this topic will be discussed more completely in a forthcoming paper by Plun and Wilcox on the implementation of a graphical editor and compiler for the language. Section 3 di

We have implemented a C-based graphic engine, called SwarmView, which is used to display animation traces as produced by SwarmExec, the Prolog-based Swarm execution engine. SwarmView runs on a Silicon Graphics Personal Iris running IRIX, a UNIX-based operating system. This paper describes the major design elements of SwarmView. A basic familiarity with Swarm and its visualization extension is assumed; the interested reader is referred to the referenced papers. Familiarity with the paper "SwarmView Animation Vocabulary and Interpretation" is required; the appendices of this paper are reproduced from that one. Section 2 of this paper describes SwarmView's design. Section 3 briefly discusses the user interface with SwarmView.