A Grounded Theory of Debugging in Professional Software Engineering Practice

Debugging is a central yet complex activity in software engineering. Prior studies have documented debugging strategies and tool usage, but little theory explains how experienced developers reason about bugs in large, real-world codebases. We conducted a qualitative study using a grounded theory approach. We observed seven professional developers and five professional live-coding streamers working on 17 debugging tasks in their own codebases, capturing diverse contexts of debugging. We theorize debugging as a structured, iterative diagnostic process in which programmers update a mental model of the system to guide information gathering. Developers gather information by alternating between navigation and execution strategies, employing forward and backward tracing modes of reasoning and adapting these approaches according to codebase context, complexity, and familiarity. Developers also gather external resources to complement code-based evidence, with their experience enabling them to systematically construct a mental model. We contribute a grounded theory of professional debugging that surfaces the human-centered dimensions of the practice, with implications for tool design and software engineering education.

💡 Research Summary

This paper presents a grounded theory of professional debugging derived from in‑situ observations of experienced software engineers. The authors studied seven professional developers working on their own, familiar codebases and supplemented these data with five publicly available live‑coding streams, yielding a total of twelve participants and seventeen distinct debugging tasks across a wide range of domains (web, operating systems, databases, AI, finance, medicine). Using a constructivist grounded‑theory methodology, they performed open, focused, and theoretical coding on transcribed think‑aloud sessions and video recordings, iteratively refining categories until theoretical saturation was achieved.

The central contribution is a four‑stage iterative model: (1) Reproduction – confirming the bug’s manifestation; (2) Mental‑Model Development – continuously updating a dynamic mental representation of the system to guide information gathering; (3) Fix Development – crafting code changes based on the evolving model; and (4) Fix Validation – verifying that the fix resolves the issue. The authors argue that the bulk of debugging time is spent in stage 2, where developers employ a “knowledge‑avoidance” strategy: they extend their existing mental model only as far as needed to fix the bug, rather than striving for exhaustive system understanding. This contrasts with traditional pedagogical advice that encourages comprehensive reading of documentation and code before attempting a fix.

Two orthogonal strategy families were identified: navigation (static code comprehension) and execution (dynamic runtime analysis). Within each family, developers switch between forward tracing (following the current execution flow) and backward tracing (working from the observed failure back toward the cause). The study shows that professionals fluidly alternate between these modes, often nesting one strategy inside another (e.g., using a breakpoint to navigate to a function, then reading the function statically).

External, sociotechnical resources play a prominent role. Participants frequently consulted coworkers, examined version‑control history, and, in several cases, leveraged AI‑based code explanation tools to quickly grasp unfamiliar functions. This reliance on human and tool‑mediated knowledge sources is more pronounced than in prior survey‑based or laboratory studies, highlighting the collaborative nature of real‑world debugging.

Methodologically, the research balances depth and breadth: direct observation provides rich contextual data, while live‑stream analysis mitigates the limitation of pre‑selected tasks and helps achieve saturation. The authors acknowledge limitations, including a sample constrained by code‑sharing permissions, potential reactivity introduced by think‑aloud protocols, and the inability to capture emergent, high‑pressure debugging episodes.

Implications are threefold. For education, curricula should teach students to adopt knowledge‑avoidance pragmatically, emphasizing minimal‑sufficient model building and flexible switching between forward/backward tracing. For tool design, IDEs could surface contextual navigation‑execution links, suggest appropriate tracing modes, and integrate seamless access to sociotechnical resources (e.g., inline version‑control diffs, AI assistants). For research, the grounded theory offers a foundation for quantitative studies of debugging efficiency and for cross‑cultural examinations of debugging practices.

In sum, the paper reframes debugging not as a linear “find‑the‑bug‑then‑fix” activity but as an iterative, model‑centric diagnostic process where mental‑model evolution, strategic mode switching, and collaborative resource use are the keystones of professional practice.