speed limits

Andrei Alexandrescu's CppCon 2019 talk revisits sorting, showing how branchless tricks, hybrid strategies and a cost metric can speed up std::sort-style algorithms on modern hardware.

David MacKay's TEDxWarwick talk uses basic arithmetic to show how much land and energy renewables would need to power a country like the UK. It explains the limits of sustainable options and why they should still be pursued.

Retired Major Brian Shul tells the story of a ground speed check with LA Center while flying the SR-71 Blackbird. He recounts it live at the Hiller Aviation Museum.

Spencer Lisenby explains dynamic soaring, a technique that lets unpowered radio-controlled gliders reach speeds above 835 kph. He covers the physics and the design, build and flying challenges.

A JuliaCon 2016 talk by Shashi Gowda showing an APL implementation in Julia. APL code is translated to Julia and JIT compiled to machine code.

Lars Bergstrom of Google presents how Rust improves team productivity beyond safety and speed, with data on rewrites, defects and review. It compares Rust teams to those on legacy native languages and Go.

Mirabai Knight's PyCon 2013 talk on Plover, a free cross-platform stenography engine that lets people write at up to 240 WPM on ordinary hardware, including a demo of coding by steno.

Jon Moore's Strange Loop 2017 talk argues that rate limiting is the wrong tool for protecting services from noisy clients. He proposes concurrency-based capacity management and quotas instead.

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.

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.

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

A JuliaCon talk by a NASA Launch Services Program engineer on modeling spacecraft separation dynamics in Julia. He describes replacing a Simulink-based workflow for checking launch vehicle separation requirements with Julia and ModelingToolkit, with large speedups and much shorter code.

Daniel Dunbar of Apple presents llbuild, a framework for building build systems, at the 2016 LLVM Developers' Meeting. He argues that the traditional way C compilers integrate with build systems limits compile speed, and proposes a new architecture.

Rob Pike's October 2009 Google Tech Talk introducing Go, a new experimental systems language designed for fast builds, concurrency and garbage collection. It covers the goals, syntax and type system.

Michael Steil's 33c3 talk explains essentially everything about the Game Boy: CPU, video hardware, peripherals, and the tricks used by games and demos. It revives the era of counting clock cycles around hardware limits.

Mike Acton of Insomniac Games argues that a program's purpose is transforming data, and shows how common C++ approaches work against that in performance-critical game development. He covers cache behavior, data layout and the limits of compilers.

Evan Czaplicki, creator of Elm, examines how programming languages are funded. He looks at where compiler engineers' salaries come from, why Go has about 5 engineers while Dart has about 30, and how this limits language design.

Joe Armstrong, co-inventor of Erlang, gives a funny and opinionated Strange Loop talk on the tangled state of software: build tools, package managers, entropy and the physical limits of computation. He argues for ideas like naming things by content hash and throwing away your first version.

Christopher Domas presents at Black Hat 2017 how page fault analysis and processor fuzzing can exhaustively search the x86 instruction set. The talk uncovers undocumented instructions and hardware bugs and shows limits of disassemblers.

Chris Urmson's SXSW 2016 talk on Google's self-driving car project, covering 1.3 million self-driven miles and the gap between hype and reality. It shows sensor visualizations and playbacks of hard situations the cars met, and discusses failures such as the low-speed bus collision.

Titus Winters' CppCon 2017 talk argues for C++ and Google's Abseil to be maintained as a live at head language, relying on testing and automated tooling rather than never changing or promising no compatibility. It covers Hyrum's law and the limits of semantic versioning.

Morphcat Games explains how they fit Micro Mages, a full-featured NES game, into 40 kilobytes. It covers compression of sprites and level layouts and other space-saving tricks.

Bryan Cantrill's Papers We Love talk on FreeBSD Jails and Solaris Zones, tracing how OS-level virtualization grew out of chroot and the limits of the traditional UNIX security model.

Herb Sutter's CppCon 2022 talk on whether C++ can become ten times simpler and safer. He introduces his experimental Cpp2 syntax and the cppfront transpiler, explaining the limits on incremental improvement.

Ian Hubert's Blender Conference talk on world building in Blender, covering photogrammetry, camera projection and assembling complex environments from simple shapes at great speed.

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.

X.Org developer Daniel Stone explains the history and technical limits of the X Window System and why Wayland was created, debunking myths from forum comments. He covers topics such as network transparency and blocking calls.

Ronald Minnich of Google explains how UEFI firmware is a large closed attack surface and describes Google's work replacing it with Linux-based boot firmware. It also touches on Intel ME and other security coprocessors.

Tristan Harris and Aza Raskin of the Center for Humane Technology present why current AI capabilities pose catastrophic societal risks. They argue companies are racing to deploy without adequate safety, and that institutions must adapt. It was given before GPT-4's launch.

Benno Rice's linux.conf.au 2020 talk asks whether UNIX was the best design we could have had. He looks at what alternatives existed, what was gained and lost, and what could be re-learned, including the limits of treating everything as a file.

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.

George Hotz of Comma AI gives a 2017 conference talk on lessons from building a self-driving system. He argues about how driving should be defined and why the common approach to autonomous vehicles is flawed.

Scott Meyers explains how CPU caches work and why they matter for performance, covering cache levels, access speeds, associativity, and effects in multithreaded code. The focus is C++ and cache-aware, data-oriented programming.

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.

Martin Kleppmann surveys current research on CRDTs, the algorithms for merging concurrent edits across offline replicas. He covers the hard parts such as rich text, moves and merge results that are technically correct but poor.

A long information session where The Boring Company presents its vision for Loop, an underground high-speed transit system, and the traffic problems it aims to solve. It includes discussion of faster tunnel boring and electrification.

Kathy Sierra's Fluent 2015 keynote on the one metaskill for developers: the ability to come up to speed quickly and stay there. She covers how people learn, cognitive resources versus willpower, and building skill.

John McCall of Apple's Swift team presents at CppNow 2023 on introducing a memory-safe successor language into large C++ code bases. He argues incremental improvement of C++ hits hard limits and explains Swift's C++ interoperability for gradual migration.

Bret Victor's talk from Dropbox's DBX conference about living by a guiding principle, in his case that creators need an immediate connection to what they are making. He shows live-coding and time-manipulation demos that let ideas take form at the speed of thought.

Kelsey Hightower introduces Kubernetes to sysadmins at PuppetConf 2016, with a demo. He explains the declarative model and how it changes the contract between infrastructure and applications.