efficiency

Bjorn Nyland compares wireless and wired DC fast charging for an electric car, measuring end-to-end efficiency. The test shows the wireless system holding up well against a plug.

Dave Ackley gives a high-level introduction to robust-first computing, which prioritizes robustness over efficiency in computer architecture. A sorting demo illustrates the idea.

Dr. Bruce Bugbee walks through the calculations for crop yield potential when light is the limiting factor, from photosynthetic quantum yield through respiration efficiency and harvest index, using the Energy Cascade Model.

A Stanford EE380 seminar by Michael P. Frank of Sandia National Laboratories on generalized reversible computing. It surveys unconventional computing approaches as transistor scaling nears its limits and energy efficiency stops improving.

Bill Dally of NVIDIA gives a University of Washington lecture on trends in deep learning hardware. It covers numeric formats, specialized instructions, energy per operation and co-design of hardware and software.

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.

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.

Vaclav Smil's talk on historic energy transitions and what they imply for climate investment. He argues that transitions are slow, technology improves gradually, and only absolute cuts in energy use would truly work.

Herb Sutter's deep C++ and Beyond 2012 talk on atomics and the C++ memory model, covering why programmers chasing top performance need to understand hardware ordering. This is part one of two.

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.

A 2007 Google Tech Talk in which Cliff Click of Azul Systems presents a lock-free concurrent hash table that scales to 768 CPUs. He explains why it is correct by reasoning in a different way than usual happens-before and memory-order arguments.

Zach Tellman's Clojure West talk covers the basics of queueing theory and its practical use in systems, including backpressure, how queues break down under load, and pitfalls of naive core.async use.

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.

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.

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.

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.

David Heinemeier Hansson explains what he learned about indoor air quality after his new house made his family sick. He covers CO2, VOCs, off-gassing, HVAC and ventilation, and cognitive effects, presented at a Basecamp meetup.

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.

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.

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.

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.

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.

Energy scholar Vaclav Smil argues that global energy transitions are slow and that renewable targets should not rest on wishful thinking. He appraises how energy dependencies are likely to change and asks for using much less.

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.

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 documentary from Swan Bitcoin exploring Bitcoin's relationship with energy, featuring Lyn Alden and others, and arguing that mining is a net positive for the environment and not wasteful.

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.

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.

Bryan Cantrill presents the ARC (Adaptive Replacement Cache) paper by Megiddo and Modha at Papers We Love. He opens with a survey of caching strategies before digging into the self-tuning LRU/MFU design.

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.

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.

Raph Levien presents Xi editor at RustConf 2016, a high-performance text editor built in Rust. The talk goes into technical details, building polished GUI apps, and running a community-focused open source project.

Dan Holohan, author of The Lost Art of Steam Heating, talks about the old steam heating systems he learned about from veteran tradesmen. He shares stories and practical lessons on how these systems work, including running steam at low temperatures.

Kiran Pamnany's Cambridge Julia Meetup talk on Julia's shared memory parallelism and its new task scheduler. It argues that fork-join and work-stealing models nest poorly and presents depth-first scheduling for composable parallelism.

Bobby Powers presents Mesh, a drop-in malloc replacement that eliminates memory fragmentation in unmodified C/C++ programs by compacting memory. The talk covers how it works despite C's fixed object addresses, and its benefits for programs like Redis.

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.

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.

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.