Isolating cause-effect chains from computer programs

  title={Isolating cause-effect chains from computer programs},
  author={Andreas Zeller},
  booktitle={SIGSOFT '02/FSE-10},
  • A. Zeller
  • Published in SIGSOFT '02/FSE-10 2002
  • Computer Science
Consider the execution of a failing program as a sequence of program states. Each state induces the following state, up to the failure. Which variables and values of a program state are relevant for the failure? We show how the Delta Debugging algorithm isolates the relevant variables and values by systematically narrowing the state difference between a passing run and a failing run---by assessing the outcome of altered executions to determine wether a change in the program state makes a… 

Isolating Cause–Effect Chains

Isolating Cause-Effect Chains with AskIgor - Tool Demo -

AskIgor, a web service for automatically determining causes of program failures, has successfully isolated the causeeffect chain for a failure of the GNU C compiler.

Isolating cause-effect chains with AskIgor

  • A. Zeller
  • Computer Science
    11th IEEE International Workshop on Program Comprehension, 2003.
  • 2003
AskIgor is a Web service for automatically determining causes of program failures by isolated the cause-effect chain of the failure - that is, the variables and values that caused the failure.

Locating causes of program failures

  • Holger CleveA. Zeller
  • Economics
    Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005.
  • 2005
In the evaluation, cause transitions locate the failure-inducing defect twice as well as the best methods known so far.

A Case for Automated Debugging Using Data Structure Repair

A tool-chain where a data structure repair tool generates repair logs that are used by a fault localization tool and a repair abstraction tool that apply in synergy to not only identify the location of fault(s) in code but also to synthesize debugging suggestions is envisioned.

What Went Wrong : Explaining

An automated method is used fording multiple versions of an error (and similar executions that do not produce an error), and analyze these executions to produce a more succinct description of the key elements of the error.

Automatic Failure Inducing Chain Computation through Aligned Execution Comparison

It is shown that a control structure based indexing scheme, when integrated into the formal system, demonstrates very nice properties that can be exploited to develop an effective and efficient debugging algorithm.

Automated path generation for software fault localization

This paper presents an efficient technique where the construction of the successful run as well its comparison with the failing run is automated and the quality of the bug report compares well with those produced by existing fault localization approaches where the programmer manually provides or chooses a successful run.

Explaining abstract counterexamples

Results demonstrating the effectiveness of abstract explanations support this claim, and a technique for explaining and localizing errors based on finding the closest execution to a counterexample, with respect to a distance metric is extended and generalized.

Model Checking and Delta Debugging for Automated Fault Localization ; A Tutorial

Delta debugging framework offers techniques for simplification of test cases and isolation of failure-inducing parts from test cases, which help in debugging and can be adapted for fault localization, and model checking is studied.



Simplifying and Isolating Failure-Inducing Input

The delta debugging algorithm generalizes and simplifies the failing test case to a minimal test case that still produces the failure, and isolates the difference between a passing and a failingTest case.

Isolating failure-inducing thread schedules

By systematically narrowing down the difference between a thread schedule that makes the program pass and another schedule that make the program fail, the Delta Debugging approach can pinpoint the error location automatically---namely, the location(s) where a thread switch causes the program to fail.

Automated Debugging: Are We Close

A new algorithm is described that promises to relieve programmers of the hit-or-miss approach to debugging, using the results of automated testing to systematically narrow the set of failure-inducing circumstances.

Dynamic program slicing

This paper investigates the concept of the dynamic slice consisting of all statements that actually affect the value of a variable occurrence for a given program input, and introduces the economical concept of a Reduced Dynamic Dependence Graph, proportional in size to the number of dynamic slices arising during the program execution.

Tracking down software bugs using automatic anomaly detection

  • Sudheendra HangalM. Lam
  • Computer Science
    Proceedings of the 24th International Conference on Software Engineering. ICSE 2002
  • 2002
The DIDUCE system for Java programs is implemented and applied and suggests that detecting and checking program invariants dynamically is a simple and effective methodology for debugging many different kinds of program errors across a wide variety of application domains.

Algorithmic Program Debugging

An algorithm that can fix a bug that has been identified, and integrate it with the diagnosis algorithms to form an interactive debugging system that can debug programs that are too complex for the Model Inference System to synthesize.

Simplifying failure-inducing input

This work shows how the delta debugging algorithm generalizes and simplifies some failing input to a minimal test case that produces the failure of a program.

An efficient relevant slicing method for debugging

In this paper a forward algorithm is introduced for the computation of relevant slices of programs and it can be applied for real size applications.

A survey of program slicing techniques

  • F. Tip
  • Computer Science
    J. Program. Lang.
  • 1995
An overview of the applications of program slicing, which include debugging, program integration, dataflow testing, and software maintenance is presented, including the various general approaches used to compute slices.

Dynamic slicing of computer programs