Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
10.1145/3586183.3606781acmconferencesArticle/Chapter ViewAbstractPublication PagesuistConference Proceedingsconference-collections
research-article
Open access

Hypothesizer: A Hypothesis-Based Debugger to Find and Test Debugging Hypotheses

Published: 29 October 2023 Publication History

Abstract

When software defects occur, developers begin the debugging process by formulating hypotheses to explain the cause. These hypotheses guide the investigation process, determining which evidence developers gather to accept or reject the hypothesis, such as parts of the code and program state developers examine. However, existing debugging techniques do not offer support in finding relevant hypotheses, leading to wasted time testing hypotheses and examining code that ultimately does not lead to a fix. To address this issue, we introduce a new type of debugging tool, the hypothesis-based debugger, and an implementation of this tool in Hypothesizer. Hypothesis-based debuggers support developers from the beginning of the debugging process by finding relevant hypotheses until the defect is fixed. To debug using Hypothesizer, developers first demonstrate the defect, generating a recording of the program behavior with code execution, user interface events, network communications, and user interface changes. Based on this information and the developer’s descriptions of the symptoms, Hypothesizer finds relevant hypotheses, analyzes the code to identify relevant evidence to test the hypothesis, and generates an investigation plan through a timeline view. This summarizes all evidence items related to the hypothesis, indicates whether the hypothesis is likely to be true by showing which evidence items were confirmed in the recording, and enables the developer to quickly check evidence in the recording by viewing code snippets for each evidence item. A randomized controlled experiment with 16 professional developers found that, compared to traditional debugging tools and techniques such as breakpoint debuggers and Stack Overflow, Hypothesizer dramatically improved the success rate of fixing defects by a factor of five and decreased the time to debug by a factor of three.

Supplemental Material

ZIP File
Supplemental File

References

[1]
Alaboudi. 2023. Replication package. https://archive.org/details/replication_Hypothesizer_UIST
[2]
Abdulaziz Alaboudi and Thomas D LaToza. 2020. Using hypotheses as a debugging aid. In Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, Dunedin, New Zealand, 1–9.
[3]
Abdulaziz Alaboudi and Thomas D. LaToza. 2021. Edit-Run Behavior in Programming and Debugging. In Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, Los Alamitos, CA, USA, 1–10.
[4]
Abdulaziz Alaboudi and Thomas D LaToza. 2023. What Constitutes Debugging? An Exploratory Study of Debugging Episodes". Empirical Software Engineering (EMSE) Forthcoming, Forthcoming (2023), To be published.
[5]
Maryam Arab, Thomas D. LaToza, Jenny Liang, and Amy J. Ko. 2022. An exploratory study of sharing strategic programming knowledge. In Conference on Human Factors in Computing Systems (CHI). ACM, New Orleans, LA, USA, 15 pages.
[6]
Maryam Arab, Jenny Liang, Yang Kyu Yoo, Amy J. Ko, and Thomas D. LaToza. 2021. HowToo: a platform for sharing, finding, and using programming strategies. In Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, St Louis, MO, USA, 1–9.
[7]
Muhammad Asaduzzaman, Ahmed Shah Mashiyat, Chanchal K. Roy, and Kevin A. Schneider. 2013. Answering questions about unanswered questions of Stack Overflow. In International Conference on Mining Software Repositories (MSR). ACM, Francisco, CA, USA, 97–100.
[8]
Marcel Böhme, Ezekiel O. Soremekun, Sudipta Chattopadhyay, Emamurho Ugherughe, and Andreas Zeller. 2017. Where is the bug and how is it fixed? an experiment with practitioners. In Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, Paderborn, Germany, 117–128.
[9]
Ruven Brooks. 1983. Towards a theory of the comprehension of computer programs. International Journal of Man-Machine Studies 18, 6 (1983), 543–554.
[10]
Brian Burg, Richard Bailey, Amy J Ko, and Michael D Ernst. 2013. Interactive record/replay for web application debugging. In Symposium on User Interface Software and Technology (UIST). ACM, St. Andrews, Scotland, United Kingdom, 473–484.
[11]
Chromedevtools. 2022. Chrome DevTools Protocol. https://chromedevtools.github.io/devtools-protocol/
[12]
Richard A. DeMillo, Hsin Pan, Eugene H. Spafford, Richard A. DeMillo, Hsin Pan, and Eugene H. Spafford. 1996. Critical slicing for software fault localization. In International Symposium on Software Testing and Analysis (ISSTA). ACM, San Diego, California, USA, 121–134.
[13]
L. Gugerty and G. Olson. 1986. Debugging by Skilled and Novice Programmers. In Conference on Human Factors in Computing Systems. ACM, Boston, Massachusetts, USA, 171–174.
[14]
Björn Hartmann, Daniel MacDougall, Joel Brandt, and Scott R Klemmer. 2010. What would other programmers do: suggesting solutions to error messages. In Conference on Human Factors in Computing Systems (CHI). ACM, Atlanta, GA, USA, 1019–1028.
[15]
Morten Hertzum and Annelise Mark Pejtersen. 2000. Information-seeking practices of engineers: Searching for documents as well as for people. Information Processing and Management 36, 5 (Sep 2000), 761–778.
[16]
Robin Jeffries. 1982. A comparison of the debugging behavior of expert and novice programmers. Proceedings of AERA annual meeting 10, 5 (1982), 1–7.
[17]
Brittany Johnson, Yoonki Song, Emerson Murphy-Hill, and Robert Bowdidge. 2013. Why don’t software developers use static analysis tools to find bugs?. In International Conference on Software Engineering (ICSE). ACM/IEEE, San Francisco, CA, USA, 672–681.
[18]
Amy J Ko. 2006. Debugging by asking questions about program output. In International Conference on Software Engineering (ICSE). ACM/IEEE, Shanghai, China, 989–992.
[19]
Amy J Ko, Robert DeLine, and Gina Venolia. 2007. Information needs in collocated software development teams. In International Conference on Software Engineering (ICSE). ACM/IEEE, Minneapolis, MN, USA, 344–353.
[20]
Amy J Ko and Brad A Myers. 2004. Designing the whyline: a debugging interface for asking questions about program behavior. In Conference on Human Factors in Computing Systems (CHI). ACM, Vienna, Austria, 151–158.
[21]
Amy J Ko and Brad A Myers. 2008. Debugging reinvented: asking and answering why and why not questions about program behavior. In International Conference on Software Engineering (ICSE). ACM/IEEE, Leipzig, Germany, 301–310.
[22]
Amy J Ko, Brad A Myers, Michael J Coblenz, and Htet Htet Aung. 2006. An exploratory study of how developers seek, relate, and collect relevant information during software maintenance tasks. IEEE Transactions on software engineering (TSE) 32, 12 (2006), 971–987.
[23]
Thomas D LaToza and Brad A Myers. 2011. Visualizing call graphs. In Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, Pittsburgh, USA, 117–124.
[24]
Thomas D. LaToza, Gina Venolia, and Robert DeLine. 2006. Maintaining Mental Models: A Study of Developer Work Habits. In International Conference on Software Engineering (ICSE). ACM/IEEE, Shanghai, China, 492–501.
[25]
Joseph Lawrance, Christopher Bogart, Margaret Burnett, Rachel Bellamy, Kyle Rector, and Scott D. Fleming. 2013. How programmers debug, revisited: An information foraging theory perspective. IEEE Transactions on Software Engineering (TSE) 39, 2 (2013), 197–215.
[26]
L. Layman, M. Diep, M. Nagappan, J. Singer, R. Deline, and G. Venolia. 2013. Debugging Revisited: Toward Understanding the Debugging Needs of Contemporary Software Developers. In International Symposium on Empirical Software Engineering and Measurement (ESEM). ACM/IEEE, Baltimore, Maryland, USA, 383–392.
[27]
Stanley Letovsky. 1987. Cognitive processes in program comprehension. Journal of Systems and Software (JSS) 7, 4 (1987), 325–339.
[28]
Bil Lewis. 2003. Debugging backwards in time. arXiv preprint cs/0310016.
[29]
David C. Littman, Jeannine Pinto, Stanley Letovsky, and Elliot Soloway. 1987. Mental models and software maintenance. Journal of Systems and Software (JSS) 7, 4 (1987), 341–355.
[30]
Lena Mamykina, Bella Manoim, Manas Mittal, George Hripcsak, and Björn Hartmann. 2011. Design Lessons from the Fastest Q&A Site in the West. In Conference on Human Factors in Computing Systems (CHI). ACM, Vancouver, BC, Canada, 2857–2866.
[31]
OpenAI. 2023. OpenAI API. https://openai.com/ Accessed: March 2023.
[32]
Chris Parnin and Alessandro Orso. 2011. Are automated debugging techniques actually helping programmers?. In International Symposium on Software Testing and Analysis (ISSTA). ACM, Toronto, Ontario, Canada, 199–209.
[33]
Michael Perscheid, Benjamin Siegmund, Marcel Taeumel, and Robert Hirschfeld. 2017. Studying the advancement in debugging practice of professional software developers. Software Quality Journal 25, 1 (2017), 83–110.
[34]
Replay. 2022. replay. https://www.replay.io/
[35]
Semgrep. 2023. Semgrep: A Code Analysis Tool. https://semgrep.dev/ Accessed: March 2023.
[36]
Stackoverflow. 2022. reactBugs. https://stackoverflow.com/search?q=clicking+a+button+does+not+work+%5Breact%5D Accessed: 2023-03-06.
[37]
Christoph Treude, Ohad Barzilay, and Margaret-Anne Storey. 2011. How do programmers ask and answer questions on the web?. In International Conference on Software Engineering (ICSE). ACM/IEEE, Waikiki, Honolulu, HI, USA, 804–807.
[38]
Bogdan Vasilescu, Alexander Serebrenik, Prem Devanbu, and Vladimir Filkov. 2014. How social Q&A sites are changing knowledge sharing in open source software communities. In Conference on Computer Supported Cooperative Work (CSCW). ACM, Baltimore, Maryland, USA, 342–354.
[39]
A. Von Mayrhauser and A.M. Vans. 1996. On the role of hypotheses during opportunistic understanding while porting large scale code. In International Workshop on Program Comprehension (ICPC). IEEE, Berlin, Germany, 68–77.
[40]
Mark Weiser. 1984. Program slicing. In International Conference on Software Engineering (ICSE). ACM/IEEE, Washington, D.C., USA, 439–449.
[41]
W Eric Wong, Ruizhi Gao, Yihao Li, Rui Abreu, and Franz Wotawa. 2016. A survey on software fault localization. IEEE Transactions on Software Engineering (TSE) 42, 8 (2016), 707–740.
[42]
X. Xia, L. Bao, D. Lo, and S. Li. 2016. “Automated Debugging Considered Harmful” Considered Harmful: A User Study Revisiting the Usefulness of Spectra-Based Fault Localization Techniques with Professionals Using Real Bugs from Large Systems. In International Conference on Software Maintenance and Evolution (ICSME. IEEE, Raleigh, North Carolina, USA., 267–278.
[43]
Xiangyu Zhang, R. Gupta, and Youtao Zhang. 2003. Precise dynamic slicing algorithms. In International Conference on Software Engineering (ICSE). ACM/IEEE, Portland, Oregon, USA, 319–329.
[44]
Jie Yang, Claudia Hauff, Alessandro Bozzon, and Geert-Jan Houben. 2014. Asking the Right Question in Collaborative Q&a Systems. In Proceedings of the 25th ACM Conference on Hypertext and Social Media. ACM, Santiago, Chile, 179–189.
[45]
Andreas. Zeller. 2005. Why Programs Fail: A Guide to Systematic Debugging. Morgan Kaufmann, Burlington, MA, USA. 480 pages.
[46]
Xiangyu Zhang, Neelam Gupta, and Rajiv Gupta. 2006. Pruning dynamic slices with confidence. In Conference on Programming Language Design and Implementation (PLDI). ACM, Ottawa, Ontario, Canada, 169–180.

Cited By

View all
  • (2024)VIME: Visual Interactive Model Explorer for Identifying Capabilities and Limitations of Machine Learning Models for Sequential Decision-MakingProceedings of the 37th Annual ACM Symposium on User Interface Software and Technology10.1145/3654777.3676323(1-21)Online publication date: 13-Oct-2024
  • (2024)UNFOLD: Enabling Live Programming for Debugging GUI Applications2024 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)10.1109/VL/HCC60511.2024.00041(306-316)Online publication date: 2-Sep-2024

Recommendations

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences
UIST '23: Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology
October 2023
1825 pages
ISBN:9798400701320
DOI:10.1145/3586183
This work is licensed under a Creative Commons Attribution International 4.0 License.

Sponsors

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 29 October 2023

Check for updates

Author Tags

  1. debugging
  2. debugging hypotheses
  3. debugging tools

Qualifiers

  • Research-article
  • Research
  • Refereed limited

Conference

UIST '23

Acceptance Rates

Overall Acceptance Rate 561 of 2,567 submissions, 22%

Upcoming Conference

UIST '25
The 38th Annual ACM Symposium on User Interface Software and Technology
September 28 - October 1, 2025
Busan , Republic of Korea

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • Downloads (Last 12 months)600
  • Downloads (Last 6 weeks)70
Reflects downloads up to 23 Dec 2024

Other Metrics

Citations

Cited By

View all
  • (2024)VIME: Visual Interactive Model Explorer for Identifying Capabilities and Limitations of Machine Learning Models for Sequential Decision-MakingProceedings of the 37th Annual ACM Symposium on User Interface Software and Technology10.1145/3654777.3676323(1-21)Online publication date: 13-Oct-2024
  • (2024)UNFOLD: Enabling Live Programming for Debugging GUI Applications2024 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)10.1109/VL/HCC60511.2024.00041(306-316)Online publication date: 2-Sep-2024

View Options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

HTML Format

View this article in HTML Format.

HTML Format

Login options

Media

Figures

Other

Tables

Share

Share

Share this Publication link

Share on social media