abstract interpretation

Chandler Carruth argues in a CppCon 2019 talk that C++ has no truly zero-cost abstractions. Using examples like unique_ptr, ABI constraints and compile-time costs, he shows that abstractions cost runtime, compile time or human effort.

Cheng Lou's react-europe 2016 talk lays out a mental framework for thinking about abstraction levels in JavaScript tooling, from Angular and Grunt to Webpack and React. It uses that framework to reason about the cost of abstractions and how to choose between competing solutions.

Lecture 1B of MIT's 6.001 Structure and Interpretation of Computer Programs (1986) with Gerald Sussman, covering procedures, processes and the substitution model. It includes the line about the power of naming things.

Matt Might's Curry On talk on ending errors in code, both software and the human genome. He covers conservative approximation of the halting problem via static analysis and a computational approach to precision medicine.

The first lecture of MIT's 1986 6.001 Structure and Interpretation of Computer Programs, given by Harold Abelson, introducing Lisp and the idea of computer science as the study of process.

Sean Carroll gives a Royal Institution talk tracing the history of quantum mechanics from Einstein and Bohr to today. He covers the Copenhagen interpretation and the many worlds interpretation.

Dan Abramov's talk on the wet codebase, using visualizations to show how removing all duplication too early produces wrong abstractions that are hard to unwind.

3Blue1Brown introduces group theory and abstract groups, then builds toward classification of finite simple groups and the enormous Monster group with its 196,883 dimensions.

Lecture 7A of the 1986 MIT 6.001 SICP course, with Gerald Sussman presenting the metacircular evaluator, part 1. It shows how a Lisp evaluator can be written in Lisp itself.

Ron Garret's Google Tech Talk argues that quantum mechanics is no harder to understand than relativity and that popular accounts wrongly rely on the Copenhagen interpretation. He presents measurement as entanglement and explains phenomena like the quantum eraser.

A very short clip of Carl Sagan saying that to make an apple pie from scratch you must first invent the universe. It illustrates how everything depends on a chain of prior things.

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.

Jason Turner's CppCon 2016 talk builds a simple Commodore 64 game using C++17, showing how constexpr and const let a modern compiler produce tight 6502 code. He walks through assembly output to show abstractions being optimized away.

Cliff Click of Azul Systems asks what a JVM is supposed to do, in a Google Tech Talk from 2011. He covers the services a JVM provides, such as garbage collection and compilation, and the messy reality beneath the abstractions.

Simon Peyton Jones explains nested data parallelism and Data Parallel Haskell, an approach to exploiting multicore and distributed hardware while keeping a simple single-control-flow programming model.

Nada Amin's Strange Loop talk on programming languages that build on themselves, centered on towers of interpreters and nestable interpretation in Scheme. She shows how interpreters can be stacked and collapsed.

Part 2 of an old Microsoft Research demo of Intentional Programming, showing the compiler side of a system that stores programs as abstract structure rather than text. The uploader says the companion editor clip is clearer.

The first lecture of MIT's 6.001 (SICP) with Abelson and Sussman, giving an overview of the course and an introduction to Lisp. It argues that computer science is about managing complexity and abstraction, not computers.

Jonathan Blow's DevGAMM 2019 talk argues that software knowledge is being lost between generations and that growing layers of abstraction could lead to a decline in technological civilization.

Casey Muratori's University of Twente guest lecture is a case study in how straightforward code can cut thousands of lines and tens of seconds of runtime down to a few dozen lines running in under a second. It uses concrete examples to show why software is often an order of magnitude slower than it should be.

Runar Bjarnason's Scala World talk argues that restraint and precision in components beat power and flexibility. Constraints on parts make them easier to compose into systems.

Elm creator Evan Czaplicki's talk on how a file grows and when to split code up. He argues for keeping code in one file until it hurts and warns against premature extraction.

Sandi Metz argues that hidden assumptions in code are missing concepts, and shows how to name and expose them so code is easier to understand and change. It covers null objects and messages in Ruby.

A PBS Space Time episode introducing de Broglie-Bohm pilot wave theory, an interpretation of quantum mechanics that avoids much of the strangeness of the mainstream views. It is aimed at curious lay viewers.

Moral philosopher James Flynn explains the Flynn effect, the steady rise of IQ scores across the 20th century. He argues the shift reflects a move toward abstract, hypothetical thinking as cognitively demanding professions grew.

Looking Glass Universe explains de Broglie-Bohm pilot wave theory (Bohmian mechanics) as an alternative to the standard interpretation of quantum mechanics. The video lays out the pros and cons of the theory and links to related videos on contextuality and entanglement.

Eugenia Cheng gives the opening keynote at Lambda World 2017, presenting category theory as very abstract algebra whose abstraction gives it broad applicability. She applies it to everyday questions including privilege and prejudice.

Veritasium explains the many-worlds interpretation of quantum mechanics, drawing heavily on Sean Carroll's book. It walks through the Schrodinger equation and why wave collapse may be unnecessary if the universe keeps splitting.

A two-hour Computer History Museum oral history interview with Bjarne Stroustrup, conducted by Paul McJones in 2015. It covers his youth, education at Aarhus and Cambridge, his career at Bell Labs and elsewhere, and the design and evolution of C++.

Svelte creator Rich Harris explains moving reactivity into the compiler and language rather than tracking state at runtime, with a history of spreadsheets as reactive systems and comparisons to React.

Rob Pike shows how the Go text/template lexer is built, using state functions, goroutines and channels. The talk was given at a Google Technology User Group in Sydney in 2011.

William Byrd presents at Papers We Love NYC on what he calls the most beautiful program ever written, a Lisp interpreter written in Lisp. He walks through the metacircular interpreter and related ideas, and demos relational programming and program synthesis near the end.

Christian Schafmeister's Google Tech Talk on designing spiroligomer molecules and building Clasp, a Common Lisp on LLVM that interoperates with C++, to program molecular design. It covers the chemistry, automatic differentiation for force fields, and how the compiler is built.

Tom7 explains how he built a SIGBOVIK 2017 paper made only of printable ASCII bytes that is also a valid DOS executable. He writes a C compiler targeting printable x86 without self-modifying code and solves the puzzles the constraint creates.

Christopher Domas's Derbycon 2015 talk on the M/o/Vfuscator, a compiler that emits only x86 mov instructions, showing mov is Turing complete. It explains how a full machine is built from mov and why the output is a nightmare to reverse engineer.

David Beazley's PyCon India closing keynote, in which he live-codes a stack machine and grows it into an interpreter that runs WebAssembly, then uses it to play a Rust-written game. It requires no prior WebAssembly knowledge.

Miguel de Icaza's GodotCon 2023 talk on Swift bindings for Godot. He argues that garbage-collector pauses in C# are a persistent problem and that Swift's reference counting avoids them.

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.

A two-hour live stream in which Aaron Hsu explains the architecture, design history and aesthetic of Co-dfns, his parallel APL compiler. He walks through the code and the reasoning behind its dense style.

Eric Bier, a PARC research scientist, demonstrates the Cedar integrated programming environment and language, an evolution of Mesa from Xerox PARC. The demo shows the Tioga editor, garbage collection, and a full graphical workstation environment.