Successful strategies for debugging concurrent software: an empirical investigation
R. E. Kurt Stirewalt, Scott Fleming · 2009
Concurrent software can provide substantial performance benefits; however, such software is highly complex. This complexity makes debugging concurrent software especially difficult. Debugging techniques that are highly effective for debugging sequential software are rendered ineffective by concurrency. Moreover, the literature provides little advice for programmers on what techniques are effective. To address this problem, we conducted in an empirical investigation to understand the strategies and practices that successful programmers use during debugging. Specifically, we carried out an exploratory study in which we observed fifteen programmers individually performing a debugging task on a multithreaded server application, which we seeded with a defect. To better understand the programmers' goals and intentions, we prompted them to think aloud as they worked. This study produced several promising theories. To test and refine one of these theories, we followed up the exploratory study with a controlled experiment. Three main claims emerged from our studies. First, programmers who are successful at debugging concurrent software use a previously-undocumented failure-trace modeling strategy, which involves modeling interactions among multiple threads to understand the potential behavior of a concurrent program. Second, the use of external representations, such as UML sequence diagrams, during failure-trace modeling enhances success with the strategy. Third, concurrency thwarts efforts to systematically manage hypotheses regarding the cause of the defect during debugging. In this dissertation, we also report ancillary findings regarding other behaviors that programmers exhibited and share important lessons learned in the conduct of think-aloud studies.