size optimization

Nicholas Ormrod's CppCon 2016 talk on how Facebook optimizes std::string with its open-source replacement fbstring. It covers storage layout tradeoffs, small string optimization and memory allocation behavior.

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.

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.

Kaze Emanuar searches for the best sine approximation for the Nintendo 64, comparing the lookup tables in Mario 64 and Ocarina of Time with polynomial alternatives. It walks through numerics and 3rd, 4th and 5th order approximations.

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.

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.

Dean Friedman's near-hour-long introduction to synthesis, covering the building blocks of sound and the controls on a synthesizer. He slowly adjusts knobs so viewers hear what each parameter does.

An Alan Kay talk on programming and scaling, covering theoretical limits of code size, engineering versus tinkering, and biological cells as inspiration for object-oriented design.

Barely Sociable presents a case that Bitcoin creator Satoshi Nakamoto is cryptographer Adam Back. It uses interview clips and circumstantial evidence, and also touches on the block size dispute.

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.

Huygens Optics shows through a laser interference experiment that the question of a photon's size is really about coherence length. It argues that photons exist as energy exchanges between radiation and matter, not as little particles in free space.

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.

A 30-minute condensed version of the documentary I.O.U.S.A., which examines the growing US national debt and its consequences.

In Ars Technica's War Stories, Naughty Dog co-founder Andy Gavin explains how the team squeezed Crash Bandicoot onto the original PlayStation. They overwrote Sony library code in RAM, built custom animation compression, and streamed assets around slow seek times.

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.

Not Just Bikes explains how SUVs and light trucks have grown in size and share of US sales, and why that is dangerous for pedestrians, cyclists and city life. He covers the regulatory loopholes, such as fuel economy rules and the chicken tax, that favored them.

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

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.

Peter Rizun and Andrew Stone present results of tests running 1 GB blocks on a Bitcoin test network at Scaling Bitcoin Stanford. The talk argues for big-block scaling and discusses its consequences.

Lukas Eder's Devoxx talk on how modern cost-based SQL optimizers rewrite and plan queries in ways developers would not expect. It argues that declarative SQL, used well, can run complex queries very fast.

MattKC fits a playable Snake game into a QR code by writing tiny x86 machine code and patching the ZBar scanner so it can run the decoded data.

Rusty Russell and Matt Evans examine why Unix utilities like ls and cat grew from a few kilobytes to over a hundred kilobytes. They take apart common tools to see where the growth comes from.

Christian Thalinger presents at the 2015 JVM Language Summit on adding ahead-of-time compilation to the JVM, covering the HotSpot team's AOT work and its relation to warmup and deoptimization.

3Blue1Brown visualizes high-dimensional spheres to explain a surprising puzzle about how a sphere fits in a box as dimensions grow. It builds geometric intuition for counterintuitive properties of high-dimensional space.

Guy Steele's classic 1998 OOPSLA keynote on how a programming language must grow with its user community. He delivers it in a playful style, starting with only monosyllabic words and defining new terms as he goes.

The first lecture of N J Wildberger's History of Mathematics course, starting with Pythagoras' theorem and following Stillwell's text. It emphasizes the flow of ideas over proofs.

Peter Thiel's lecture from the How to Start a Startup course on business strategy and monopoly theory, arguing that competition destroys profits and that startups should aim to build monopolies. It covers the ideas of Zero to One.

Vsauce's Michael Stevens takes viewers past infinity using transfinite numbers, ordinals and cardinals, with input from mathematician Hugh Woodin. It is a fast-paced, mind-bending tour of different sizes of infinity.

A 2018 GDC talk by NetherRealm's Michael Stallone on the engine changes, optimizations and tooling needed to roll back and re-simulate up to 8 frames in 16 ms in Mortal Kombat and Injustice 2. It is a deep dive into deterministic rollback netcode.

Patrick Boyle's deadpan account of Saudi Arabia's Neom and The Line megaproject, a planned 170 km linear city that has been scaled back to a fraction of its size. He covers the feasibility problems and the financing.

David Guillot describes how his team replaced a two-year-old React UI of their SaaS product with Django templates and htmx in a couple of months. The talk gives concrete indicators on code size, performance and team impact.

Paul Graham speaks at Startup School 2008 about how to create a successful startup. His talk emphasizes being good, not just avoiding being evil, as a strategic advantage.

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.

Derek Slager's Clojure/conj talk argues that ClojureScript is a pragmatic choice for web development. He addresses common objections, recent improvements, tooling and use cases where it shines.

An Isaac Arthur episode on arcologies, self-sufficient habitats that could house whole cities, on Earth or on harsh worlds. It covers how such structures might work and what limits their size.

A joint Erlang Factory 2016 keynote by Phoenix creator Chris McCord and Elm creator Evan Czaplicki on using the two together, including Phoenix.Presence design and PubSub optimizations.

Not Just Bikes argues that oversized American fire trucks and fire department requirements push cities toward wide roads and dangerous street design. He compares this with the Dutch approach to emergency response.

Luke Wagner of Fastly explains what a WebAssembly component is, how it relates to familiar concepts, and what the Component Model enables. It emphasizes security, composability and modularity.

Doug DeMuro reviews the Rivian electric delivery van built for Amazon, walking through its quirks, features and design innovations. It is a long, detailed tour of the vehicle inside and out.

Rik Arends presents Makepad, a Rust UI framework, at RustNL 2023. The talk covers designing modern, GPU-fast UIs with Rust and includes live-coded demos of an IDE and a synthesizer.