compiler optimization

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.

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 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.

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.

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.

Nicholas Ormrod's CppCon 2016 talk on how Facebook optimizes std::string with its open-source replacement fbstring. It covers storage layout tradeoffs, small string optimization and memory allocation behavior.

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.

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.

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.

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.

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.

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.

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.

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.

Rob Pike's GopherCon 2016 talk on the design of the Go assembler, explaining why Go uses a common assembly language translated to each architecture.

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.

Christian Thalinger presents at the 2015 JVM Language Summit on adding ahead-of-time compilation to the JVM, covering the HotSpot team's AOT work and its relation to warmup and deoptimization.

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.

Derek Slager's Clojure/conj talk argues that ClojureScript is a pragmatic choice for web development. He addresses common objections, recent improvements, tooling and use cases where it shines.

Kaze Emanuar searches for the best sine approximation for the Nintendo 64, comparing the lookup tables in Mario 64 and Ocarina of Time with polynomial alternatives. It walks through numerics and 3rd, 4th and 5th order approximations.

Matt Parker follows the community effort to speed up his slow Wordle-solving code, which ended up running hundreds of millions of times faster. He walks through the techniques contributors used.

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.

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.

Julia co-creator Jeff Bezanson candidly lists fundamental problems with the language at JuliaCon 2019, including modularity, types and compiler latency, and how they might be solved.

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.

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.

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.

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.

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.

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.

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.

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.

Julien Verlaguet of Facebook describes applying static analysis and type inference to a very large PHP codebase, using OCaml. The work led to the Hack language.

Daniel Lemire's QCon talk on how simdjson parses gigabytes of JSON per second. It covers SIMD vectorization, branch prediction and the lessons learned building a fast parser.

Timothy Baldridge presents Pixie, a lightweight Lisp built on RPython, at Strange Loop 2015. It covers C interop, immutable data structures, fast startup and async-by-default IO.