compilers

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.

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

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.

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.

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.

Lex Fridman's long interview with Chris Lattner, creator of LLVM and Swift, covering the future of computing and programming languages. It touches on compilers, hardware, and his work at Apple, Tesla, Google and SiFive.

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.

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.

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.

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.

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.

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.

Lex Fridman's long podcast conversation with Chris Lattner, creator of Swift, LLVM and MLIR and co-founder of Modular. Topics include the Mojo language, the future of programming and AI, and hardware.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Herb Sutter's CppCon 2015 plenary on writing safe, modern C++ by default using the C++ Core Guidelines. It includes a demo of lifetime-checking static analysis tooling.

Steve Yegge's Stanford seminar on GROK, Google's internal large-scale, cross-language source code analysis system. It covers how the system helps with code search and understanding across Google's huge codebase.

David Ungar of IBM Research reflects at Stanford on the Self language project and argues the real legacy of ideas is the people. He covers its history, philosophy, successes and failures.

Sasa Juric explains how to parse a language from first principles without regexes, live-coding a simple parser combinator library in Elixir. It was given at WebCamp Zagreb 2019.

Tsoding live-codes a JSON parser from scratch in Haskell in about 111 lines, using only the standard library. It is an edited Twitch stream that explains the intuition behind parser combinators, functors, applicatives and monads.

Christian Schafmeister's Google Tech Talk on Clasp and CANDO, a Common Lisp implementation on LLVM and C++ used to design molecules, including energy minimization and force-field calculations.

In a long live-coding session, Andreas Kling works on making the Cookie Clicker game playable in the Ladybird browser from SerenityOS. He tracks down bugs in the browser engine and fixes them.

Go runtime contributor Dmitry Vyukov looks inside the Go scheduler, explaining how goroutines and channels are implemented. He covers the main scheduler components and overall operation, then goes into details such as preemption and stacks.

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.

Part two of a Computer History Museum oral history with Gary Davidian, covering his work on the 68000 emulator for PowerPC at Apple, Power Computing, clean-room contracting and later performance optimization work. It is nearly three hours long.

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.

Lecture 7A from MIT 6.001 (SICP) by Abelson and Sussman introduces the metacircular evaluator, a Scheme interpreter written in Scheme. It shows how evaluating a program is itself a program.

Grady Booch interviews John Backus, who led the IBM team that created FORTRAN in 1957, for the Computer History Museum in 2006. Backus describes the development of the first successful high-level language and its compiler. The interview runs 88 minutes.