JADE extensions (JADE-X)

The project JADE Extensions (JADE-X) project aims at developing an intelligent debugging environment that improves the software engineering process by providing assistance in locating and (if possible) correcting bugs in Java programs. Considering the size and complexity of recent computer programs, this is generally a very expensive and time-consuming task. Therefore, research has developed several approaches that deal with debugging and verification of computer programs, each of them using proprietary methodologies and requiring different amount of knowledge. Unlike those approaches, our approach does not deal with formal verification of programs, the debugging tool to be developed during JADE-X adapts model-based diagnosis (MBD) for debugging. MBD has been developed for finding and fixing faults in hardware and is based on a component- oriented model of the system describing its functionality. This approach can also be used for software debugging. In this domain, the components are constructed from various elements of the program, such as statements or expressions. The connections are derived from the used and modified variables. However, it is not easy to develop a general model that can be used to locate different kinds of faults efficiently, as the model influences e.g. the number of bug candidates. Hence, the development of suitable models for program debugging depends on multiple aspects and has to be investigated carefully. JADE-X is based on the results obtained during the previous project (JADE) and extends the results in order to provide better results. Multiple models representing different abstractions of programs are to be developed in order to provide better results for different kinds of faults without an increased amount of user interaction. Combinations of such models are expected to considerably enhance the debugging process, as a reduction in bug candidates, diagnosis time and user interaction can be achieved. Project JADE-X is expected to deliver multiple models of Java programs (including object-oriented features), knowledge about when to apply which models, an improvement of available diagnosis algorithms and an empirical evaluation of the results using a collection of real- world examples. Finally, a debugging tool for Java programs is to be implemented that includes multiple models, diagnosis algorithms and mechanisms to express the desired behavior of a program.

During the last decade, object-oriented programming languages like, for example, the Java programming language, have become increasingly popular to master today`s ever increasing complexity in Software engineering. In order to reduce time to market, which becomes increasingly important in today`s fast paced economy, applying formal verification techniques and extensive testing is imperative in order to cope with the error-prone development process of large-scale projects. However, if some faulty behavior is identifed due to testing or automated verification, the location of the error in the source code is of particular interest. Nevertheless, there is currently almost no Support for the designer in fixing the faults thus found. Traditional debuggers force the developer to go through the code and therefore fault localization and error correction is a time consuming task. The project JADE-X (JADE eXtensions) addresses these issues by conducting research an automated Software debugging particularly for the object-oriented mainstream programming language Java. Within the predecessor project JADE (Java Debugging Experiments) research an applying the model-based diagnosis paradigm for debugging object-oriented languages has been conducted. Basically, the developed techniques are applicable, however, modeling, or in other words - capturing the relevant aspects for fault localization in a so called debugging model - turns out to be a difficult and crucial task. Whereas JADE project has shown that model-based reasoning techniques are applicable in the area of object-oriented programming languages, the goal of JADE-X is to extend the models developed in JADE thereby establishing foundational support for the construction of semiautomated and automated debuggers. As Software projects become increasingly complex, it is important to capture those aspects of a program that might be responsible for causing detected misbehavior thereby leaving aside the irrelevant attributes. Specifically this is highly desirable to reduce the debugging model`s size and thus the time for computing faulty candidates. To reach a high degree of overall automation, the task of modeling has to be carried out fully automatically, thus JADE-X is concerned with finding program abstractions that can be deduced from the faulty program without any user interaction. However, a straightforward modeling approach often bottoms out in either unacceptable response times or inaccurate localization of the fault. To address the previously mentioned intricacies JADE-X conducted research in two directions. First, rather abstract models, so called dependence models developed in the JADE project - have been improved. These models are tailored towards localizing faults in very big programs and deliver limited amount of accuracy but allow for very fast computation of fault candidates. Notably, the improved models allow for fault localization under presence of aliasing. Second, JADE-X conducted research an fner-grained debugging modes. At the cost of an increased computational effort these models allow for localizing faults at the granularity of Statements or expressions. To address the trade-off between diagnosis accuracy and the effort necessary to compute the diagnosis candidates, JADE-X specifically conducted research an iterative refinement - a novel technique specifically for modeling in fault detection rather than localization. In this respect JADE-X contributed to automated Software debugging not only in providing tailored models for fault localization relying an iterative refinement in terms of Boolean programs but also in the closer integration of verification techniques, that is - methods to detect misbehavior - and fault localization techniques. Finally, JADE-X also established First empirical grounds, particular for models relying an Boolean abstractions. The ability to apply so called Boolean programs for fault localization motivates further research since - at least for certain types of object-oriented programs - similar results than those achieved for Hardware Description Languages appear to be prospective in the near future.