compile times

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.

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.

Matt Godbolt, creator of Compiler Explorer, tours surprising optimizations modern compilers perform, such as turning loops into closed-form sums and using popcount instructions. He explores what the compiler does behind the scenes.

Chris Lattner's ASPLOS 2021 keynote on the golden age of compiler design in an era of hardware and software co-design, covering compiler infrastructure for accelerators and unifying hardware IRs.

John Oliver's Last Week Tonight segment on timeshares covers how people get sold into them, why they are so hard to leave, and the exit-company scams that target owners trying to get out.

Matt Godbolt tells the story of Compiler Explorer, from a hacky basement server to a cloud-scaled service handling tens of thousands of daily requests. He also shows its features and how it is built.

A long Mill Computing lecture on the Mill CPU's compiler toolchain, covering the specializer that targets family members, scheduling and latency passes, and the belt. It explains how the compiler handles a wide-issue, exposed-pipeline design.

Andy Keep's Clojure/Conj talk on writing a nanopass compiler, built from many single-task passes with formally defined intermediate languages. It covers the framework's origins in a compiler teaching course at Indiana University.

Jonathan Blow demos his prototype programming language, covering the base language and compile-time execution, including running a game while compiling. The video is about 70 minutes of demo followed by Q&A.

Chandler Carruth's CppNow 2023 talk on modernizing compiler design for the Carbon toolchain, using data-oriented design and modern hardware assumptions. It covers lexing, parsing and compact data structures aimed at compiler performance.

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.

Technology Connections explains how LED traffic lights, which do not melt snow, drew complaints and were blamed for accidents. He uses it to illustrate the 'but sometimes' fallacy against new technology.

Mathologer shows how times table diagrams on a circle produce cardioids and other curves connected to the Mandelbrot set. He explains the patterns and links to a tool for making your own diagrams.

Lex Fridman interviews Chris Lattner, creator of LLVM, Clang and Swift, about compilers, Swift for TensorFlow, TPUs and ML accelerators. The talk covers how hardware and software meet to produce efficient code.

Hana Dusikova's CppCon 2018 talk presenting a C++ library that builds regular expressions from compile-time strings, using a C++20 feature. It avoids runtime parsing cost and covers implementation details, problems she hit, and benchmarks.

Chandler Carruth walks through tuning C++ performance, from writing benchmarks to analyzing results on real CPUs and compilers. It focuses on small-scale problems such as loop kernels, data structures and algorithms, and on keeping compilers from optimizing benchmarks away.

Jonathan Blow talks at Gamelab 2018 about the design decisions behind Jai, the programming language he is building for game programmers. He covers low-friction development, quality of life and the effects of compile times.

The first episode of a long live-coding series in which Immo Landwerth builds the Minsk compiler for a small language in C#. It starts with a basic expression evaluator and builds toward a full language.

Brandt Bucher presents his prototype JIT compiler for CPython at the 2023 Core Developer Sprint. He explains the copy-and-patch approach, the implementation and its performance.

An interview with Anders Hejlsberg, lead architect of TypeScript, about porting the TypeScript compiler to Go. He covers the 10x type-checking speedup, lower memory use, and why Go was chosen.

Andrew Kelley's roadmap talk on upcoming Zig compiler milestones, focused on compilation speed. It was given at a Zig community event in 2022.

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.

Andreas Kling live-codes a prototype JavaScript JIT compiler for the LibJS engine used in SerenityOS and Ladybird. He builds a standalone bytecode VM, a simple interpreter, and then a simple JIT in about 80 minutes.

Mark Bittman and baker Jim Lahey of Sullivan Street Bakery demonstrate the no-knead bread recipe, where a long, slow rise does the work instead of kneading. It is a short New York Times recipe video.

A New York Times video on how China's sheltered internet produced a new breed of apps, centering on WeChat's all-in-one model combining payments, social and services. It suggests American companies are now taking cues from Chinese tech.

In a New York Times interview, Jerry Seinfeld describes the anatomy of his Pop-Tart joke, still a work in progress, and shows his longhand writing process.

A New York Times Op-Doc by Laura Poitras profiling William Binney, a 32-year NSA veteran who helped design a secret program he says collects Americans' personal data.

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.

In this first Crust of Rust episode, Jon Gjengset live-codes an example that needs multiple explicit lifetime annotations. Along the way he covers string types and generics over a custom trait.

Anders Hejlsberg introduces the native port of the TypeScript compiler, written in Go, which promises roughly 10x faster tooling. He demos compiling VS Code and explains where the speedup comes from.

Chandler Carruth's GoingNative 2012 talk on Clang, covering how the compiler helps defend C++ code from mistakes. It makes the case for Clang's diagnostics and tooling.

A Financial Times film examining how Brexit hurt the UK economy, with FT writers and business people. It looks at trade effects, political silence about the costs, and the absence of a convincing Brexit dividend.

Ross Douthat interviews Peter Thiel about technological stagnation, AI, longevity, space travel and politics. Thiel also lays out his framing of the Antichrist as a risk of civilizational stagnation.

Graphic body-camera footage of the January 2016 fatal shooting of Daniel Shaver by an Arizona police officer in a hotel hallway, released after the officer's acquittal.

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.

Andrew Kelley, creator of Zig, presents practical data-oriented design techniques for shrinking memory footprint and making programs cache friendly. He ends with a case study of how these ideas sped up the Zig compiler.

David Schachter describes how he made a data-collection Python program run 114,000 times faster, drawing on decades of experience. The talk covers pipelining, cache effects and other optimization lessons.

Part one of a 1996 BBC Modern Times documentary on the training to become a London black cab driver. It follows candidates learning the Knowledge and facing stressful repeated exams with Public Carriage Office examiners.

Swift compiler engineers explain how Swift implements generics using dictionary-passing with reified type metadata. They compare it with Java-style uniform representation and C++ or Rust monomorphization.