Evaluating variations on program slicing for debugging (data-flow, ada)
James R. Lyle · 1984
Debugging and maintaining computer programs is a difficult and time consuming task. The traditional methods used by a programmer to understand a program such as reading program text, reading program documentation, ad hoc testing with different inputs, or dynamic tracing, often overwhelm the programmer with details that have nothing to do with what he wants to know. A solution to this information overload problem is to reduce the amount of detail a programmer sees by an application of data-flow analysis, program slicing, that can be used to transform a large program into a smaller one containing only those statements relevant to the computation of a given output. Debugging tools have evolved through three generations. The first generation of tools produced information such as core dumps and instruction execution traces in terms of the underlying hardware. The second generation of debugging tools, often called symbolic debuggers, produced program state and history information in terms of the programming language being used. A third generation of debugging tools that attempt to locate faulty statements for the programmer has begun to emerge. The goal of this thesis was to evaluate program slicing as a debugging tool. To evaluate slicing we built a visually oriented, source-language independent, third generation debugging tool called Focus that can interactively compute and display program slices of FORTRAN and Ada programs. Focus was evaluated by comparing debugging performance between two groups of graduate student programmers. We also developed a method for combining program slices, called program dicing, to identify likely locations for faults within a program slice. Program dicing was evaluated by first introducing random errors into correct programs and then using program dicing to isolate the now incorrect statement. We found that dicing could eliminate from 93 to 98 percent of program statements from consideration while debugging a 118 line program. A second evaluation of dicing was made by comparing debugging performance between two groups of experienced student programmers. We found a significant improvement in the time to locate a program fault for subjects using dicing.