Software is invisible, disappearing into files on disks. The invisible nature of software contributes to low programmer productivity by hiding system complexity, particularly for large team-oriented projects. Visualization can help software engineers cope with this complexity and thereby increase programmer productivity. We describe four innovative visual representations of software that scale to productionsized systems and illustrate their usage in five software case studies involving: version history, differencing, static properties, performance profiles, and dynamic program slices. Keywords: software visualization, legacy code, version history, program comparison, profiling, slicing. 1 Introduction It is well known that large computer programs are complex and difficult to maintain. Production-sized systems, particularly legacy software, may contain millions of lines of code. Even a seemingly simple, small-team software project, such as a spreadsheet, is very complicated [CE94]. ...

Program visualization may be viewed as a mapping from programs to graphical representations. This simple idea provides a formal framework for a new taxonomy of program visualization systems. The taxonomy is compared briefly against previous attempts to organize the program visualization field. The taxonomic principles and their motivation are explained in detail with reference to a number of existing systems, especially Balsa, Tango, and Pavane.

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.

Abstract not found

SeeSys TM is a system embodying a technique for visualizing statis-tics associated with code that is divided hierarchically into subsystems, directories, and les. This technique can display therelative sizes of the components in the system, the relative stability of the components, the location of new functionality, and the location of error-prone code with many bug xes. Using animation, it can display the historical evolution of the code. Applying this technique, the source code from amulti-million line production software product is visualized.

Graphical animation is a way of visualizing the behavior of design models. This visualization is of use in validating a design model against informally specified requirements and in interpreting the meaning and significance of analysis results in relation to the problem domain. In this paper we describe how behavior models specified by Labeled Transition Systems (LTS) can drive graphical animations. The semantic framework for the approach is based on Timed Automata. Animations are described by an XML document that is used to generate a set of JavaBeans. The elaborated JavaBeans perform the animation actions as directed by the LTS model. Keywords Labeled Transition System, Graphic Animation, Behavior Analysis 1 INTRODUCTION A model-based design approach involves building analysis models early in the software lifecycle. These models can be developed shortly after the initial requirements capture and refined in parallel with further requirements elicitation so that early feedback on ...

Abstract not found

In this paper we present LEONARDO, an integrated environment for software visualization that allows the user to edit, compile, execute, and animate general-purpose C programs.

Until now, only users of textual programming languages have enjoyed the fruits of algorithm animation. Users of visual programming languages (VPLs) have been deprived of the unique semantic insights algorithm animation offers, insights that would foster the understanding and debugging of visual programs. To begin solving this shortcoming, we have seamlessly integrated algorithm animation capabilities into Forms/3, a declarative VPL in which evaluation is the continuous maintenance of a network of one-way constraints. Our results show that a VPL that uses this constraint-based evaluation model can provide features not found in other algorithm animation systems. 1: Introduction Algorithm animation is a type of software visualization of growing importance. It is a dynamic visualization of the main abstractions of a program's underlying algorithm. The value of algorithm animation lies in its ability to portray the essence of the program's logic, avoiding the obscuring of this essence tha...

Abstract. Program errors are hard to find because of the cause-effect gap between the time when an error occurs and the time when the error becomes apparent to the programmer. Although debugging techniques such as conditional and data breakpoints help to find error causes in simple cases, they fail to effectively bridge the cause-effect gap in many situations. Dynamic query-based debuggers offer programmers an effective tool that provides instant error alert by continuously checking inter-object relationships while the debugged program is running. To speed up dynamic query evaluation, our debugger (implemented in portable Java) uses a combination of program instrumentation, load-time code generation, query optimization, and incremental reevaluation. Experiments and a query cost model show that selection queries are efficient in most cases, while more costly join queries are practical when query evaluations are infrequent or query domains are small. 1.