JIVE: Java Interactive Software Visualization Environment

2010

We describe a pedagogic tool called JIVE (Java Interactive Visualization Environment) for clarifying the dynamic behavior of Java programs. The tool has the following main goals: provide clear visualizations of execution state and call history, with varying levels of granularity; show method calls within object contexts; support declarative queries over executions; and, support forward and reverse stepping. JIVE employs extensions of UML object and sequence diagrams to represent execution state and call history. While these diagrams are normally used as design-time specifications, their use for depicting run-time behavior helps close the gap between design and execution. We illustrate the use of JIVE for understanding typical data structure operations. JIVE has been tested in programming language courses for the past three years.

Proceedings IEEE 2002 Symposia on Human Centric Computing Languages and Environments, 2002

The design and implementation of a novel visual interactive execution environment for Java is described. This system displays both the run-time object structure as well as the internal details of object and method activations. The representation of the execution state is based upon a novel yet simple representation technique which clarifies the important fact that objects are environments. All major Java features, including inheritance, inner classes, static methods, exceptions, etc., are supported. The GUI components built from Java's Swing or AWT libraries can be visualized in juxtaposition with the underlying execution state. We also include a reverse-execution mechanism that allows a user to rollback to previous states of an execution. A notable characteristic of the visualization system is that it employs the existing Java Virtual Machine, i.e., no new Java interpreter is needed. A novel pre-processor (source-to-source transformation) is employed in conjunction with a run-time mediator written in Java, which carries out the visualization. A prototype of these ideas has been completed to validate the entire approach.

Proceedings of the 4th International Conference on Computer Supported Education, 2012

We provide an explicit, consistent, execution model for OO programs, specifically Java, together with a tool that visualizes the model This equips the student with a model to think and communicate about OO programs. Especially for an e-learning situation this is significant. Firstly, such a model supports the interaction with teachers and provides a sound basis for the understanding of other e-learning material concerning programming. Secondly, the tool supports acquiring proficiency with the model in an e-learning setting by giving precise information to hone his/her conceptualization of program execution. The model is advanced in that it accommodates multi-threading. The tool is flexible in that it directly uses the Java Virtual Machine for the visualization: extensions and adaptations can thus make use of the information the actual execution provides. A case in point is modeling the execution of code involving user interaction through the Graphic User Interface library. We consider several options here.

2003

Visualisation is a powerful method for explaining how programs work. However, while it is advantageous in theory, it is not used as frequently as it might be. Patterns may be used to describe architectures, so in this paper we present a pattern language in two parts. The first part describes a set of patterns for approaching the development of program-specific visualisations. The second focusses on actual implementation of the visualisations using the InspectJ framework, which uses AspectJ to monitor programs at run time. The patterns step through the process of building a visualisation from start to finish, featuring a running example of the development of a visualisation for a simulation program. After reading these patterns, you should be able to use InspectJ to create visualisations for your own Java programs.

2004

Electronic Notes in Theoretical Computer Science, 2009

Electronic Notes in Theoretical Computer Science, 2009

Informatics in Education

In this paper, we present an open-source program visualization tool, Jeliot 3. We discuss the design principles and philosophy that gave rise to this successful e-learning tool and to several other related environments. Beside Jeliot 3, we introduce three different environments, BlueJ, EJE, and JeCo that use Jeliot 3 as a plug-in to allow visualization of the program code. Another system, FADA, is a tool that was derived from Jeliot 3 but serves for different pedagogical goals. A community of users and developers of these projects has been created and supported, that allows for global and iterative improvements of the Jeliot 3 tool. This way, both academic research and feedback from the user community contribute to the development. We compare the presented approach of the tool development to some of the current tools and we discuss several instances evidencing a particular success.

Proceedings of the 2005 ACM symposium on Software visualization - SoftVis '05, 2005

A novel approach to the runtime visualization and analysis of object-oriented programs is presented and illustrated through a prototype system called JIVE: J ava I nteractive V isualization E nvironment. The main contributions of JIVE are: multiple concurrent representations of program state and execution history; support for forward and reverse execution; and graphical queries over program execution. This model facilitates program understanding and interactive debugging. Our visualization of runtime states clarifies the important point that objects are environments of execution. The history of object interaction is displayed via sequence diagrams, and in this way we help close the loop between design-time and run-time representations. Interactive execution is made possible by maintaining a runtime history database, which may be queried for information on variable behavior, method executions, and object interactions. We illustrate the capabilities of this system through examples. JIVE is implemented using the Java Platform Debugger Architecture and supports the Java language and libraries, including multithreaded and GUI applications.