compiler optimization

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.

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.

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.

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.

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.

Chandler Carruth's CppNow 2013 keynote on how C++ builds complex software from simple emergent structures, and how compilers optimize them through inlining and value semantics.

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.

Chandler Carruth's CppCon 2016 talk tries to defuse the heated debate over undefined behavior in C and C++. He explains from the compiler writer's perspective why UB exists and how it enables optimization.

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.

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

Paul Biggar's Google Tech Talk on compiling and optimizing scripting languages, drawn from his work on the phc ahead-of-time PHP compiler. He covers runtime typing, aliasing and code generation challenges, and argues AOT can compete with JIT.

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.

Jan Vitek of Northeastern University gives a meetup talk on the challenges of making the R language run fast. He explains what in R's semantics makes it hard to optimize and to build a JIT compiler for.

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.

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.

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.

Casey Muratori's first refterm lecture lays out philosophies of optimization, distinguishing optimization from non-pessimization, which means avoiding needless work. It uses his fast terminal renderer project to show how fast computers really are.

Andrei Alexandrescu's ACCU 2016 talk previews material from his book on writing fast code, with a focus on optimization techniques such as sentinels and faster search.

Richard Feldman explains how pure functional languages can match or beat imperative ones on performance. Compilers can turn immutable code into in-place mutation, avoiding naive copying. The talk draws on his work on the Roc language.

Cliff Click, author of HotSpot's JIT compiler, shares hard-won advice for people writing virtual machines at the VMSS16 workshop. Topics include interpreters, JITs and performance lessons.

Emery Berger argues that performance is hard to measure and deliver on modern systems, showing how code layout and link order can swamp optimization effects. He presents tools that evaluate performance more reliably.

Ian Piumarta's 2007 Stanford EE380 lecture on building a dynamic programming environment from the ground up, from the Viewpoints Research Institute's work. It covers the design of a language and system with a recursive design, parsing through code generation, and the COLA architecture.

A talk by Yuri Iozzelli at a WebAssembly meetup on CheerpX, an x86 virtual machine running in the browser. It uses a JIT compiler that emits WebAssembly at runtime to run real native applications. It covers the architecture and demos such as porting a multiplayer C++ game.

Paul Phillips, a major Scala compiler contributor, gives a long talk on Scala collections and views, using it to critique Scala's design and direction.

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.

Christian Schafmeister presents CANDO at the 2016 European Lisp Symposium. It is a compiled Lisp-based language for designing macromolecules and nanoscale materials, built on the Clasp implementation of Common Lisp.

Jonathan Blow gives a formal, hour-long demo of his Jai compiler focused on the implicit context feature. The context carries things like allocators through a program without explicit parameter passing, and the talk walks through the code.

Christian Schafmeister presents lessons from six years of implementing Clasp, a Common Lisp compiler using LLVM as its backend that interoperates with C++. He explains handling a dynamic, memory-managed language on LLVM.

Chris Thalinger of Twitter describes the company's effort to run its Scala services on the Graal JIT compiler at Scala Days NYC 2018. It covers the performance gains Twitter saw and the work of running Graal in production.

Netflix engineer Drew Gallatin's EuroBSDcon 2022 talk quantifies the older FreeBSD optimizations that let Netflix serve web traffic at 800Gb/s, including TSO, LRO, VM page cache zones, asynchronous sendfile and unmapped mbufs.

Cliff Click of Azul Systems gives a Google Tech Talk on running Java business applications on a machine with about a thousand cores. He covers hardware and software codesign, including garbage collection hardware and the JIT.

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.

Andrew Adams, a Halide developer, presents the Halide language for image processing and tensor computation. The talk explains the separation of algorithm from schedule with illustrated examples of parallelism, locality and redundancy tradeoffs.

A 2023 LLVM Developers' Meeting keynote by Abdul Dakkak, Chris Lattner and Jeff Niu introducing Mojo, a Python-family systems language built on MLIR and LLVM for heterogeneous computing.

Chris Seaton talks about JRuby+Truffle, explaining how the Truffle and Graal combination optimises the tricky parts of Ruby and why it outperforms other Ruby implementations.

Robert Smith of Rigetti Computing talks at a Bay Area Lisp and Scheme meetup about using Common Lisp for quantum computing. He covers the technical, sociological and psychological sides of working across disciplines.

Andrew Kelley's 2024 Zig roadmap talk, followed by a Q&A, covers the language's priorities and the state of the project. Topics include compilation speed, moving off LLVM toward a self-hosted toolchain, async, and the path to 1.0.