Series: Time Traveling Debugger

In this video I demonstrate the time traveling debugger I built over my vacation. A time traveling debugger is a debugger that can step backwards in time. I devised a scheme to implement this concept using immutable data structures within the programming language. The Fun Programming Language was used as the test bed for implementing this concept.

Watch “Time Traveling Debugger - Part 1”

I continue demonstrating the time traveling debugger I built over my vacation. The debugger relies on a history file which contains snapshots of every state of the program’s execution. In this video I demonstrate how the debugger works with heap objects: arrays and dictionaries.

Watch “Time Traveling Debugger - Part 2”

In this video I’ll dig into the internals of the code generator of the Fun language to show you where most of the magic happens to make the time traveling debugger work.

Watch “Time Traveling Debugger - Part 3”

In this video I will explain the motivation behind my work on the time traveling debugger, the prior art surrounding this idea, and give a status update on the project.

Watch “Dream of the Time Machine”

I give a brief introduction to the deep zoom debugger. The deep zoom debugger is a new concept of what a debugger for programs could be. It uses a zooming based user interface a la Google Earth to allow the programmer to inspect the program from differ levels of detail.

Watch “Introducing the Deep Zoom Debugger”

I demo the deep-zoom debugger to my colleague Huiqi Zhou.

Watch “Deep-Zoom Debugger Demo with Huiqi Zhou”

I give a status update on the project I've been working called the "Time Machine".

Watch “Time Machine Status Update 1”

This time on Time Machine Status Update I talk about my failed attempt at improving the performance of the $stringify serialization function and the effort to update the zoom debugger UI to work with the sqlite-based database scheme.

Watch “Time Machine Status Update 2”

I present a design problem I encountered while working on the zoom debugger and how I resolved it, at least for the moment. I hope this can be instructive for some developers towards solving problems of their own.

Watch “Design Problem: Data Fetching Scheme of Zoom Debugger”

In this video, Huiqi and I talk about the time traveling debugging I've been working on. We plan to explain the architecture and inner workings of the debugger as well as covering some important computer science concepts along the way over a series of episodes.

Watch “How Time Traveling Works”

In this video I want to allow Huiqi and you the viewers to experience what it's like to code with a time traveling debugger. We do a medium difficulty challenge from leetcode.com called Add Two Numbers: https://leetcode.com/problems/add-two-numbers/. At the end we also go over how to get setup if you want to take the debugger for a spin yourself. You can find that info at https://github.com/airportyh/play-lang.

Watch “What it's Like to Code with a Time Traveling Debugger”

I started working on a time-traveling debugger for Python. This a video documenting it.

Watch “Time Traveling Debugger for Python”

Here I give an update about the progress of the time traveling debugger for Python.

Watch “Python Debugger Update”

In this video I tell Huiqi about rr: a report/replay debugger for C and C++. We talk about how record/replay debuggers work using Redux as a starting point.

Watch “rr and Time-Traveling Debuggers”

This video introduces the time traveling debugging for Python I've been working up to today. It show what it's like to code using time traveling debugging, how my implementation works, as well as a proof of concept debugging UI called the zoom debugger. The time traveling debugger project can be found at: https://github.com/airportyh/time-traveling-debugger.

Watch “Time Travel Debugging (in Python)”

Bil Lewis published an influential paper in 2003 called "Debugging Backwards in Time". It inspired me and others to build time traveling debuggers of their own. The debugger he built was called ODB, or the Omniscient debugger, implemented for Java. I was very lucky to get to chat with him over zoom, ask him some questions, and even have him demo the ODB to me. We had an amicable chat. The source code of ODB can be found at https://github.com/OmniscientDebugger/LewisOmniscientDebugger, and his paper can be found at http://www.cs.kent.edu/~farrell/mc08/lectures/progs/pthreads/Lewis-Berg/odb/AADEBUG_Mar_03.pdf. Also, he once did a talk at Google which was recorded and published here: https://www.youtube.com/watch?v=xpI8hIgOyko.

Watch “Omniscient Debugging (ODB) With Bil Lewis”

In this video with Huiqi I describe a proposal for a change in the design of the time travel debugger's state storage mechanism, in hopes of improving the performance of the recreate program and the disk usage of the resulting history file.

Watch “TT Debugger Data Storage Optimization”

In this video Huiqi and I talk about the role of data visualization in debuggers.

Watch “Data Visualization in Debugging”

In this episode, I share a status update on the time-traveling debugger project and then Huiqi and I do a brainstorming session on possible visualizations for debuggers.

Watch “Questions Developers Ask When Debugging”

I tell Huiqi about a performance war story that took place last week.

Watch “Let's Talk About Performance”

I talk briefly with Huiqi about learning C and C++ vs more modern languages like Go and Rust.

Watch “Learning C/C++ vs Go or Rust”

We talk about performance again! We follow up on the previous week's plan to speed up the "recreate" program. Short version: it worked as predicted! Long version: watch the video. The Stackoverflow answer written by Mike Dunlavey that was cited can be found here: https://stackoverflow.com/a/1796715/5304

Watch “Let's Talk about Performance! (2)”

I rewrote some Python code in C last couple of weeks to improve the performance of the "recreate" program. Here I show a brief side-by-side comparison of the code before and after with Huiqi.

Watch “Python vs C: Side by Side (Plus Macros!)”

In this video I give an introduction and a demo to the rr debugger. rr (https://rr-project.org/) is a revolutionary time-traveling debugger. It was initially developed by Robert O'Callahan and others at Mozilla for the purpose of debugging difficult to reproduce bugs in Firefox. It uses the deterministic replay technique to enable time-traveling. The ability to reverse time in debugging is a game changer. It has saved me hours of debugging time and allowed me to solve mysteries I would not otherwise have been able to solve. The ability to reverse time gives rise to some new debugging techniques. I cover one technique here called "Backup and Drill Down" and I plan to cover more in future videos.

Watch “rr Time-Traveling Debugger”

I am making a terminal-based UI framework for the time-traveling debugger project. Here I share what I did so far with Huiqi.

Watch “Making a Terminal-Based UI Framework”

I recently got my time-traveling Python debugger working again after some major reconstruction work and it felt really good to use it for actual work again. In this video I should you an actual debugging session where I solve a couple of bugs in a text field widget I am working on.

Watch “Debugging UI Widget with Time Travel”

In this video I implement keyboard focus for text fields in a UI framework I've been working on. The implementation was aided by the time-traveling Python debugger.

Watch “Building a UI Framework with Time Travel”

I tell the story of an interesting bug I encountered while working on a scroll view widget, how I used the time-traveling debugger to tackle it, and the lessons I learned.

Watch “An Interesting Bug”

This is the first status update on the time-travel debugger in a while, and I do it in Huiqi's presence. I made a windowing system on top of a UI framework I call oui. I implemented a tree widget which is now able to display composite data structures like dictionaries and object with the expand and collapse feature.

Watch “Time Machine Status Update 3”

I show Huiqi an interesting performance bug and the interesting way I visualized the execution of the code to understand the problem.

Watch “Seeing Code As Fractals”

Another status update for the time-traveling debugger.

Watch “Time Machine Status Update 4”

I give another status update about the time-traveling debugger with Huiqi. We slipped into a little bit of dynamic programming talk in the middle of the conversation. Enjoy!

Watch “Time Machine Status Update 5”

I give Huiqi another status update of the time-traveling debugger. We talked about sticky line numbers, file selection menu, hit indicators for file lines, the launch/goto bar, and future features.

Watch “Time Machine Status Update 6”

I give Huiqi an update on the debugger project and we have a discussion about different approaches.

Watch “Time Machine Update and Design Discussion”

I have the great pleasure of speaking to Robert O'Callahan (roc), the creator of the rr record/replay debugger and co-founder of Pernosco. We talk about the origins of his various projects, how they work, what they mean for the software industry, and more. roc's blog - https://robert.ocallahan.org/ rr - https://rr-project.org/ roc's rr talk - https://www.youtube.com/watch?v=H4iNuufAe_8 Pernosco - https://pernos.co/ Chromometer paper - https://www.cs.purdue.edu/homes/xyzhang/fall07/Papers/Amber.pdf My videos about rr - https://tobyho.com/video-series/rr-debugger.html

Watch “Time-Travel Debugging with Robert O'Callahan”

In this video I do a simple roman numeral conversion code exercise to demonstrate what it's like to code with a time-traveling debugger.

Watch “Code Exercise with a Time-Traveling Debugger”

Hello everyone! This is a recording of a talk I've done at some Atlanta local events about Time Travel Debuggers. It was the first time in years that I'd give a tech talk in public. It was very nostalgic. I was also very happy to be able see the reactions of the audience live! Although I won't be able to see your reactions live, you may give it to me via the comment section.

Watch “Time Travel Debuggers Talk”