compilers

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

Rick Hudson's GopherCon 2015 talk on Go 1.5's new low-latency concurrent garbage collector. It covers the motivation, performance numbers, technical challenges and why the approach fits Go.

Tikhon Jelvis's Compose Conference talk on using the Z3 SMT solver to analyze and verify programs, including checking invariants with bounded loops. He demonstrates verifying programs in a small language by compiling them to Z3.

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.

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.

Tom Dale explains the internals of the Glimmer VM, Ember's rendering engine, which compiles templates to opcodes. The talk includes a performance benchmark demo.

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.

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

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.

Ahmon Dancy of Franz Inc explains low-level programming in Common Lisp, including off-heap data structures used in AllegroGraph to manage memory outside the garbage collector.

Chris Lattner and Brennan Saeta present Swift for TensorFlow at the TensorFlow Dev Summit 2019, covering language-integrated automatic differentiation and tooling for machine learning in Swift.

An Apple WWDC24 session introducing Embedded Swift, a subset of Swift with no runtime that targets tiny microcontrollers. It demonstrates the idea on an off-the-shelf Matter smart home device.

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.