A survey on algorithmic debugging strategies

Abstract

Algorithmic debugging is a debugging technique that has been extended to practically all programming paradigms. Roughly speaking, the technique constructs an internal representation of all (sub)computations performed during the execution of a buggy program; and then, it asks the programmer about the correctness of such computations. The answers of the programmer guide the search for the bug until it is isolated by discarding correct parts of the program. After twenty years of research in algorithmic debugging many different techniques have appeared to improve the original proposal. Surprisingly, no study exists that joins together all these techniques and compares their advantages and their performance. This article presents a study that compares all current algorithmic debugging techniques and analyzes their differences and their costs. The research identifies the dimensions on which each strategy relies. This information allows us to combine the strong points of different strategies.

A Generalized Model for Algorithmic Debugging

“…Roughly, traceable buggy nodes are those buggy nodes that may be directly responsible of the wrong behavior of the program (their effects are visible in the root of the tree). This property makes them debuggable by all AD strategies that are variants of Top-Down (see [29]). …”

“…During many years, the main goal of most AD researchers has been the definition of better strategies to reduce the search space after every answer, and to reduce the complexity of the questions. A survey of search strategies for AD can be found in [29]. In our formalization, a search strategy is just a function that analyzes the ET and returns an execution node (either the next node to ask, or a buggy node).…”

Enhancing Declarative Debugging with Loop Expansion and Tree Compression

“…Although these nodes could be omitted, if they are kept, the ET becomes more balanced. Balanced ETs are very convenient for strategies such as Divide and Query [16], because it is possible to prune almost half of the tree after every answer, thus obtaining a logarithmic number of questions with respect to the number of nodes in the ET. This approach is related to our technique, but it has some drawbacks: it can only be applied where transitivity inferences took place while creating the ET, and thus most of the parts of the tree cannot be balanced, and even in these cases the balancing only affects two nodes.…”

“…In both cases, we will always implicitly refer to the most efficient version of both strategies, respectively named, (i) Heaviest First [1], which always traverses the ET from the root to the leaves selecting always the heaviest node; and (ii) Hirunkitti's Divide and Query [6], which always selects the node in the ET that better divides the number of nodes in the ET by the half. A comparative study of these techniques can be found in [16].…”

“…One notable exception is Declarative Debugging [15,16]. In this work we present a technique to improve the performance of Declarative Debugging reducing the debugging time.…”