An Execution Backtracking Approach to Program Debugging (original) (raw)
Related papers
An Execution-Backtracking Approach to Debugging
IEEE Software, 1988
An execution backtracking facility in interactive source debuggers allows users to mirror their thought processes while debugging -working backwards from the location where an error is manifested and determining the conditions under which the error occurred. Such a facility also allows a user to change program characteristics and reexecute from arbitrary poin ts within the program under examination -a "what-if" capability.
An execution-backtracking approach to debugging
1991
Abstract Spyder, a system for selective checkpointing of computational sequences, is presented. It lets users backtrack from checkpoints without the need to reexecute the program to reach recent prior states. In contrast to more comprehensive (and storage-intensive) checkpointing schemes, backtracking in this approach is constrained to limit storage requirements. The resulting debugger offers a structured view of dynamic events, similar to lexical scope rules' effect on static visibility.
Efficient Debugging with Slicing and Backtracking
Spe, 1990
Programmers spend considerable time debugging code. Several tools are available to help them in this task, varying from hexadecimal dumps of program state to window-and mouse-based interactive debuggers, but the task still remains complex and difficult. Most of these conventional debuggers provide breakpoints and traces as their main debugging aids. These features have changed little in the past 15-20 years despite the increased complexity of software systems on which debuggers are used.
2000
Programmers spend considerable time debugging code. Several tools are available to help them in this task, varying from hexadecimal dumps of program state to window- and mouse-based interactive debuggers, but the task still remains complex and difficult. Most of these conventional debuggers provide breakpoints and traces as their main debugging aids. These features have changed little in the past 15-20
Efficient debugging with slicing and backtracking
1990
Abstract Programmers spend considerable time debugging code. Several tools are available to help them in this task, varying from hexadecimal dumps of program state to window-and mouse-based interactive debuggers, but the task still remains complex and difficult. Most of these conventional debuggers provide breakpoints and traces as their main debugging aids. These features have changed little in the past 15–20 years despite the increased complexity of software systems on which debuggers are used.
Debugging with Dynamic Slicing and Backtracking
SUMMARY Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task remains complex and difficult. Other than breakpoints and tracing, these tools provide little high-level help. Programmers must perform many tasks manually that the tools could perform automatically, such as finding which statements in the program affect the value of an output variable for a given test case, and what was the value of a given variable when the control last reached a given program location. If debugging tools provided explicit support for these tasks, the debugging process could be automated to a significant extent. In this paper we present a debugging model, based on dynamic program slicing and execution backtracking techniques, that easily lends itself to automation. This model is based on experience with using these techniques to debug software. We also present a prototype debugging tool, SPYDER, that explicitly supports the proposed model, and with which we are performing further debugging research. KEY WORDS program debugging Execution backtracking Reverse program execution Program slicing Dynamic program slicing
Debugging with dynamic slicing and backtracking
Software: Practice and Experience, 1993
Programmers spend considerable time debugging code. Symbolic debuggers provide some help but the task remains complex and di cult. Other than breakpoints and tracing, these tools provide little high-level help. Programmers must perform many tasks manually that the tools could perform automatically, such as nding which statements in the program a ect the value of an output variable for a given testcase, and what was the value of a given variable when the control last reached a given program location. If debugging tools provided explicit support for these tasks, the debugging process could be automated to a signi cant extent.
A portable virtual machine for program debugging and directing
2004
Abstract Directors are reactive systems that monitor the run-time environment and react to the emitted events. Typical examples of directors are debuggers and tools for program analysis and software visualization. In this paper we describe a cross-platform virtual machine that provides advanced facilities for implementing directors with low effort.
A framework for automatic debugging
Proceedings 17th IEEE International Conference on Automated Software Engineering,, 2002
This paper presents an application framework in which declarative specifications of debugging actions are translated into execution monitors that can automatically detect bugs. The approach is non-intrusive with respect to program source code and provides a high level of abstraction for debugging activities.
Dynamic slicing in the presence of unconstrained pointers
1991
Program slices are useful in debugging. Most work on program slicing to date has concentrated on nding slices of programs involving only scalar variables. Pointers and composite variables do not lend themselves well to static analysis, especially when the language involved is not strongly-typed. When debugging a program, however, we are interested in analyzing the program behavior for testcases that reveal a fault. In this paper, we present a uniform approach to handling pointers and composite variables such a s arrays, records, and unions for the purpose of obtaining dynamic program slices. The dynamic approach proposed works well even when the language involved allows unconstrained pointers and performs no runtime checks, as in C.