debugger

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.

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.

Evan Czaplicki's Strange Loop 2014 talk surveys the many formulations of functional reactive programming and how they relate historically and theoretically. It then shows how Elm's variant enables hot-swapping and its time-traveling debugger.

Casey Muratori responds on-stream to a dismissive Twitter post by demonstrating how slow Visual Studio's startup and debugger watch window are, comparing it to much older software and machines. It is a long rant about software performance and bloat.

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.

Elias Martenson presents his Emacs-based workflow for building a web application (the Potato chat platform) with Common Lisp on the backend and ClojureScript on the frontend. He demonstrates SLIME, Paredit, CIDER and debugger-driven interactive development. The talk is 79 minutes and was given at Emacs SG.

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.

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.

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.

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.

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.

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.

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.

Chris Toomey of thoughtbot explains Vim as a language of commands, motions and text objects that combine into precise edits. He shows how to master the built-in pieces and extend them.

Casey Muratori shows how fast a terminal renderer can run, building a simple reference renderer that handles Unicode and colored text far quicker than Windows Terminal. He argues that common excuses for slow terminals do not hold up.

A three-minute Emacs Rocks screencast by Magnar Sveen demonstrating paredit, which edits Lisp code structurally as a tree of s-expressions rather than characters.

Emily Shea explains how repetitive strain injury pushed her to program by voice using speech recognition (Talon), and gives a live coding demo. She argues voice-driven development can be pain-free, efficient and enjoyable.

Titus Winters' CppCon 2017 talk argues for C++ and Google's Abseil to be maintained as a live at head language, relying on testing and automated tooling rather than never changing or promising no compatibility. It covers Hyrum's law and the limits of semantic versioning.

Joel Grus's JupyterCon talk explaining why he dislikes Jupyter notebooks. He covers hidden state, trouble with reproducibility and testing, and how notebooks frustrate teaching. He shows his preferred workflow and what Jupyter could change.

A five-minute lightning demo of VisiData, a terminal tool for exploring and manipulating data. It uses two months of NYC 311 complaint data to drill down, plot points on a virtual map and save selected rows.

Matt Godbolt's CppCon 2017 talk shows what modern compilers do with your C++ code, using Compiler Explorer to inspect generated assembly. It covers surprising optimizations and how the tool works.

Vim creator Bram Moolenaar's 2007 Google Tech Talk on habits for efficient text editing. He explains how to spot repetition and inefficiency, then use editor features to fix it.

John Kitchin shows how Emacs org-mode with Python lets researchers combine narrative, math, figures and executable code in one document. It exports to LaTeX, HTML and PDF, and he used it for papers and e-books.

Brandon Rhodes' PyOhio 2014 talk on applying the Clean Architecture in Python. He shows how this high-level design pattern fits Python's features and addresses maintainability problems in large applications.

Aaron Bieber, a longtime Vim user, describes his experience trying Emacs with evil mode. He covers what he found, what he missed from Vim, and what Vim could borrow from Emacs.