JavaMod: An integrated Java model for Java software visualization

2006

This paper presents a declarative approach to the debugging of object-oriented programs and illustrates the methodology through an extension of a novel interactive visualization system for Java developed in our previous research. Unlike traditional "procedural" debugging, we use the term "declarative debugging" to refer to a flexible set of queries on individual execution states and also over the entire history of execution (or portion of the history). Examples include queries to find all values assigned to a variable over its lifetime ; which variable has a certain value; the calling sequence that results in a certain outcome; whether a certain statement was executed; etc. These queries were arrived at by a systematic study of errors in objectoriented programs in our previous research. Our proposed system, JavaDD, maintains the execution history as a relational database of salient events, such as method call/return, thread start/end, variable assignment, etc. An important property of our approach is that these queries can be posed interactively (at any step of execution), and there is no need to develop a compiler to instrument the source code, as in related research projects. Furthermore, we also sketch a visual interface so that both queries and answers can be composed using inituitive object and sequence diagrams. We believe such an approach is a significant contribution to the art of program debugging. We present the architecture of JavaDD, a detailed catalog of our queries and their translation, and several examples illustrating the approach. We also compare our approach related research efforts in the area of query-based analysis of object-oriented programs.

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.

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

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.

2018 International Conference on Computing, Electronics & Communications Engineering (iCCECE), 2018

In the domain of Software Engineering, program analysis and understanding has been considered to be a very challenging task since decade, as it demands dedicated time and efforts. The analysis of source code may occasionally be comparatively easier due to its static nature, however, the back-end code (Bytecode), especially in terms of Java programming, is complicated to be analysed. In this paper, we present a methodological approach towards understanding the Bytecode of Java programs. We put forward a framework for the debugging process of Java Bytecode. Furthermore, we discuss the debugging process of Bytecode understanding from simple to multiple statements with regards to data flow analysis. Finally, we present a comparative analysis of Bytecode along with the simulation of the proposed framework for the debugging process.

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.

This paper describes research on visualising Java software at runtime in order to enable the identification of structural features. The aim is to highlight both the static and dynamic structure of the software and aid software engineers in tasks requiring program comprehension of the code. The paper takes the position that this type of analysis and visualisation for object oriented languages must be carried out with dynamic runtime information and that it cannot, in general, be obtained by static analysis alone. A case study is worked through to demonstrate the approach.

Information and Control Systems

Introduction: Over the last years program analysis methods were widely used for software quality assurance. Different types of program analysis require various levels of program representation, analysis methods, etc. Platforms that provide utilities to implement different types of analysis on their basis become very important because they allow one to simplify the process of development. Purpose: Development of a platform for analysis of JVM programs. Results: In this paper we present Kex, a platform for building program analysis tools for JVM bytecode. Kex provides three abstraction levels. First is Kfg, which is an SSA-based control flow graph representation for bytecode-level analysis and transformation. Second is a symbolic program representation called Predicate State, which consists of first order logic predicates that represent instructions of the original program, constraints, etc. The final level is SMT integration layer for constraint solving. It currently provides an inte...

Periodica Polytechnica Electrical Engineering, 2011

Development environments support the programmer in numerous ways from syntax highlighting to different refactoring and code generating methods. However, there are cases where these tools are limited or not usable, such as getting familiar with large and complex source codes written by a third person; finding the complexities of huge projects or finding semantic errors. In this paper we present our static analyzer tool, called 4D Ariadne, which concentrates on these problems. 4D Ariadne is a static debugger of Object Oriented applications written in Java programming language It calculates data dependencies of objects being able to compute them both forward and backward. As 4D Ariadne provides only the direct influences to the user, it can be considered as an alternative of traditional debuggers, without executing the code. 4D Ariadne also provides dynamic call graphs representing polymorphic properties of objects.

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