pith. sign in

arxiv: 2604.09301 · v1 · submitted 2026-04-10 · 💻 cs.PL · cs.HC

Tracers for debugging and program exploration

Shardul Chiplunkar , Cl\'ement Pit-Claudel This is my paper

Pith reviewed 2026-05-10 17:08 UTC · model grok-4.3

classification 💻 cs.PL cs.HC
keywords debuggingexecution tracesprogram explorationhypothesis generationruntime analysissoftware tools
0
0 comments X p. Extension

The pith

Debuggers should present every executed line in runtime order rather than source order.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Programmers debug by forming guesses about code behavior and testing them against reality. Traditional step debuggers show only isolated snapshots of state at single points, leaving users to mentally assemble how the state evolved over time. The paper proposes centering tools on a complete trace that records and displays every line in the exact sequence it executed. This ordering makes patterns such as repeated calls, event sequences, and timing relationships visible without extra effort. The authors outline design decisions for building such tracers and note the challenges of presenting large histories effectively.

Core claim

The paper claims that a debugging interface built around the full execution trace lets programmers view code lines in the order they actually ran, which directly supports generating and checking hypotheses about program behavior more naturally than snapshot-based step debuggers.

What carries the argument

The execution trace, the complete chronological record of every statement executed during a run, which reorders display and navigation according to runtime sequence instead of source syntax.

If this is right

  • Users can count statement executions and observe call sequences directly by scanning the trace.
  • Hypothesis generation becomes integrated with the act of inspecting the history rather than requiring separate mental reconstruction.
  • Design choices around trace filtering and navigation become central to keeping the view usable.
  • Preliminary results suggest the approach surfaces behaviors that snapshots hide.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Traces could support automated queries that highlight unusual execution patterns without manual scanning.
  • The same chronological view might clarify interleavings in concurrent or event-driven code more readily than current tools.
  • Extending tracers to allow replay or branching from specific points in the history could turn passive viewing into active exploration.

Load-bearing premise

That showing the entire execution history in time order will help programmers form useful hypotheses without overwhelming them with too much detail.

What would settle it

A study in which programmers attempt to understand and debug unfamiliar code using either a trace viewer or a conventional step debugger, then compare success rates and time spent on hypothesis generation.

Figures

Figures reproduced from arXiv: 2604.09301 by Cl\'ement Pit-Claudel, Shardul Chiplunkar.

Figure 1
Figure 1. Figure 1: Mockup of our proposed tracer. On the left is the primary trace interface, and on the right, the [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: On the left is a program stopped at return sum(things) (in blue) inside a stepper. The stack trace, consisting of compute, do_it, and main, is highlighted in red; but as main is in a different file, the stepper would not display its source code at the same time as that of the other two functions. On the right is the same program in a tracer. (It is not stopped anywhere; it has run to completion. If it had … view at source ↗
read the original abstract

Programmers often use an iterative process of hypothesis generation ("perhaps this function is called twice?") and hypothesis testing ("let's count how many times this breakpoint fires") to understand the behavior of unfamiliar or malfunctioning software. Existing debugging tools are much better suited to testing hypotheses than to generating them. Step debuggers, for example, present isolated snapshots of the program's state, leaving it to the programmer to mentally reconstruct the evolution of that state over time. We advocate for a different approach: building a debugging and program-exploration tool around a *trace*, or complete history, of the program's execution. Our key claim is that the user should see every line *as executed* (in time order) rather than *as written* (in syntax order). We discuss design choices, preliminary results, and interesting challenges.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The paper advocates building debugging and program-exploration tools around complete execution traces rather than traditional snapshot-based step debuggers. Its central claim is that users should view every executed line in time (execution) order instead of syntax (source) order, because this better supports the iterative hypothesis-generation and hypothesis-testing process that programmers use when understanding unfamiliar or faulty code.

Significance. If the proposed trace-based approach can be shown to deliver net insight without cognitive overload, it would offer a substantive alternative paradigm for debugging interfaces. The manuscript earns credit for explicitly identifying interesting implementation challenges and for framing the design around a concrete user activity (hypothesis generation). However, because the superiority claim rests on an untested user-benefit step, the work remains at the level of a design proposal rather than a validated result.

major comments (2)
  1. [Abstract] Abstract: the key claim that 'the user should see every line as executed (in time order) rather than as written (in syntax order)' is presented as the paper's central contribution, yet the manuscript supplies no quantitative comparison (hypothesis accuracy, time-to-insight, error rates) or even a detailed description of the 'preliminary results' that would allow evaluation of whether complete traces outperform mental reconstruction from isolated snapshots.
  2. [Abstract] The weakest assumption identified in the skeptic note (that displaying the full trace will facilitate hypothesis generation without overwhelming the user) is load-bearing for the advocacy; the manuscript does not provide evidence or a concrete mitigation strategy for this assumption.
minor comments (2)
  1. The abstract mentions 'design choices' and 'interesting challenges' but does not indicate where in the manuscript these are elaborated or what concrete examples are used.
  2. Consider adding a short related-work paragraph contrasting the proposed tracer with existing dynamic-analysis and program-visualization tools.

Simulated Author's Rebuttal

2 responses · 0 unresolved

Thank you for the constructive review. We agree that the manuscript is primarily a design proposal rather than a validated empirical result, and that the central claim would benefit from clearer scoping and more detail on preliminary observations. We respond point by point to the major comments and indicate planned revisions.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the key claim that 'the user should see every line as executed (in time order) rather than as written (in syntax order)' is presented as the paper's central contribution, yet the manuscript supplies no quantitative comparison (hypothesis accuracy, time-to-insight, error rates) or even a detailed description of the 'preliminary results' that would allow evaluation of whether complete traces outperform mental reconstruction from isolated snapshots.

    Authors: We accept the observation that the abstract presents the claim without supporting data. The paper is framed as advocacy for a trace-based paradigm and identification of associated design challenges, not as a controlled user study. The preliminary results consist of informal observations from our prototype implementation, in which time-ordered traces surfaced repeated or unexpected call patterns that were difficult to reconstruct mentally from step-debugger snapshots. In revision we will add a dedicated section with concrete examples of these observations and the specific debugging tasks they supported. We will not introduce quantitative metrics, as that would require a separate human-subjects experiment outside the current scope. revision: partial

  2. Referee: [Abstract] The weakest assumption identified in the skeptic note (that displaying the full trace will facilitate hypothesis generation without overwhelming the user) is load-bearing for the advocacy; the manuscript does not provide evidence or a concrete mitigation strategy for this assumption.

    Authors: We agree that the assumption is load-bearing and that the abstract does not address mitigation. The body of the manuscript already outlines concrete strategies, including hierarchical summarization of repeated executions, user-controlled filtering by time ranges or variable values, and interactive navigation that collapses sub-traces. We will revise the abstract to reference these approaches explicitly and to note that managing information overload remains an open implementation challenge we identify for future work. revision: yes

Circularity Check

0 steps flagged

No circularity: conceptual design paper with no derivations or self-referential reductions

full rationale

The paper advocates a trace-based debugging approach and asserts that execution-order presentation aids hypothesis generation better than snapshot debuggers. It contains no equations, fitted parameters, mathematical derivations, or load-bearing self-citations. The key claim is a qualitative design recommendation supported by discussion of choices and preliminary results; it does not reduce any prediction or uniqueness result to its own inputs by construction. As a high-level conceptual work without quantitative models or chains of inference that could be tautological, the argument is self-contained against external benchmarks and exhibits no circularity patterns.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

No free parameters, axioms, or invented entities are introduced as the paper is a high-level discussion of tool design without formal mathematical content.

pith-pipeline@v0.9.0 · 5431 in / 1030 out tokens · 66657 ms · 2026-05-10T17:08:55.218418+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

52 extracted references · 52 canonical work pages

  1. [1]

    2023.Immediate Tracing

    Valentin Aebi. 2023.Immediate Tracing. Semester Project. EPFL, Lausanne, Switzerland. https://infoscience.epfl.ch/handle/ 20.500.14299/198892 Abdulaziz Alaboudi and Thomas D. LaToza

    work page 2023

  2. [2]

    InProceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (UIST 2023)

    Hypothesizer: A Hypothesis-Based Debugger to Find and Test Debugging Hypotheses. InProceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (UIST 2023). ACM, New York, NY, USA, 1–14. doi:10.1145/3586183.3606781 Saba Alimadadi, Ali Mesbah, and Karthik Pattabiraman

    work page doi:10.1145/3586183.3606781 2023

  3. [3]

    In Proceedings of the 40th International Conference on Software Engineering (ICSE 2018)

    Inferring Hierarchical Motifs from Execution Traces. In Proceedings of the 40th International Conference on Software Engineering (ICSE 2018). Association for Computing Machinery, New York, NY, USA, 776–787. doi:10.1145/3180155.3180216 Dmitrii Artiukhov, Bob Brockbernd, Evgeniia Fedotova, Nikita Koval, Ivan Kylchik, Evgenii Moiseenko, Lev Serebryakov, Evge...

    work page doi:10.1145/3180155.3180216 2018

  4. [4]

    Journal of Object Technology25, 1 (2026), A9:1–5

    Trace Debugger: Interactive Execution Trace Debugging for Java and Kotlin. Journal of Object Technology25, 1 (2026), A9:1–5. doi:10.5381/jot.2026.25.1.a9 Robert M. Balzer. 1969.ExDAMS: Extendable Debugging and Monitoring System. Memorandum RM-5772-ARPA. The Rand Corporation, Santa Monica, CA, USA. 42 pages. https://www.rand.org/pubs/research_memoranda/RM5...

    work page doi:10.5381/jot.2026.25.1.a9 2026

  5. [5]

    Proceedings of the ACM on Human-Computer Interaction8, EICS (June 2024), 1–26

    Inline Visualization and Manipulation of Real-Time Hardware Log for Supporting Debugging of Embedded Programs. Proceedings of the ACM on Human-Computer Interaction8, EICS (June 2024), 1–26. doi:10.1145/3660250 Holger Cleve and Andreas Zeller

    work page doi:10.1145/3660250 2024

  6. [6]

    InProceedings of the 27th International Conference on Software Engineering (ICSE 2005)

    Locating Causes of Program Failures. InProceedings of the 27th International Conference on Software Engineering (ICSE 2005). ACM Press, New York, NY, USA, 342–351. doi:10.1145/1062455.1062522 Mariano P. Consens, Masum Z. Hasan, and Alberto O. Mendelzon

    work page doi:10.1145/1062455.1062522 2005

  7. [7]

    819), Litwin Witold and Tore Risch (Eds.)

    (Lecture Notes in Computer Science, Vol. 819), Litwin Witold and Tore Risch (Eds.). Springer-Verlag, Berlin, Heidelberg. doi:10.1007/3-540-58183-9_45 Bas Cornelissen, Andy Zaidman, and Arie van Deursen

    work page doi:10.1007/3-540-58183-9_45

  8. [8]

    doi:10.1109/TSE.2010.47 Marc Eisenstadt and Mike Brayshaw

    A Controlled Experiment for Program Comprehension through Trace Visualization.IEEE Transactions on Software Engineering37, 3 (May 2011), 341–355. doi:10.1109/TSE.2010.47 Marc Eisenstadt and Mike Brayshaw

    work page doi:10.1109/tse.2010.47 2011

  9. [9]

    1988), 277–342

    The Transparent PROLOG Machine (TPM): An Execution Model and Graphical Debugger for Logic Programming.The Journal of Logic Programming5, 4 (Dec. 1988), 277–342. doi:10.1016/0743- 1066(88)90001-5 Jakob Engblom

    work page doi:10.1016/0743- 1988

  10. [10]

    InProceedings of the 2012 System, Software, SoC and Silicon Debug Conference

    A Review of Reverse Debugging. InProceedings of the 2012 System, Software, SoC and Silicon Debug Conference. IEEE, 1–6. https://ieeexplore.ieee.org/document/6338149 Jim Etheredge

    work page arXiv 2012

  11. [11]

    InProceedings of the 35th ACM Technical Symposium on Computer Science Education (SIGCSE 2004)

    CMeRun: Program Logic Debugging Courseware for CS1/CS2 Students. InProceedings of the 35th ACM Technical Symposium on Computer Science Education (SIGCSE 2004). Association for Computing Machinery, New York, NY, USA, 22–25. doi:10.1145/971300.971311 Simon F. Goldsmith, Robert O’Callahan, and Alex Aiken

    work page doi:10.1145/971300.971311 2004

  12. [12]

    InProceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2005)

    Relational Queries over Program Traces. InProceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2005). ACM, New York, NY, USA, 385–402. doi:10.1145/1094811.1094841 Philip J. Guo

    work page doi:10.1145/1094811.1094841 2005

  13. [13]

    InProceedings of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE 2013)

    Online Python Tutor: Embeddable Web-Based Program Visualization for CS Education. InProceedings of the 44th ACM Technical Symposium on Computer Science Education (SIGCSE 2013). Association for Computing Machinery, New York, NY, USA, 579–584. doi:10.1145/2445196.2445368 Philip J. Guo

    work page doi:10.1145/2445196.2445368 2013

  14. [14]

    InThe 34th Annual ACM Symposium on User Interface Software and Technology (UIST 2021)

    Ten Million Users and Ten Years Later: Python Tutor’s Design Guidelines for Building Scalable and Sustainable Research Software in Academia. InThe 34th Annual ACM Symposium on User Interface Software and Technology (UIST 2021). Association for Computing Machinery, New York, NY, USA, 1235–1251. doi:10.1145/3472749.3474819 Alex Hall

    work page doi:10.1145/3472749.3474819 2021

  15. [15]

    doi:10.1002/1099-1689(200009)10:3<171::AID-STVR209>3.0.CO;2-J Matthew Heinsen Egan

    An Empirical Investigation of the Relationship between Spectra Differences and Regression Faults.Software Testing, Verification and Reliability10, 3 (2000), 171–194. doi:10.1002/1099-1689(200009)10:3<171::AID-STVR209>3.0.CO;2-J Matthew Heinsen Egan. 2015.Advanced Debugging and Program Visualization for Novice C Programmers. Ph. D. Dissertation. University...

    work page doi:10.1002/1099-1689(200009)10:3 2000

  16. [16]

    InNODe/GSEM 2006 (Lecture Notes in Informatics, Vol

    Design and Implementation of a Backward-in-Time Debugger. InNODe/GSEM 2006 (Lecture Notes in Informatics, Vol. P-88). Gesellschaft für Informatik e.V., 17–32. https: PLATEAU Workshop on Programming Languages and Human-Computer Interaction. Publication date: April

    work page 2006

  17. [17]

    InProceedings of the 18th ACM SIGSOFT International Symposium on Foundations of Software Engineering (SIGSOFT/FSE 2010)

    LEAP: Lightweight Deterministic Multi-Processor Replay of Concurrent Java Programs. InProceedings of the 18th ACM SIGSOFT International Symposium on Foundations of Software Engineering (SIGSOFT/FSE 2010). ACM, Santa Fe, NM, USA, 207–216. doi:10.1145/1882291.1882323 INRIA

    work page doi:10.1145/1882291.1882323 2010

  18. [18]

    Retrieved 2025-12-18 from https://ocaml.org/manual/5.4/toplevel

    The Toplevel System or REPL (OCaml). Retrieved 2025-12-18 from https://ocaml.org/manual/5.4/toplevel. html#s%3Atoplevel-directives Peiling Jiang, Fuling Sun, and Haijun Xia

    work page 2025

  19. [19]

    Ge, Yuan Cui, and Matthew Kay

    Log-It: Supporting Programming with Interactive, Contextual, Structured, and Visual Logs. InProceedings of the 2023 CHI Conference on Human Factors in Computing Systems (CHI 2023). ACM, New York, NY, USA, 1–16. doi:10.1145/3544548.3581403 Bastien Jolidon and Kelvin Kappeler. 2025.A Student-Ready Implementation of Trace-Based Debugging for Java. Semester P...

    work page doi:10.1145/3544548.3581403 2023

  20. [20]

    Jones and Mary Jean Harrold

    Empirical Evaluation of the Tarantula Automatic Fault-Localization Technique. InProceedings of the 20th IEEE/ACM International Conference on Automated Software Engineering (ASE 2005). ACM, New York, NY, USA, 273–282. doi:10.1145/1101908.1101949 Hyeonsu Kang and Philip J. Guo

    work page doi:10.1145/1101908.1101949 2005

  21. [21]

    InProceedings of the 30th Annual ACM Symposium on User Interface Software and Technology (UIST 2017)

    Omnicode: A Novice-Oriented Live Programming Environment with Always-on Run- Time Value Visualizations. InProceedings of the 30th Annual ACM Symposium on User Interface Software and Technology (UIST 2017). Association for Computing Machinery, New York, NY, USA, 737–745. doi:10.1145/3126594.3126632 Kelvin Kappeler. 2026.PrintWizard: Next-Level Trace-Based ...

    work page doi:10.1145/3126594.3126632 2017

  22. [22]

    InProceedings of the 3rd Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA 1988)

    GraphTrace—Understanding Object-Oriented Systems Using Concurrently Animated Views. InProceedings of the 3rd Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA 1988). Association for Computing Machinery, New York, NY, USA, 191–205. doi:10.1145/62083.62101 Thomas Kluyver, Benjamin Ragan-Kelley, Fernando Pérez, Brian Gran...

    work page doi:10.1145/62083.62101 1988

  23. [23]

    InProceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI 2004)

    Designing the Whyline: A Debugging Interface for Asking Questions about Program Behavior. InProceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI 2004). Association for Computing Machinery, New York, NY, USA, 151–158. doi:10.1145/985692.985712 Amy J. Ko and Brad A. Myers

    work page doi:10.1145/985692.985712 2004

  24. [24]

    InProceedings of the 13th International Conference on Software Engineering (ICSE 2008)

    Debugging Reinvented: Asking and Answering Why and Why Not Questions about Program Behavior. InProceedings of the 13th International Conference on Software Engineering (ICSE 2008). ACM, New York, NY, USA, 301–310. doi:10.1145/1368088.1368130 Minhyuk Ko, Omer Ahmed, Yoseph Berhanu Alebachew, and Chris Brown

    work page doi:10.1145/1368088.1368130 2008

  25. [25]

    In2025 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)

    AutoPrint: Judging the Effectiveness of an Automatic Print Statement Debugging Tool. In2025 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, 379–384. doi:10.1109/VL-HCC65237.2025.00049 Jonathan Lampérth. 2024.Record and Replay Debugging at Scale: Towards Always-on Java Application Recording in the Cloud. Master’s thesis. ETH ...

    work page doi:10.1109/vl-hcc65237.2025.00049 2025

  26. [26]

    doi:10.1145/324422.324385 Sorin Lerner

    Saving Traces for Ada Debugging.SIGAda Ada LettersV, 2 (May 1985), 97–108. doi:10.1145/324422.324385 Sorin Lerner

    work page doi:10.1145/324422.324385 1985

  27. [27]

    InProceedings of the 2020 CHI Conference on Human Factors in Computing Systems (CHI 2020)

    Projection Boxes: On-the-Fly Reconfigurable Visualization for Live Programming. InProceedings of the 2020 CHI Conference on Human Factors in Computing Systems (CHI 2020). Association for Computing Machinery, New York, NY, USA, 1–7. doi:10.1145/3313831.3376494 Bil Lewis

    work page doi:10.1145/3313831.3376494 2020

  28. [28]

    InProceedings of the Fifth International Workshop on Automated and Algorithmic Debugging (AADEBUG 2003)

    Debugging Backwards in Time. InProceedings of the Fifth International Workshop on Automated and Algorithmic Debugging (AADEBUG 2003). arXiv, Ghent, Belgium, 225–235. doi:10.48550/arXiv.cs/0310016 arXiv:cs/0310016 Tom Lieber

    work page doi:10.48550/arxiv.cs/0310016 2003

  29. [29]

    InProceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI 2014)

    Addressing Misconceptions about Code with Always-on Programming Visualizations. InProceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI 2014). ACM, New York, NY, USA, 2481–2490. doi:10.1145/2556288.2557409 Henry Lieberman

    work page doi:10.1145/2556288.2557409 2014

  30. [30]

    InProceedings of the 1984 ACM Symposium on LISP and Functional Programming (LFP 1984)

    Steps toward Better Debugging Tools for LISP. InProceedings of the 1984 ACM Symposium on LISP and Functional Programming (LFP 1984). ACM, Austin, TX, USA, 247–255. doi:10.1145/800055.802041 LispWorks Ltd

    work page doi:10.1145/800055.802041 1984

  31. [31]

    Retrieved 2025-12-18 from http://clhs.lisp.se/Body/m_tracec.htm Michael Martin, Benjamin Livshits, and Monica S

    Macro TRACE, UNTRACE. Retrieved 2025-12-18 from http://clhs.lisp.se/Body/m_tracec.htm Michael Martin, Benjamin Livshits, and Monica S. Lam

    work page 2025

  32. [32]

    InProceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2005)

    Finding Application Errors and Security Flaws Using PQL: A Program Query Language. InProceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2005). ACM, San Diego, CA, USA, 365–383. doi:10.1145/1094811.1094840 Toshinori Matsumura, Takashi Ishio, Yu Kashima, and Katsuro Inoue

    work page doi:10.1145/1094811.1094840 2005

  33. [33]

    Association for Computing Machinery, New York, NY, USA, 253–257

    12 Shardul Chiplunkar and Clément Pit-Claudel Program Comprehension (ICPC 2014). Association for Computing Machinery, New York, NY, USA, 253–257. doi:10.1145/ 2597008.2597803 Microsoft Corp

    work page arXiv 2014

  34. [34]

    2017.Engineering Record and Replay for Deployability: Extended Technical Report

    doi:10.1145/1352135.1352193 Robert O’Callahan, Chris Jones, Nathan Froyd, Kyle Huey, Albert Noll, and Nimrod Partush. 2017.Engineering Record and Replay for Deployability: Extended Technical Report. Technical Report. doi:10.48550/arXiv.1705.05937 arXiv:1705.05937 [cs] Pernosco

    work page doi:10.1145/1352135.1352193 2017

  35. [35]

    doi:10.1145/3426425.3426940 Jan Paul Posma and Steve Krouse

    ACM, Virtual USA, 155–174. doi:10.1145/3426425.3426940 Jan Paul Posma and Steve Krouse. 2014.𝜆Lessons. https://stevekrouse.com/hs.js/ Guillaume Pothier and Éric Tanter

    work page doi:10.1145/3426425.3426940 2014

  36. [36]

    2009), 78–85

    Back to the Future: Omniscient Debugging.IEEE Software26, 6 (Nov. 2009), 78–85. doi:10.1109/MS.2009.169 Ram Rachum, Alex Hall, Iori Yanokura, and PySnooper contributors

    work page doi:10.1109/ms.2009.169 2009

  37. [37]

    PyCon Israel

    PySnooper: Never Use print for Debugging Again. PyCon Israel. doi:10.5281/zenodo.10462459 Record Replay Inc

    work page doi:10.5281/zenodo.10462459

  38. [38]

    The Use of Program Profiling for Software Maintenance with Applications to the Year 2000 Problem. InProceedings of the 6th European Software Engineering Conference, Held Jointly with the 5th ACM SIGSOFT International Symposium on Foundations of Software Engineering (ESEC 1997/FSE-5). Springer-Verlag, Berlin, Heidelberg, 432–449. doi:10.1145/267895.267925 ...

    work page doi:10.1145/267895.267925 2000

  39. [39]

    https://prg.is.titech.ac.jp/papers/pdf/ipsj-trans- pro-2010.pdf David Schwartz, Ankith Kowshik, and Luís Pina

    Traceglasses: a trace-based debugger for realizing efficient navigation.IPSJ Transactions on Programming3, 3 (June 2010), 1–17. https://prg.is.titech.ac.jp/papers/pdf/ipsj-trans- pro-2010.pdf David Schwartz, Ankith Kowshik, and Luís Pina

    work page 2010

  40. [40]

    2024), 1641–1669

    Jmvx: Fast Multi-Threaded Multi-Version Execution and Record- Replay for Managed Languages.Proceedings of the ACM on Programming Languages8, OOPSLA2 (Oct. 2024), 1641–1669. doi:10.1145/3689769 Erwan Serandour. 2024.Immediate Tracing for Smoother Debugging and Code Exploration. Master’s thesis. EPFL, Lausanne, Switzerland. Matthew Sotoudeh

    work page doi:10.1145/3689769 2024

  41. [41]

    InProceedings of the 2025 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software

    Literate Tracing. InProceedings of the 2025 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software. Association for Computing Machinery, New York, NY, USA, 143–160. doi:10.1145/3759429.3762626 Ryo Suzuki, Gustavo Soares, Andrew Head, Elena Glassman, Ruan Reis, Melina Mongiovi, Loris D’Antoni, and Björn...

    work page doi:10.1145/3759429.3762626 2025

  42. [42]

    Stolee, and Brittany Johnson

    TraceDiff: Debugging Unexpected Code Behavior Using Trace Divergences. In2017 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, 107–115. doi:10.1109/VLHCC.2017.8103457 SWI Prolog

    work page doi:10.1109/vlhcc.2017.8103457 2017

  43. [43]

    Retrieved 2026-03-27 from https://www.swi-prolog.org/pldoc/man? section=debugger Carst Tankink, Herman Geuvers, James McKinna, and Freek Wiedijk

    Debugging and Tracing Programs. Retrieved 2026-03-27 from https://www.swi-prolog.org/pldoc/man? section=debugger Carst Tankink, Herman Geuvers, James McKinna, and Freek Wiedijk

    work page 2026

  44. [44]

    (Lecture Notes in Computer Science, 6167), Serge Autexier, Jacques Calmet, David Delahaye, Patrick D. F. Ion, Laurence Rideau, Renaud Rioboo, and Alan P. Sexton (Eds.). Springer, Berlin, Heidelberg, 440–454. doi:10.1007/978-3-642-14128-7_37 Minoru Terada

    work page doi:10.1007/978-3-642-14128-7_37

  45. [45]

    InProceedings of the 10th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE 2005)

    ETV: A Program Trace Player for Students. InProceedings of the 10th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE 2005). Association for Computing Machinery, New York, NY, USA, 118–122. doi:10.1145/1067445.1067480 Undo Ltd

    work page doi:10.1145/1067445.1067480 2005

  46. [46]

    InProceedings of the 13th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE ’08)

    SRec: An Animation System of Recursion for Algorithm Courses. InProceedings of the 13th Annual SIGCSE Conference on Innovation and Technology in Computer Science Education (ITiCSE ’08). Association for Computing Machinery, New York, NY, USA, 225–229. doi:10.1145/1384271.1384332 Bret Victor

    work page doi:10.1145/1384271.1384332

  47. [47]

    Retrieved 2026-04-07 from https://worrydream.com/LearnableProgramming/ Ruochen Wang and Thomas D

    Learnable Programming. Retrieved 2026-04-07 from https://worrydream.com/LearnableProgramming/ Ruochen Wang and Thomas D. LaToza

    work page 2026

  48. [48]

    In2025 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)

    How Omniscient Debuggers Impact Debugging Behavior. In2025 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, 57–67. doi:10.1109/VL-HCC65237.2025. 00016 PLATEAU Workshop on Programming Languages and Human-Computer Interaction. Publication date: April

    work page doi:10.1109/vl-hcc65237.2025 2025

  49. [49]

    InInternational Conference on Program Comprehension (ICPC)

    JavaWiz: A Trace-Based Graphical Debugger for Software Development Education. In2025 IEEE/ACM 33rd International Conference on Program Comprehension (ICPC). IEEE, Ottawa, ON, Canada, 1–12. doi:10.1109/ICPC66645.2025.00023 W. Eric Wong, Vidroha Debroy, Ruizhi Gao, and Yihao Li

    work page doi:10.1109/icpc66645.2025.00023 2025

  50. [50]

    The dstar method for effective software fault localization,

    The DStar Method for Effective Software Fault Localization. IEEE Transactions on Reliability63, 1 (March 2014), 290–308. doi:10.1109/TR.2013.2285319 Andreas Zeller. 2009.Why Programs Fail: A Guide to Systematic Debugging(2nd ed.). Morgan Kaufmann Publishers Inc., San Francisco, CA, USA. Valerie Zhao, Lefan Zhang, Bo Wang, Michael L. Littman, Shan Lu, and Blase Ur

    work page doi:10.1109/tr.2013.2285319 2014

  51. [51]

    InProceedings of the 2021 CHI Conference on Human Factors in Computing Systems (CHI 2021)

    Understanding Trigger-Action Programs through Novel Visualizations of Program Differences. InProceedings of the 2021 CHI Conference on Human Factors in Computing Systems (CHI 2021). Association for Computing Machinery, New York, NY, USA, 1–17. doi:10.1145/ 3411764.3445567 Renyi Zhong, Yichen Li, Jinxi Kuang, Wenwei Gu, Yintong Huo, and Michael R. Lyu

    work page arXiv 2021

  52. [52]

    2025), 16:1–16:31

    LogUpdater: Automated Detection and Repair of Specific Defects in Logging Statements.ACM Transactions on Software Engineering and Methodology35, 1 (Dec. 2025), 16:1–16:31. doi:10.1145/3731754 PLATEAU Workshop on Programming Languages and Human-Computer Interaction. Publication date: April 2026

    work page doi:10.1145/3731754 2025