# Locating Faults with Program Slicing: An Empirical Analysis

arXiv: https://arxiv.org/abs/2101.03008 · HTML: https://mlsanity.com/paper/2101.03008/

## Key facts

- Cited by 7 papers in the map (data through 14 Oct 2026).
- First posted on arXiv 8 Jan 2021.

## Built on by (most cited first, 7 of 7)

- [Who is Introducing the Failure? Automatically Attributing Failures of Multi-Agent Systems via Spectrum Analysis](https://mlsanity.com/paper/2509.13782/) (2025)
- [SweRank: Software Issue Localization with Code Ranking](https://mlsanity.com/paper/2505.07849/) (2025)
- [On the Role of Fault Localization Context for LLM-Based Program Repair](https://mlsanity.com/paper/2604.05481/) (2026)
- [CFaults: Model-Based Diagnosis for Fault Localization in C Programs with Multiple Test Cases](https://mlsanity.com/paper/2407.09337/) (2024)
- [SLICEMATE: Accurate and Scalable Static Program Slicing via LLM-Powered Agents](https://mlsanity.com/paper/2507.18957/) (2025)
- [Model-Based Diagnosis with Multiple Observations: A Unified Approach for C Software and Boolean Circuits](https://mlsanity.com/paper/2512.02898/) (2025)
- [FLARE: Agentic Coverage-Guided Fuzzing for LLM-Based Multi-Agent Systems](https://mlsanity.com/paper/2604.05289/) (2026)

## Abstract (arXiv)

Statistical fault localization is an easily deployed technique for quickly determining candidates for faulty code locations. If a human programmer has to search the fault beyond the top candidate locations, though, more traditional techniques of following dependencies along dynamic slices may be better suited. In a large study of 457 bugs (369 single faults and 88 multiple faults) in 46 open source C programs, we compare the effectiveness of statistical fault localization against dynamic slicing. For single faults, we find that dynamic slicing was eight percentage points more effective than the best performing statistical debugging formula; for 66% of the bugs, dynamic slicing finds the fault earlier than the best performing statistical debugging formula. In our evaluation, dynamic slicing is more effective for programs with single fault, but statistical debugging performs better on multiple faults. Best results, however, are obtained by a hybrid approach: If programmers first examine at most the top five most suspicious locations from statistical debugging, and then switch to dynamic slices, on average, they will need to examine 15% (30 lines) of the code. These findings hold for 18 most effective statistical debugging formulas and our results are independent of the number of faults (i.e. single or multiple faults) and error type (i.e. artificial or real errors).