incremental reading

A five-minute SuperMemo demo of incremental reading: importing a Wikipedia article on nutrition, extracting passages, making cloze deletions and finishing the item. It lists the keyboard shortcuts used.

Yaron Minsky of Jane Street shows how the OCaml Incremental library lets trading UIs express data transformations that are easy to read and efficient on streaming data. It includes a live table demo.

A short film by Max Joseph about his anxiety in bookstores and how to read more books amid constant streaming, social media and news. He looks for ways to rebalance his content diet in favor of reading.

A 2015 GDC talk by Bungie's Barry Genova on how Destiny's engine was restructured into a job graph with limited thread pre-emption. It is aimed at programmers of demanding game engines.

Pianist Tom Brier sight-reads a piano arrangement of the Super Mario World ending theme, working from a first-draft score by Keeper1st. He takes some liberties with the score as he plays.

Alan Kay speaks at the DEMO Founder School session on why real progress takes invention rather than incremental innovation. He argues for problem-oriented thinking and long-term research funding.

Konrad Malawski's Strange Loop 2023 talk shows how the FoundationDB team adopted Swift incrementally in a C++ codebase. It covers Swift's C++ interoperability, which let them move single functions or entire types over one at a time.

Max Brunsfeld of GitHub presents Tree-sitter, a parsing system for programming tools that supports incremental, error-tolerant parsing. He demos its integration into GitHub.com and Atom for syntax highlighting and code navigation.

Ken Shirriff walks through how to reverse engineer integrated circuits from die photos, using famous chips as examples, in a Hackaday SuperConference talk.

Max Brunsfeld introduces Tree-sitter, a parsing system for developer tools that offers incremental parsing and robust error recovery through a uniform C API. The talk explains the design, based on LR extended to GLR parsing.

Anders Hejlsberg whiteboards how compilers are taught versus how modern ones are actually built. He explains the shift to compilers as services with incremental, error-tolerant, IDE-oriented design, as in Roslyn and TypeScript.

Kiran Pamnany's Cambridge Julia Meetup talk on Julia's shared memory parallelism and its new task scheduler. It argues that fork-join and work-stealing models nest poorly and presents depth-first scheduling for composable parallelism.

Charles Marohn of Strong Towns presents, in a Talks at Google session, the ideas from his book on why many North American towns struggle financially despite decades of growth. He argues for incremental, bottom-up city building as a path to local prosperity.

Dennis Gustafsson, creator of Teardown, presents how he parallelized the physics solver for an upcoming game, followed by a Q&A. The talk was given at the Better Software Conference 2025.

A reading of David Foster Wallace's essay Consider the Lobster, about the 2003 Maine Lobster Festival and the ethics of boiling lobsters alive. The reading runs about 50 minutes.

Paul Irish walks through the jQuery source code and shares ten lessons and interesting techniques from it, aimed at JavaScript developers who want to learn from a widely used library.

Paul Phillips, a former Scala core contributor, argues after moving a million lines of code that much of what the software industry does is wrong. He critiques Scala and compiler design and calls for better approaches.

Daniel Dunbar of Apple presents llbuild, a framework for building build systems, at the 2016 LLVM Developers' Meeting. He argues that the traditional way C compilers integrate with build systems limits compile speed, and proposes a new architecture.

A short scene from the British sitcom Yes Prime Minister in which officials describe 'salami tactics' for invading a country slice by slice. Each small step is too minor to justify a major response.

Martin Odersky's JVM Language Summit 2015 talk argues that compilers can be thought of as databases. It describes design ideas for the Scala compiler and for developer tools.

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.

In this 2019 GDC session, Petri Purho of Nolla Games explains the technical side of Noita's physics engine, including scaling a falling-sand simulation to large continuous worlds and adding destructible rigid bodies. It also shows how the emergent physics drives the gameplay.

Paul Turner of Google presents kernel interfaces for user-level scheduling of real threads, aiming at a uniform synchronous programming model across C++, Java, Go and Python. It introduces the switchto-style system calls behind Google's fibers.

Larry Hastings explains what Python's GIL is, what problems it solves and how it works, and presents his Gilectomy project to remove it, including the performance and C-extension obstacles.

Raymond Hettinger's PyBay 2017 keynote on concurrency in Python. It covers threads, processes, asyncio, locks and the GIL, with live shell-based examples.

David Beazley's PyCon 2010 talk explains how the Python Global Interpreter Lock works and shows experiments where multithreaded code runs slower, even on more cores, due to lock contention and context-switching overhead.

A BBC Horizon clip demonstrating the McGurk effect, where the same audio sounds like different syllables depending on the mouth movements you see. It shows that people integrate visual speech information into what they hear.

Yuta, a Japanese YouTuber, tests how much simplified Chinese a Japanese person can read, working with a Mandarin speaker. The video shows where shared kanji help and where meanings differ.

A two-minute BBC Horizon clip demonstrating the McGurk effect, where what you see of a speaker's mouth changes the sound you hear.

A Wired short on competitive high school policy debate, where students speak at around 350 words per minute. It shows how a nerdy contest turned into a high-speed spectacle.

John Ousterhout, Stanford professor and creator of Tcl, presents the ideas of his book A Philosophy of Software Design in a Talks at Google session. He covers managing complexity, deep modules and interfaces, and what he teaches in his Stanford software design course.

SethBling shows MarI/O, a program using neural networks and the NEAT genetic algorithm to learn to play Super Mario World. The description links the source code, the paper and background reading.

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.

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.

Herb Sutter's CppCon 2022 talk on whether C++ can become ten times simpler and safer. He introduces his experimental Cpp2 syntax and the cppfront transpiler, explaining the limits on incremental improvement.

Not Just Bikes explains how many American suburbs, built all at once rather than incrementally, cannot cover their infrastructure costs and survive on growing debt. It draws on Strong Towns' work on the growth Ponzi scheme.

A two-minute time-lapse from the Kishony Lab showing bacteria spreading across a giant petri dish with increasing antibiotic doses, evolving resistance as they go.

Part 4 of John Carmack's QuakeCon 2013 keynote, covering OpenGL, functional programming, Haskell, Lisp and Scheme, typing, multithreading, events and garbage collection.

Jay Parlar's Strange Loop talk shows how model checkers such as Alloy can find complex bugs in a system's design without running or reading any code. He walks through modeling architectures and checking every possible sequence of operations, including a real security bug and a UI feature-interaction bug.

Stuart Halloway's satirical talk describes how to protect yourself from industry change by spreading complexity through systems while following idiomatic practice. It uses this inversion to catalog software design anti-patterns.