Algorithmic Debugging of Java Programs

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.

2010 IEEE International Conference on Software Maintenance, 2010

This work presents DDJ, an algorithmic debugger for Java. The main advantage of DDJ with respect to previous algorithmic debuggers is its scalability. DDJ has a new architecture based on the use of cache memories that allows it to scale both in time and memory. In addition, it includes new techniques that allow the debugger to start the debugging session even before the execution tree has been produced. We present the new architecture, and describe the main features of this debugger together with a usage scenario.

2007

This paper presents a logic based approach to debugging Java programs. In contrast with traditional debugging we propose a debugging methodology for Java programs using logical queries on individual execution states and also over the history of execution. These queries were arrived at by a systematic study of errors in object-oriented programs in our earlier research. We represent the salient events during the execution of a Java program by a logic database, and implement the queries as logic programs. Such an approach allows us to answer a number of useful and interesting queries about a Java program, such as the calling sequence that results in a certain outcome, the state of an object at a particular execution point, etc. Our system also provides the ability to compose new queries during a debugging session. We believe that logic programming offers a significant contribution to the art of object-oriented programs debugging.

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.

Electronic Notes in Theoretical Computer Science, 2009

Algorithmic debugging is a semi-automatic debugging technique which is based on the answers of an oracle (usually the programmer) to a series of questions generated automatically by the algorithmic debugger. The technique typically traverses a record of the executionthe so-called execution tree-which only captures the declarative aspects of the execution and hides operational details. In this work we overview and compare the most important algorithmic debuggers of different programming paradigms. In the study we analyze the most important features incorporated by current algorithmic debuggers, and we identify some features not supported yet by any debugger. We then compare all the debuggers giving rise to a map of the state of the practice in algorithmic debugging. /95/23/2003/077-054 and by the Vicerrectorado de Innovación y Desarrollo de la UPV under project TAMAT ref. 5771. 1 Depending on the programming paradigm, the execution tree is called differently, e.g., Proof Tree, Computation Tree, Evaluation Dependence Tree, etc. We use ET to refer to any of them.

Lecture Notes in Computer Science, 2015

Algorithmic debugging is a semi-automatic debugging technique that is present in practically all mature programming languages. In this paper we claim that the state of the practice in algorithmic debugging is a step forward compared with the state of the theory. In particular, we argue that novel techniques for algorithmic debugging cannot be supported by the standard internal data structures, such as the Execution Tree (ET), used in this technique, and hence a generalization of the standard definitions and algorithms is needed. We identify two specific problems of the standard formulation and implementations of algorithmic debugging, and we propose a reformulation to solve both problems. The reformulation has been done in a paradigm-independent manner to make it useful and reusable in different programming languages.

Proceedings of the 2007 OOPSLA workshop on eclipse technology eXchange - eclipse '07, 2007

We present a declarative and visual debugging environment for Eclipse called JIVE. 1 Traditional debugging is procedural in that a programmer must proceed step-by-step and objectby-object in order to uncover the cause of an error. In contrast, we present a declarative approach to debugging consisting of a flexible set of queries over a program's execution history as well as over individual runtime states. This runtime information is depicted in a visual manner during program execution in order to aid the debugging process. The current state of execution is depicted through an enhanced object diagram, and the history of execution is depicted by a sequence diagram. Our methodology makes use of these diagrams as a means of formulating queries and reporting results in a visual manner. It also supports revisiting past runtime states, either through reverse stepping of the program or through queries that report information from past states. Eclipse serves as an ideal framework for implementing JIVE since, like the JIVE architecture, it makes crucial use of the Java Platform Debugging Architecture (JPDA). This paper presents details of the JIVE architecture and its integration into Eclipse.

ACM Computing Surveys, 2018

Algorithmic debugging is a technique proposed in 1982 by E. Y. Shapiro in the context of logic programming. This survey shows how the initial ideas have been developed to become a widespread debugging schema fitting many different programming paradigms and with applications out of the program debugging field. We describe the general framework and the main issues related to the implementations in different programming paradigms and discuss several proposed improvements and optimizations. We also review the main algorithmic debugger tools that have been implemented so far and compare their features. From this comparison, we elaborate a summary of desirable characteristics that should be considered when implementing future algorithmic debuggers.

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.

1994

Declarative error diagnosis of logic programs was introduced in Sh82]. Other work in error diagnosis has focused on adding various kinds of control to the declarative diagnoser Av84], or extending the debugging to a larger class of programs Pe86]. In all this work the error that is detected is either an incorrect clause instance, which represents an incorrect implication in the intended interpretation, or there is a goal on which the program fails when it should succeed because the clauses in the program don't \cover" it. In this work we re ne the notion of an error so that the exact place in the clause where the error occurs can be identi ed. This is made possible by reasoning with the intensional semantics of the program rather than the extensional semantics.