research-article

Open access

Object-Centric Time-Travel Debugging: Exploring Traces of Objects

Authors:

Christoph Thiede,

Marcel Taeumel,

Robert HirschfeldAuthors Info & Claims

Programming '23: Companion Proceedings of the 7th International Conference on the Art, Science, and Engineering of Programming

Pages 54 - 60

https://doi.org/10.1145/3594671.3594678

Published: 12 September 2023 Publication History

All formats PDF

Abstract

Traditional behavior-centric debuggers are organized around an extensive call stack, making it hard for programmers to navigate and explore large programs. We present object traces, a novel, object-centric approach to time-travel debugging that enables programmers to directly interact with recorded states of objects and explore their evolution in a simplified call tree. Our approach allows programmers to send messages to the object trace to ask questions of different granularity, from single variable values to custom representations of object graphs. We demonstrate practicability by applying it to the TraceDebugger, a time-travel debugger for Squeak/Smalltalk. We examine the practical opportunities and limitations of object traces and suggest directions for future work.

References

[1]

Roberto Baldoni, Emilio Coppa, Daniele Cono D’elia, Camil Demetrescu, and Irene Finocchi. 2018. A Survey of Symbolic Execution Techniques. Comput. Surveys 51, 3, Article 50 (2018), 39 pages. https://doi.org/10.1145/3182657

Digital Library

[2]

Cristian Cadar and Koushik Sen. 2013. Symbolic Execution for Software Testing: Three Decades Later. Commun. ACM 56, 2, 82–90. https://doi.org/10.1145/2408776.2408795

Digital Library

[3]

Andrei Chiş, Oscar Nierstrasz, Aliaksei Syrel, and Tudor Gîrba. 2015. The Moldable Inspector. In 2015 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward!) (Pittsburgh, PA, USA) (Onward! 2015). Association for Computing Machinery, New York, NY, USA, 44–60. https://doi.org/10.1145/2814228.2814234

Digital Library

[4]

Andrei Chiş, Tudor Gîrba, and Oscar Nierstrasz. 2014. The Moldable Debugger: A Framework for Developing Domain-specific Debuggers. In Software Language Engineering, Benoît Combemale, David J. Pearce, Olivier Barais, and Jurgen J. Vinju (Eds.). Springer International Publishing, 102–121. https://doi.org/10.1007/978-3-319-11245-9_6

[5]

Claudio Corrodi. 2016. Towards Efficient Object-centric Debugging With Declarative Breakpoints. In Post-proceedings of the 9th Seminar on Advanced Techniques and Tools for Software Evolution, Bergen, Norway, July 11-13, 2016(CEUR Workshop Proceedings, Vol. 1791), Mircea Lungu, Anya Helene Bagge, and Haidar Osman (Eds.). CEUR-WS.org, 32–39. http://ceur-ws.org/Vol-1791/paper-04.pdf

[6]

Steven Costiou, Clotilde Toullec, Mickaël Kerboeuf, and Alain Plantec. 2018. Back-in-Time Inspectors: An Implementation With Collectors. In International Workshop on Smalltalk Technologies, Vol. 10. Cagliari, Italy. https://hal.univ-brest.fr/hal-02320434

[7]

Ward Cunningham and Kent Beck. 1986. A Diagram for Object-oriented Programs, In Conference Proceedings on Object-Oriented Programming Systems, Languages and Applications. ACM Sigplan Notices 21, 11, 361–367. https://doi.org/10.1145/28697.28734

Digital Library

[8]

Jeffrey K. Czyz and Bharat Jayaraman. 2007. Declarative and Visual Debugging in Eclipse. In Proceedings of the 2007 OOPSLA Workshop on Eclipse Technology EXchange (Montreal, Quebec, Canada) (eclipse ’07). Association for Computing Machinery, New York, NY, USA, 31–35. https://doi.org/10.1145/1328279.1328286

Digital Library

[9]

Marcus Denker, Stéphane Ducasse, and Éric Tanter. 2006. Runtime bytecode transformation for Smalltalk. Computer Languages, Systems & Structures 32, 2 (2006), 125–139. https://doi.org/10.1016/j.cl.2005.10.002

Digital Library

[10]

Michael J Flynn. 1966. Very High-speed Computing Systems. Proc. IEEE 54, 12, 1901–1909. https://doi.org/10.1109/PROC.1966.5273

[11]

Hani Z Girgis and Bharat Jayaraman. 2006. JavaDD: A Declarative Debugger for Java. Technical Report. Department of Computer Science and Engineering, University at Buffalo. https://cse.buffalo.edu/tech-reports/2006-07.pdf

[12]

Adele Goldberg and David Robson. 1983. Smalltalk-80: The Language and Its Implementation. Addison-Wesley Longman Publishing Co., Inc., USA. https://dl.acm.org/doi/book/10.5555/273

Digital Library

[13]

Simon F. Goldsmith, Robert O’Callahan, and Alex Aiken. 2005. Relational Queries Over Program Traces. ACM SIGPLAN Notices 40, 10 (oct 2005), 385–402. https://doi.org/10.1145/1103845.1094841

Digital Library

[14]

Christoph Hofer, Marcus Denker, and Stéphane Ducasse. 2006. Design and implementation of a backward-in-time debugger. In NODe 2006 – GSEM 2006, Robert Hirschfeld, Andreas Polze, and Ryszard Kowalczyk (Eds.). Gesellschaft für Informatik e.V., Bonn, 17–32. https://dl.gi.de/20.500.12116/24100

[15]

Dan Ingalls, Ted Kaehler, John Maloney, Scott Wallace, and Alan Kay. 1997. Back to the Future: The Story of Squeak, a Practical Smalltalk Written in Itself, In Proceedings of the 12th ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages, and Applications (Atlanta, Georgia, USA). SIGPLAN Not. 32, 10, 318–326. https://doi.org/10.1145/263700.263754

Digital Library

[16]

Amy J. Ko and Brad A. Myers. 2008. Debugging Reinvented: Asking and Answering Why and Why Not Questions About Program Behavior. In Proceedings of the 30th International Conference on Software Engineering (Leipzig, Germany) (ICSE ’08). Association for Computing Machinery, New York, NY, USA, 301–310. https://doi.org/10.1145/1368088.1368130

Digital Library

[17]

Raimondas Lencevicius, Urs Hölzle, and Ambuj K. Singh. 1997. Query-based Debugging of Object-oriented Programs. ACM SIGPLAN Notices 32, 10 (1997), 304–317. https://doi.org/10.1145/263698.263752

Digital Library

[18]

Demian Lessa, Bharat Jayaraman, and Jeffrey K Czyz. 2010. Scalable Visualizations and Query-based Debugging. Technical Report. University at Buffalo, Department of Computer Science and Engineering. https://cse.buffalo.edu/tech-reports/2010-10.pdf

[19]

Bil Lewis. 2003. Debugging Backwards in Time, In Proceedings of the Fifth International Workshop on Automated Debugging (AADEBUG 2003). CoRR cs.SE/0310016. https://doi.org/10.48550/ARXIV.CS/0310016

[20]

Adrian Lienhard, Stéphane Ducasse, and Tudor Gîrba. 2009. Taking an Object-centric View on Dynamic Information With Object Flow Analysis, In ESUG 2007 International Conference on Dynamic Languages (ESUG/ICDL 2007). Computer Languages, Systems & Structures 35, 1, 63–79. https://doi.org/10.1016/j.cl.2008.05.006

Digital Library

[21]

Adrian Lienhard, Tudor Gîrba, Orla Greevy, and Oscar Nierstrasz. 2008. Test Blueprints – Exposing Side Effects in Execution Traces to Support Writing Unit Tests. In Proceedings of the 2008 12th European Conference on Software Maintenance and Reengineering(CSMR ’08). IEEE Computer Society, USA, 83–92. https://doi.org/10.1109/CSMR.2008.4493303

Digital Library

[22]

Jens Lincke, Robert Krahn, and Robert Hirschfeld. 2011. Implementing Scoped Method Tracing with ContextJS. In Proceedings of the 3rd ACM International Workshop on Context-Oriented Programming (Lancaster, United Kingdom) (COP ’11). Association for Computing Machinery, New York, NY, USA, Article 6, 6 pages. https://doi.org/10.1145/2068736.2068742

Digital Library

[23]

Michael Martin, Benjamin Livshits, and Monica S. Lam. 2005. Finding Application Errors and Security Flaws Using PQL: A Program Query Language, In Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (San Diego, CA, USA). ACM SIGPLAN Notices 40, 10, 365–383. https://doi.org/10.1145/1094811.1094840

Digital Library

[24]

Michael Perscheid, Bastian Steinert, Robert Hirschfeld, Felix Geller, and Michael Haupt. 2010. Immediacy through Interactivity: Online Analysis of Run-time Behavior. In 2010 17th Working Conference on Reverse Engineering. 77–86. https://doi.org/10.1109/WCRE.2010.17

Digital Library

[25]

Khoo Yit Phang, Jeffrey S. Foster, and Michael Hicks. 2013. Expositor: Scriptable Time-travel Debugging With First-Class Traces. In 2013 35th International Conference on Software Engineering (ICSE). 352–361. https://doi.org/10.1109/ICSE.2013.6606581

[26]

A. Potanin, J. Noble, and R. Biddle. 2004. Snapshot Query-based Debugging. In 2004 Australian Software Engineering Conference. Proceedings.251–259. https://doi.org/10.1109/ASWEC.2004.1290478

[27]

Guillaume Pothier and Éric Tanter. 2009. Back to the Future: Omniscient Debugging. IEEE Software 26, 6 (2009), 78–85. https://doi.org/10.1109/MS.2009.169

Digital Library

[28]

David Rauch, Patrick Rein, Stefan Ramson, Jens Lincke, and Robert Hirschfeld. 2019. Babylonian-style Programming: Design and Implementation of an Integration of Live Examples into General-purpose Source Code. The Art, Science, and Engineering of Programming 3, 3, 9. https://doi.org/10.22152/programming-journal.org/2019/3/9

[29]

Jorge Ressia, Alexandre Bergel, and Oscar Nierstrasz. 2012. Object-centric Debugging. In 2012 34th International Conference on Software Engineering (ICSE). IEEE, 485–495. https://doi.org/10.1109/ICSE.2012.6227167

[30]

Leon Schweizer. 2014. PathObjects: Revealing Object Interactions to Assist Developers in Program Comprehension. Master’s thesis. Hasso Plattner Institute, University of Potsdam. https://github.com/leoschweizer/PathObjects-Thesis

[31]

Ben Shneiderman and Catherine Plaisant. 2005. Designing the User Interface: Strategies for Effective Human-Computer Interaction (4th ed.). Pearson Education. http://seu1.org/files/level5/IT201/Book%20-%20Ben%20Shneiderman-Designing%20the%20User%20Interface-4th%20Edition.pdf

Digital Library

[32]

Christoph Thiede and Patrick Rein. 2021. Squeak by Example. Vol. 5.3.1. https://wiki.squeak.org/squeak/6546

[33]

David Ungar, Henry Lieberman, and Christopher Fry. 1997. Debugging and the Experience of Immediacy. Commun. ACM 40, 4 (apr 1997), 38–43. https://doi.org/10.1145/248448.248457

Digital Library

Cited By

Thiede CTaeumel MBöhme LHirschfeld REdwards JTaeumel M(2024)Talking to Objects in Natural Language: Toward Semantic Tools for Exploratory ProgrammingProceedings of the 2024 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software10.1145/3689492.3690049(68-84)Online publication date: 17-Oct-2024
https://dl.acm.org/doi/10.1145/3689492.3690049
Bourcier VCostiou S(2024)Scopeo: an Object-Centric Debugging Approach for Exploring Object-Oriented Programs2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)10.1109/SANER60148.2024.00040(332-336)Online publication date: 12-Mar-2024
https://doi.org/10.1109/SANER60148.2024.00040

Index Terms

Object-Centric Time-Travel Debugging: Exploring Traces of Objects
1. Software and its engineering
  1. Software creation and management
    1. Software verification and validation
      1. Software defect analysis
        Software testing and debugging
  2. Software notations and tools
    1. Development frameworks and environments
      1. Integrated and visual development environments

Recommendations

Time-Awareness in Object Exploration Tools: Toward In Situ Omniscient Debugging
Onward! 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software

Exploration of state and behavior is essential for understanding and debugging object-oriented programs. Many time-related questions about object communication – an object’s history – only arise in the context of a specific error in the here and now. ...
Time-travel debugging for JavaScript/Node.js
FSE 2016: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering

Time-traveling in the execution history of a program during debugging enables a developer to precisely track and understand the sequence of statements and program values leading to an error. To provide this functionality to real world developers, we ...
Example Mining: Assisting Example Creation to Enhance Code Comprehension
Programming '22: Companion Proceedings of the 6th International Conference on the Art, Science, and Engineering of Programming

Programmers often use examples with concrete values to better understand code. Code by itself is abstract, which empowers it to be used for a variety of uses, but can be difficult to grasp by developers. Babylonian Programming addresses this by allowing ...

Comments

Information & Contributors

Information

Published In

cover image ACM Other conferences

Programming '23: Companion Proceedings of the 7th International Conference on the Art, Science, and Engineering of Programming

March 2023

134 pages

ISBN:9798400707551

DOI:10.1145/3594671

Copyright © 2023 Owner/Author.

This work is licensed under a Creative Commons Attribution International 4.0 License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 12 September 2023

Check for updates

Author Tags

Qualifiers

Research-article
Research
Refereed limited

Conference

<Programming> '23 Companion

<Programming> '23 Companion: Companion Proceedings of the 7th International Conference on the Art, Science, and Engineering of Programming

March 13 - 17, 2023

Tokyo, Japan

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

1
Total Citations
View Citations
1,426
Total Downloads

Downloads (Last 12 months)1,297
Downloads (Last 6 weeks)97

Reflects downloads up to 09 Feb 2025

Other Metrics

View Author Metrics

Citations

Cited By

Thiede CTaeumel MBöhme LHirschfeld REdwards JTaeumel M(2024)Talking to Objects in Natural Language: Toward Semantic Tools for Exploratory ProgrammingProceedings of the 2024 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software10.1145/3689492.3690049(68-84)Online publication date: 17-Oct-2024
https://dl.acm.org/doi/10.1145/3689492.3690049
Bourcier VCostiou S(2024)Scopeo: an Object-Centric Debugging Approach for Exploring Object-Oriented Programs2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER)10.1109/SANER60148.2024.00040(332-336)Online publication date: 12-Mar-2024
https://doi.org/10.1109/SANER60148.2024.00040

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

HTML Format

View this article in HTML Format.

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

Figures

Tables

Media

View Table of Conten