Identifying Structural Features of Java Programs by Analysing the Interaction of Classes at Runtime (original) (raw)

JavaMod: An integrated Java model for Java software visualization

Program Visualization …

Given the practical importance and complexity of object-oriented programming, there are many software visualization systems (VSs) for these languages. These systems use different forms of visualization to assist in understanding object-oriented applications. In particular, some VSs are designed to visualize programs written in the Java programming language (and they are often implemented in such a language, too). Java is an attractive language for visualization developers, because it is a "comfortable" language and it is simple to build visualizations in Java. In the particular case of Java VSs implemented in Java itself, there is an additional advantage: the Java Virtual Machine provides an interface to debug programs written in Java, namely JPDA (JPDA). This interface avoids the need of using external debuggers or of generating program traces. The former often involves obscure interfaces; the latter requires to introduce additional code within the target program in order to extract information at run-time.

Software Visualisation of Java Programs in InspectJ

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.

Runtime visualisation of object oriented software

Visualizing Software for Understanding …, 2002

The need to understand a piece of software, in terms of its source code and how it works, is key to maintenance and development tasks. Whether it is the need to add new functionality, fix an error, or simply help a new developer join an existing project, gaining an understanding ...

Analyzing Java software by combining metrics and program visualization

Proceedings of the Fourth European Conference on Software Maintenance and Reengineering, 2000

Abstract Shimba, a prototype reverse engineering environment, has been built to support the understanding of Java software. Shimba uses Rigi and SCED to analyze, visualize, and explore the static and dynamic aspects, respectively, of the subject system. The static software artifacts and their dependencies are extracted from Java byte code and viewed as directed graphs using the Rigi reverse engineering environment. The static dependency graphs of a subject system can be annotated with attributes, such as software quality ...

Visualization of Object-Oriented (Java) Programs

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.

On understanding the statics and dynamics of object-oriented programs

SIGCSE bulletin, 2005

This paper describes research into the influence of using static (class and object) visualization on understanding program flow in object-oriented programming. We found that the advantages of using the static visualization in the first stages of learning could become disadvantages in the advanced stages. The teacher must be aware of these pitfalls and plan the learning sequence accordingly. We think that the BlueJ learning environment that we used should be augmented with dynamic visualization so that students can coordinate the static and dynamic aspects of objectoriented programs.

Interactive visualization of Java programs

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.

JIVE: A Pedagogic Tool for Visualizing the Execution of Java Programs

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.

Control and Data Flow Execution of Java Programs

ArXiv, 2017

Since decade understanding of programs has become a compulsory task for the students as well as for others who are involved in the process of developing software and providing solutions to open problems. In that aspect showing the problem in a pictorial presentation in a best manner is a key advantage to better understand it. We provide model and structure for Java programs to understand the control and data flow analysis of execution. Especially it helps to understand the static analysis of Java programs, which is an uttermost important phase for software maintenance. We provided information and model for visualization of Java programs that may help better understanding of programs for a learning and analysis purpose. The idea provided for building visualization tool is extracting data and control analysis from execution of Java programs. We presented case studies to prove that our idea is most important for better understanding of Java programs which may help towards static analys...