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.
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.
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.
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.
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.
I demo the deep-zoom debugger to my colleague Huiqi Zhou.
I give a status update on the project I've been working called the "Time Machine".
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.
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.
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.
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.
I started working on a time-traveling debugger for Python. This a video documenting it.
Here I give an update about the progress of the time traveling debugger for Python.
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.
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.
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.
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.
In this video Huiqi and I talk about the role of data visualization in debuggers.
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.
I tell Huiqi about a performance war story that took place last week.
I talk briefly with Huiqi about learning C and C++ vs more modern languages like Go and 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
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.
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.
I am making a terminal-based UI framework for the time-traveling debugger project. Here I share what I did so far with Huiqi.
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.
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.
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.
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.
I show Huiqi an interesting performance bug and the interesting way I visualized the execution of the code to understand the problem.
Another status update for the time-traveling debugger.
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!
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.
I give Huiqi an update on the debugger project and we have a discussion about different approaches.