Model-Based Debugging of Java Programs

This paper extends our previous work on the representation and analysis of Java programs for diagnosis in a new direction by providing a description and analysis of the issues arising from handling object references in dependency-based models of Java programs. We empirically compare dependencybased models with a value-based model using a set of example programs in terms of required user interaction (questions put to the user) and examine and incorporate specific interesting error categories. Apart from being based on experience with an actual implementation of the various models, the model extensions and analysis deal with aliasing, an issue that the programming language community has been examining for a long time, and that is also crucial to object-orientedness.

In Proceedings of the Eleventh …, 2000

Lecture Notes in Computer Science, 2002

Even with modern software development methodologies, the actual debugging of source code, i.e., location and identification of errors in the program when errant behavior is encountered during testing, remains a crucial part of software development. To apply model-based diagnosis techniques, which have long been state of the art in hardware diagnosis, for automatic debugging, a model of a given program must be automatically created from the source code. This work describes a model that reflects the execution semantics of the Java language, including exceptions and unstructured control flow, thereby providing unprecedented scope in the application of model-based diagnosis to programs. Besides the structural model building process, a behavioral description of some of the model components is given. Finally, impacts of the modeling decisions on the diagnostic process are considered.

2007

Program debugging is a difficult and time-consuming task. Our ultimate goal in this work is to help developers reduce the space of potential root causes for failures, which can, in turn, improve the turn around time for bug fixes. We propose a novel and very different approach. Rather then focusing on how a program behaves by analyzing its source code and/or execution traces, we concentrate on how it should behave with respect to a given behavioral model. We identify and verify slices of the behavior model, that, once implemented wrong in the program, can potentially lead to failures. Not only do we identify functional differences between the program and its model, but we also provide a ranked list of diagnoses which might explain (or be associated with) these differences. Our experiments suggest that the proposed approach can be quite effective in reducing the search space for potential root causes for failures.

Artificial Intelligence, 2002

AI Communications, 1998

IFIP International Federation for Information Processing, 2005

Recent years have seen considerable developments in modeling techniques for automatic fault location in programs. However, much of this research considered the models from a standalone perspective. Instead, this paper focuses on the highly unusual properties of the testing and measurement process, where capabilities differ strongly from the classical hardware diagnosis paradigm. In particular, in an interactive debugging process user interaction may result in highly complex input to improve the process. This work proposes a heuristic entropy-based measurement selection algorithm, which incorporates high-level properties of the intended behavior of Java programs, specific to a set of test cases. We show how to integrate the approach into previously developed modelbased debugging frameworks and how reasoning about high-level properties of programs can improve fault localization.

ECAI, 2002

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.

2008 23rd IEEE/ACM International Conference on Automated Software Engineering, 2008

Developing model-based automatic debugging strategies has been an active research area for several years, with the aim of locating defects in a program by utilising fully automated generation of a model of the program from its source code. We provide an overview of current techniques in model-based debugging and assess strengths and weaknesses of the individual approaches. An empirical comparison is presented that investigates the relative accuracy of different models on a set of test programs and fault assumptions, showing that our abstract interpretation based model provides high accuracy at significantly less computational effort than slightly more accurate techniques. We compare a range of model-based debugging techniques with other state-of-the-art automated debugging approaches and outline possible future developments in automatic debugging using model-based reasoning as the central unifying component in a comprehensive framework.

Developing model-based automatic debugging strategies has been an active research area for sev- eral years. We present a model-based debug- ging approach that is based on Abstract Interpre- tation, a technique borrowed from program analy- sis. The Abstract Interpretation mechanism is inte- grated with a classical model-based reasoning en- gine. We test the approach on sample programs and provide the first experimental comparison with earlier models used for debugging. The results show that the Abstract Interpretation based model provides more precise explanations than previous models or standard non-model based approaches.

Iet Software/iee Proceedings - Software, 1997

The model tracing based approach to intelligent program diagnosis and tutoring emphasises the fact that the student's design decisions are traced as the student develops the program. A system based on this model monitors the user's actions as helshe moves along the solution path, automatically analyses partial solutions for semantic errors and misconceptions, and offers guidance whenever helshe deviates from the correct solution path. In this way, the system always checks to see if the student is following the design path of an ideal model. Buggy paths are pruned as soon as they are discovered. Through this approach to automatic diagnosis and tutoring, a model-tracing system can, first, diagnose very specific errors and misconceptions and provide clear advice and explanations within a proper and immediate context; secondly, explicitly guide the user in the process of organising different programming concepts and statements, and, thirdly, simplify the engineering of automatic diagnosis by preventing multiple bugs and errors. However, this approach is very directive and interventionist. The user is highly constrained in the solutions that can be developed, as helshe must conform to the task decomposition and coding sequence enforced by model-tracing systems. To bypass these pitfalls associated with the traditional model-tracing approach, solutions and guidelines are suggested for improving the engineering of model tracing based diagnosis.

Computing Research Repository - CORR, 2003

This paper introduces an automatic debugging framework that relies on model-based reasoning techniques to locate faults in programs. In particular, model-based diagnosis, together with an abstract interpretation based conflict detection mechanism is used to derive diagnoses, which correspond to possible faults in pro- grams. Design information and partial specifications are applied to guide a model revision process, which allows for automatic detection and correction of structural faults.

Industrial and Engineering …, 1996

Model-Based Program Debugging and Repair Markus Stumptner and Franz Wotawa Christian Doppler Laboratory for Expert Systems Institut fur Informationssysteme. Technische Universitat VVien Paniglgasse 16. 1040 Wien. Austria, Europe Email:{mst,\ votawa}< § ) dbai. tu\ ...

In this paper we present an approach that relies on the representation of the debugging problem as a constraint satisfaction problem. We show how arbitrary sequential programs together with specification knowledge like invariants can be represented as a set of constraints. We provide a formalization of the constraint representation and of the diagnosis problem which clarifies and improves previously published ideas. We also correct a flaw in a previously published paper which could lead to undesired diagnostic results. Moreover, based on the constraint representation we explain how to use a fast constraint solver, which is freely available, for computing diagnoses. Using such a constraint solver we obtain first experimental results for a set of Java programs. The results indicate that the use of specification knowledge reduces the number of diagnoses substantially. This shows that the integration of specifications like pre-and postconditions or invariants, which can be provided as annotations in the program, can significantly help to make model-based debugging applicable in practice.