optimization

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.

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.

Charlie Marsh of Astral explains how uv, a Rust Python package manager, got so fast. He covers allocators, concurrency, zero-copy tricks and the challenges of Python packaging.

Casey Muratori's two-hour talk tracing the history of object-oriented programming back to the 1960s and examining how its ideas, and later entity component systems, came about. It is followed by a Q&A.

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.

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.

Khalil Estell's CppCon 2024 talk argues C++ exceptions can reduce binary size in firmware. He digs into how exceptions work and how to shrink their code footprint on embedded platforms.

Robert Collins explains why rustup installs were painfully slow on Windows and how changes to rustup and Windows cut install time from 3m30s to 14s. The talk covers NTFS, small files and the cost of antivirus hooks on file close.

A Zig SHOWTIME talk by Benjamin Feng on what a memory allocator is, followed by an interview. It covers allocation strategies and different allocator types in Zig.

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.

Alexis King's ZuriHac 2020 talk on how effect systems in Haskell can be implemented efficiently. It looks at the performance cost of effect libraries and how to reduce it.

Leptos creator Greg Johnston examines Rust/WebAssembly frontend frameworks against JavaScript frameworks using the JS framework benchmark. He argues that WASM is no longer too slow for DOM-heavy rendering.

Dennis Gustafsson, creator of Teardown, presents how he parallelized the physics solver for an upcoming game, followed by a Q&A. The talk was given at the Better Software Conference 2025.

Emery Berger's CppCon 2020 plenary on why performance is hard on modern hardware after the end of Dennard scaling. It covers benchmarking pitfalls and introduces new profiling tools for finding real bottlenecks.

A ten-minute clip from Jonathan Blow's talk on preventing the collapse of civilization, arguing that software quality and the knowledge to build it are in decline.

Casey Muratori's remastered BICFest 2018 talk on how the collision system of The Witness was engineered to prevent whole classes of bugs found in game engines. It covers character movement and collision handling.

Netflix engineer Drew Gallatin explains why the company runs FreeBSD-current on its CDN. He describes the team, how they track upstream, their contributions and performance milestones, and a bug causing a 20% performance regression.

Allan Jude of Klara presents work on making ZFS scale on fast NVMe storage, covering fixes to the TaskQueue interface and removal of bottlenecks. The talk was given at EuroBSDcon 2022 and describes raising write throughput from about 3 to over 7 GB/sec.

Netflix engineer Drew Gallatin explains how Netflix serves TLS-encrypted video at 400Gb/s from a single FreeBSD server. He covers NUMA, kernel TLS, hardware TLS offload and the memory bandwidth and PCIe bottlenecks they hit.

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.

Andrej Karpathy, then Tesla's head of AI, presents at ScaledML 2020 on how Tesla builds full self-driving using vision-based neural nets and fleet data collection. He covers training custom detectors and neural nets gradually replacing traditional code.

Andrej Karpathy gives a one-hour general-audience introduction to large language models, covering what they are, how they are trained, comparisons to operating systems, and security challenges such as jailbreaks.

Valve's John McDonald presents at GDC 2018 on how Valve uses deep learning (VACnet) to detect cheaters in Counter-Strike: Global Offensive. He covers training on human-reviewed replays and how model output is confirmed by manual review.

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.

Andrej Karpathy walks through how GPT assistants are trained, from tokenization and pretraining to supervised finetuning and RLHF, and gives practical prompting strategies and a view of the tooling ecosystem.

Andrej Karpathy, then Tesla's head of AI, gives a CVPR 2021 workshop keynote on how Autopilot's neural networks work. A large part covers the move to a vision-only stack, including why radar was dropped and how vision produces depth estimates.

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.

Tesla's full AI Day 2022 presentation, covering the Tesla Bot hardware and software, Full Self-Driving planning and perception, the occupancy network, data labeling, simulation and Dojo training infrastructure.

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.

Bill Dally of NVIDIA gives a Hot Chips 2023 keynote on the challenges of building hardware for deep learning. He traces how GPUs have been adapted for machine learning, especially training.

Jose Valim introduces Nx, the project bringing numerical computing to Elixir, covering multi-dimensional tensors, automatic differentiation and JIT compilation to CPU and GPU.

UC Berkeley EECS colloquium by OpenAI's John Schulman on reinforcement learning from human feedback. He covers why RL helps with truthfulness, hallucination, and the limits of behavior cloning.

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.

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

Jim Keller's talk at the 2020 Scaled Machine Learning conference on Moore's Law in the age of AI chips. He compares scalar, vector and GPU-style parallel approaches to computation.

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

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.

A React Conf talk by Xuan Huang previewing React Forget, a compiler that automatically memoizes components. It argues for making memoization the default so developers need not write useMemo or useCallback by hand.

Ilya Sutskever gives a Simons Institute talk on why neural networks generalize, framing learning as finding short descriptions, like compression. It was part of the Large Language Models and Transformers program.