performance

A Netflix performance engineer presents how Netflix tunes EC2 instances, covering instance type choice, Xen modes, SR-IOV and kernel tuning. The goal is near bare-metal performance in the cloud.

Casey Muratori shows how typical 'clean code' object-oriented patterns can cost large factors in performance. He benchmarks them against simpler data-oriented code.

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.

Alex Russell's Chrome Dev Summit 2016 talk on building web experiences that work on slow, flaky networks and low-power devices. It argues developers should focus on the performance of real-world mobile hardware rather than desktop machines.

Chandler Carruth's CppCon 2016 talk on designing hybrid data structures for performance. He covers cache locality, working-set size and allocation overhead, and why standard C++ containers fall short.

Aaron Hsu shows how to manipulate and transform tree data in APL using arrays and inverted tables instead of pointers. He claims much smaller code, better performance and easier parallelisation.

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.

Jack Moffitt presents the architecture of Servo, Mozilla's experimental browser engine written in Rust, focusing on parallelism across cores, GPUs and SIMD and the safety properties gained from Rust.

A Google I/O 2013 talk by Android audio engineers on why reliable, low-latency audio is hard on the platform. It covers problem areas across the stack, platform work underway and techniques apps can use.

A full-length recording of Tom Lehrer's 1967 concert in Copenhagen, mixing his satirical songs with spoken comedy between numbers. It runs about 51 minutes with good audio for its age.

David Ditzel of Esperanto Technologies presents their massively parallel, energy-efficient RISC-V processors at the 7th RISC-V Workshop in 2017. It covers the high-performance many-core design aimed at machine learning.

Cliff Click walks through a small performance example on a modern out-of-order CPU. He covers pipelining, ILP, CISC vs RISC, multicore, and why cache misses and the memory subsystem dominate performance.

A 2009 Google Tech Talk by Nicholas Zakas on the hidden performance pitfalls of JavaScript. It covers what is fast and slow in the language and how to avoid common bottlenecks.

Casey Muratori responds on-stream to a dismissive Twitter post by demonstrating how slow Visual Studio's startup and debugger watch window are, comparing it to much older software and machines. It is a long rant about software performance and bloat.

Casey Muratori follows up his refterm proof-of-concept, a GPU-based terminal renderer, with a second part covering memory usage, glyph sizing and correct Unicode and VT handling. It is built to show that a terminal can be fast and correct without heroic effort.

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.

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.

Matt Godbolt builds a toy path tracer in C++ in three different styles and compares them on clarity, testability, compile time and run-time performance. The talk was given at CppCon 2019.

Aaron Patterson's RailsConf 2011 talk on Rails 3.1 performance, showing why deeper Rack middleware stacks slow Rails and how a shallower pipeline helps. It also touches on Rack API design.

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.

Ilya Grigorik of Google's Make the Web Fast team explains how to build a mobile site that appears on screen within one second. He covers the network and rendering constraints on mobile.

Casey Muratori shows how fast a terminal renderer can run, building a simple reference renderer that handles Unicode and colored text far quicker than Windows Terminal. He argues that common excuses for slow terminals do not hold up.

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

Steven G. Johnson, MIT professor and FFTW co-author, gives a JuliaCon 2019 keynote on metaprogramming and staged programming in Julia, showing how it enables high-performance numerical code and when not to use macros.

Jafar Husain of Netflix explains at React.js Conf 2015 how Netflix runs React-style rendering without the DOM on smart TVs and game consoles. It uses a canvas-like API for performance.

Nick Caston compares Unity's sample ECS/DOTS project (AngryBots) with his own from-scratch C++ and OpenGL clone. He benchmarks performance and discusses the effort involved in each approach.

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.

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.

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.

Ryan Florence's React.js Conf 2015 talk pushes React into unusual use cases, including a demo comparing rendering in React, Ember and Angular.

Armin Ronacher, creator of Flask, explains how CPython's internals and C API leak into the language's semantics. Using examples like the complexity of the add operation, he shows why Python is hard to optimize or reimplement.

Rick Reed of WhatsApp explains at Erlang Factory 2014 how the service scaled to billions of messages with a very small engineering team. He covers the FreeBSD and Erlang stack, Mnesia usage, server counts and bottleneck work.

Gil Tene of Azul Systems explains common pitfalls in measuring latency and response time, including why averages mislead and the problem of coordinated omission. He introduces open source tools like HdrHistogram for better measurement and reporting.

Chandler Carruth argues in a CppCon 2019 talk that C++ has no truly zero-cost abstractions. Using examples like unique_ptr, ABI constraints and compile-time costs, he shows that abstractions cost runtime, compile time or human effort.

Larry Hastings explains what Python's GIL is, what problems it solves and how it works, and presents his Gilectomy project to remove it, including the performance and C-extension obstacles.

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.

David Beazley's PyCon 2010 talk explains how the Python Global Interpreter Lock works and shows experiments where multithreaded code runs slower, even on more cores, due to lock contention and context-switching overhead.

Armin Ronacher's EuroPython 2017 keynote examining how the CPython interpreter's leaky abstractions affect language design and how Python could evolve, drawing on JavaScript and Rust experience.

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.