We describe Gevol, a system that visualizes the evolution of software using a novel graph drawing technique for visualization of large graphs with a temporal component. Gevol extracts information about a Java program stored within a CVS version control system and displays it using a temporal graph visualizer. This information can be used by programmers to understand the evolution of a legacy program: Why is the program structured the way it is? Which programmers were responsible for which parts of the program during which time periods? Which parts of the program appear unstable over long periods of time and may need to be rewritten? This type of information will complement that produced by more static tools such as source code browsers, slicers, and static analyzers. 1

Abstract not found

This paper describes a way of organizing information aboutan object-oriented program's execution. The context is our system for visualizing that execution. The critical constraints are completeness, compactness, and efficient retrieval. We describe our design and how it meets these constraints. 1 Introduction Much is known about how to characterize programs statically. Contemporary programming languages embody countless lessons learned over nearly a half century of modern computing. It's clear that a language must balance expressiveness and simplicity, abstraction and specificity, flexibility and robustness. The proportions can vary according to need, but programming language design is necessarily a compromise between conflicting goals. We can think of a programming language as defining a vast space of legal programs relatively few of which are of any practical use. To define a space we must have orthogonal dimensions. In the case of structured programming languages we might devote on...

In recent years many prototype systems have been developed for graphically visualizing program execution in an attempt to create a better interface between software engineers and their programs. Several classificationbased taxonomies have been proposed to describe computer program visualization systems and general frameworks have been suggested for implementation. In this paper we provide a framework for both describing existing systems and implementing new ones. We demonstrate the utility of automatic program visualization by re-implementing a number of classic systems using this framework. Résumé Récemment on a développé beaucoup de systèmes prototype pour visualiser graphiquement l'exécution d'un programme afin de créer une meilleure interface entre les créateurs de logiciel et leurs programmes. Plusieurs taxonomies basées sur une classification ont été proposées pour décrire des systèmes de visualization de programmes et des cadres généraux ont été proposés pour leur réalisation. ...

It is very time-consuming and expensive to create the graphical, highly-interactive styles of user interfaces that are increasingly common. User Interface Management Systems (UIMSs) attempt to make the creation of user interfaces easier, but most existing UIMSs cannot create the low-level interaction techniques (pop-up, pull-down and fixed menus, on-screen "light buttons", scroll-bars, ela-borate feedback mechanisms and animations, etc.) that are frequently used. This paper describes Peridot, a system that automatically creates the code for these user inter-faces while the designer demonstrates to the system how the interface should look and work. Peridot uses rule-based inferencing so no programming by the designer is required, and Direct Manipulation techniques are used to create Direct Manipulation interfaces, which can make full use of a mouse and other input devices. This allows extremely rapid protetyping of user interfaces.

The subject of this paper is flow- and context-insensitive pointer analysis. We present a novel approach for precisely modelling struct variables and indirect function calls. Our method emphasises efficiency and simplicity and is based on a simple language of set constraints. We obtain an O(v 4) bound on the time needed to solve a set of constraints from this language, where v is the number of constraint variables. This gives, for the first time, some insight into the hardness of performing field-sensitive pointer analysis of C. Furthermore, we experimentally evaluate the time versus precision trade-off for our method by comparing against the field-insensitive equivalent. Our benchmark suite consists of 11 common C programs ranging in size from 15,000 to 200,000 lines of code. Our results indicate the field-sensitive analysis is more expensive to compute, but yields significantly better precision. In addition, our technique has been integrated into the latest release (version 4.1) of the GNU Compiler GCC. Finally, we identify several previously unknown issues with an alternative and less precise approach to modelling struct variables, known as

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...

Conventional methods for programming a robot either are inflexible or demand significant expertise. While the notion of automatic programming by high-level goal specification addresses these issues, the overwhelming complexity of planning manipulator grasps and paths remains a formidable obstacle to practical implementation. This thesis describes the approach of programming a robot by human demonstration. Our system observes a human performing the task, recognizes the human grasp, and maps it onto the manipulator. Using human actions to guide robot execution greatly reduces the planning complexity. In analyzing the task sequence, the system first divides the observed sensory data into meaningful temporal segments, namely the pregrasp, grasp, and manipulation phases. This is achieved by analyzing the human hand motion profiles. The features used are the fingertip polygon area (the fingertip polygon being the polygon whose vertices are the fingertips), hand speed, and the volume sweep r...

ion There are times when the amount of data produced by a program overwhelms the user. When this happens, an animation confuses more than it educates. If the algorithm is complex, and uses several different data structures and sub-algorithms, the user may get lost in the details and not see the over-all picture. In such cases, the programmer should condense complicated parts of the scene into simpler items, like boxes. This is the approach taken in several videos we have reviewed. Time can also be abstracted, if several phases of an algorithm are omitted and only the final result of several program steps is presented. An ideal system should include facilities that help the programmer implement this sort of abstraction. Ideally, all the detail should be accessible to the user if he/she needs to see it. This is called semantic zooming. Sometimes, of course, it may be desirable to present the viewer with large amounts of information. This occurs when several sorts are simultaneously c...

Modern computer systems routinely present information to the user as a combination of text and diagrammatic images, described as "graphical user interfaces". Practitioners and researchers in Human-Computer Interaction (HCI) generally believe that the value of these diagrammatic representations is derived from metaphorical reasoning; they communicate abstract information by depicting a physical situation from which the abstractions can be inferred. This assumption has been prevalent in HCI research for over 20 years, but has seldom been tested experimentally. This thesis analyses the reasons why diagrams are believed to assist with abstract reasoning. It then presents the results of a series of experiments testing the contribution of metaphor to comprehension, problem solving, explanation and memory tasks carried out using a range of different diagrams. The results indicate that explicit metaphors provide surprisingly little benefit for cognitive tasks using diagrams as an external re...