debugging

An overview of the PTVS 2.0 beta feature for debugging Python and C/C++ together in one session in Visual Studio.

Stuart Halloway of Cognitect argues for debugging with the scientific method: form hypotheses, try to falsify them, and write everything down. The talk is given to the Clojure community but applies to any language.

Paul Irish's Chrome Dev Summit 2016 talk surveys the state of the art in Chrome DevTools debugging. It covers workspaces, diffs, CSS coverage, Node debugging, editor improvements and Lighthouse.

Ron Garret tells the story of the Remote Agent Experiment on NASA's Deep Space 1, where autonomous software controlled a spacecraft in 1999. He describes debugging Lisp code remotely from millions of miles away.

Bryan Cantrill's GOTO Chicago 2017 talk on debugging production systems under pressure, centered on the incident where an operator's mistyped command rebooted an entire Joyent datacenter. It covers human factors, automation and architecture.

A five-minute demo of the Common Lisp debugger fixing a bug, recompiling a single function, and resuming execution from the failed stack frame. It shows how to avoid re-running long computations.

A brief demo of the Smalltalk debugger, including defining a method that doesn't exist yet while the program is stopped mid-crash.

Allan Blomquist demonstrates the internal programming and debugging tools Tomorrow Corporation uses to make games, including live modification of a running game and time-travel debugging.

Greg Law's 15-minute CppCon 2015 lightning talk shows what GDB can do beyond basic use, including its text user interface and reverse debugging.

Bruce Waggoner of the Voyager team describes how engineers diagnosed Voyager 1's 2023 loss of telemetry and patched its flight software from 15 billion miles away. The talk covers the spacecraft's architecture and the scarcity of old documentation.

Bryan Cantrill's 2007 Google Tech Talk on DTrace, showing how dynamic tracing improves debugging of both development and live production systems. It includes a vivid war story about tracking down a problem on a Sun Ray server.

Raymond Hettinger's PyBay 2018 keynote on preventing, finding and fixing bugs under a time budget. He covers testing practice, type annotation tradeoffs and the limits of coverage metrics.

Dan Abramov live-codes hot reloading with time-travel debugging at React Europe 2015, debuting Redux and its devtools. The slides themselves are driven by application state.

A reverse engineer walks through fixing a ten-year-old bug in Guitar Hero III without access to its source code, using a disassembler and decompiler. It is technical but explained step by step.

Paul Irish and Pavel Feldman present the newest Chrome Dev Tools features at Google I/O 2011, including live CSS editing, saving changes, breakpoints and network analysis. It also covers remote debugging.

A 2007 Google Tech Talk in which Bryan Cantrill demonstrates DTrace and explains how it improves debugging of both development and live production systems.

A clip of John Carmack on the Lex Fridman podcast discussing his programming setup, why he favors debuggers and IDEs, and his puzzlement at developers who avoid them.

Bryan Cantrill's Uptime 2017 talk on the engineering challenges of the stateful data path, including storage, firmware and hardware bugs. It uses the 'zebras vs. horses' diagnostic heuristic to explain why rare failures keep appearing.

Casey Muratori gives a fast tour of the RemedyBG debugger for Windows, which he uses daily. He shows its speed and features, especially the watch window.

Bret Victor's talk from Dropbox's DBX conference about living by a guiding principle, in his case that creators need an immediate connection to what they are making. He shows live-coding and time-manipulation demos that let ideas take form at the speed of thought.

JPL's David Cummings presents at the 2025 Flight Software Workshop how the team diagnosed and fixed the 2023 Voyager 1 anomaly from billions of miles away. It walks through the flight computer and the memory fix.

A five-minute demo of a live ClojureScript game editor by Chris Granger. It is based on Bret Victor's demo from the Inventing on Principle talk, with code changes reflected instantly in the running game.

A 1993 VHS demo of Lucid Energize, a database-backed, incremental C/C++ programming environment built on XEmacs. It shows features like incremental compilation, live debugging and hyperlinked output.

Sandi Metz takes an ugly section of conditional code and refactors it into a few simple objects, bridging object-oriented theory and practice. The talk includes her take on the Gilded Rose refactoring kata and the idea that duplication is cheaper than the wrong abstraction.

Will Wilson of FoundationDB explains how the team tested their distributed database using deterministic simulation. By running the whole system in a simulator with injected faults and reproducible seeds, they could find rare concurrency and network bugs.

Ian Cooper's DevTernity talk revisits Kent Beck's original TDD ideas and shows where misunderstandings crept in. It argues tests should target behaviors through public interfaces rather than implementation details, so suites support refactoring instead of resisting it.

Bret Victor's talk at CUSEC 2012 in which he argues that creators need immediate feedback and should organize their work around a guiding principle. He demonstrates live-coding and animation tools that show results as you type, and describes his own principle that creators must see what they are making.

Rafal Dittwald's Clojure/north talk shows how to move from writing Java-style code in Clojure to thinking in data-driven, functional terms. He walks through a JavaScript example, refactoring imperative code step by step into a functional core.

Emery Berger explains why performance is hard to measure and deliver on modern hardware, showing how code layout and alignment can swamp optimization effects. He presents Stabilizer for statistically sound evaluation and Coz, a causal profiler.

Russ Cox gives a 23-minute tour of the Acme text editor from Plan 9, showing its mouse-driven interface, executing commands from text, and its filesystem-based interface to other programs.

Gil Tene of Azul Systems explains common pitfalls in measuring latency and response time, including why averages mislead and the problem of coordinated omission. He introduces open source tools like HdrHistogram for better measurement and reporting.

Gary Bernhardt's RubyConf 2012 talk on testing in isolation without mocking everything. It goes through behavior versus data, mutation versus immutability, and how a functional core with an imperative shell yields natural isolation and parallelism.

Linus Torvalds gives a Google tech talk on git, the source control system he created two years earlier. He argues for distributed version control over centralized systems such as CVS and Subversion.

A thoughtbot meetup talk by Max Cantor on getting most of what popular plugins provide using only built-in Vim features. It covers autocomplete, file jumping, filesystem navigation, build integration and snippets, with slides and a vimrc available.

Tavis Rudd describes how RSI forced him to program by voice, and shows the Python and Emacs Lisp system he built with voice recognition. A live demo creates and deploys a small system without touching the keyboard.

A lecture from MIT's Missing Semester course covering version control with git. It builds up git from its data model rather than from commands.

Howard Abrams demonstrates, in an EmacsConf 2015 talk, how he uses org-mode's Babel and Tramp to configure and operate remote servers from a single document. Code blocks, their results and the explanatory text all live together.

Ruby developer Avdi Grimm gives a seven-minute tour of Pharo Smalltalk's development environment, focusing on tools like search-by-example and the integrated, live coding experience.

A Linux.conf.au 2013 talk that explains git's internal model using a playful, toy-based approach. It presents git operations as operations on a graph of commits, aimed at people who find git confusing.

Jack Rusher's Strange Loop 2022 talk argues that most programming languages are still designed around punchcard-era assumptions. He makes the case for live, interactive programming environments, drawing on Lisp, Smalltalk and REPL-driven development.