performance optimization

Casey Muratori's first refterm lecture lays out philosophies of optimization, distinguishing optimization from non-pessimization, which means avoiding needless work. It uses his fast terminal renderer project to show how fast computers really are.

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.

A Google Tech Talk on Yahoo's 14 rules for faster web pages and the YSlow tool. It covers front-end practices like avoiding @import and fixing ETags, with live analysis of popular sites.

Malte Skarupke's C++Now 2018 talk on hash table performance, explaining why std::unordered_map is slow and memory hungry and presenting faster designs, including his bytell hash map.

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.

Andrei Alexandrescu's ACCU 2016 talk previews material from his book on writing fast code, with a focus on optimization techniques such as sentinels and faster search.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Matt Kulukundis reviews two years of Abseil's Swiss table hashtable, covering post-release optimizations, lessons from rolling it out across Google, design choices, and what global monitoring revealed.

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.

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.

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.

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.

A short Microsoft promo comparing classic Teams with the rewritten new Teams side by side, claiming faster startup and better performance. The new version is shown taking around nine seconds to launch.

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.

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.

Stephan T. Lavavej's CppCon 2019 talk on implementing floating-point to_chars and from_chars in Microsoft's C++ STL. It covers the history of float-string conversion and the algorithms that make it much faster.

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.

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.

The winning demo from Revision 2015's oldskool competition, running on a real 1981 IBM PC with CGA at 4.77MHz. It uses extreme tricks to produce effects, graphics and sound far beyond what the hardware was thought capable of.

John McCutchan of Google explains how Dart and the Dart VM expose SIMD instructions to speed up web software. He covers what SIMD is and how it applies to graphics and games.