It is HN's standard answer to why Python cannot easily get much faster, and is recommended by people who work on JITs and alternative runtimes.
Topics › Software Engineering & Languages
The best software performance & optimization videos, according to Hacker News
120 videos about software performance & optimization that Hacker News commenters keep pointing each other to, ranked by how many separate months they were recommended. Part of Software Engineering & Languages.
HN repeatedly recommends it as an entertaining, mind-opening talk on allocator design and composable generic programming.
It is the standard link in HN threads about software decay, lost knowledge and fragile technological civilization.
It is the standard recommendation for anyone puzzled by unexplained benchmark changes from tiny code edits, and for learning about causal profiling.
HN recommends it, long as it is, as an eye-opening rant on software complexity and why systems became so complicated.
HN repeatedly cites it as the definitive explanation of SwissTable, the design behind Abseil, Rust's hash map and Go's maps.
The go-to talk showing how Erlang let a tiny team run a massive messaging system.
It is one of the most frequently recommended videos on HN for old-school game development hacks under tight hardware constraints.
The canonical recommendation whenever percentiles, tail latency, load testing or averages come up, described by some as life changing.
HN returns to it constantly in software performance debates as the primer on non-pessimization and why modern software is slow.
It is the go-to talk HN points to for data-oriented design and hardware-aware performance thinking, despite Acton's blunt style.
HN commenters recommend it for its source-based history of OOP, though some dispute its account of Alan Kay.
A perennial recommendation for anyone learning performance optimization, cited whenever hash tables, cache behavior or STL containers come up.
It is the canonical reference for the claim that modern software wastes hardware, and the proof-of-concept behind the Windows Terminal performance debate.
HN loves the deep, hands-on look at N64 hardware quirks such as bus contention and the surprisingly large wins from low-hanging optimizations.
HN people recommend it to anyone wanting a practical sense of what CPUs can really do and why abstraction layers cost so much performance.
HN commenters cite it whenever zero-cost abstraction claims come up, especially for why unique_ptr is not free on some ABIs.
HN treats it as the classic go-to for learning atomics and memory ordering, recommended over books.
HN recommends it as an entertaining talk that starts simple and goes deep on practical performance optimization.
HN treats it as the best primer on the event loop, praising its entertaining, easy-to-grasp visual explanations.
HN regards it as one of the best technical talks, a deep and clear walkthrough of scalable lock-free hash tables built on compare-and-swap.
HN repeatedly points people to it as the best overview of low-latency trading engineering.
Recommended as the clearest explanation of why immutable data need not be slow, and as the introduction to Roc.
HN recommends it as a fascinating explanation of queues, flow control and overload that applies well beyond Clojure.
HN recommends it, and Cliff Click's talks in general, as practical wisdom from someone who built HotSpot and worked on Azul's VMs.
The default reference in Python performance threads for why removing the GIL is hard.
HN cites it as one of the best talks on data-oriented design, applying struct-of-arrays and compact data layouts to a real compiler.
A frequent citation in debates about SOLID and Clean Code, representing the performance-first side of the argument.
HN commenters cite it as the clearest case for why mobile devices are slow and why code-splitting and progressive web apps are needed.
HN points to it whenever benchmarking pitfalls and layout effects come up, as an eye-opening talk on how unreliable naive measurements are.
The canonical recommendation for understanding the GIL, praised both for its clarity and for how well it explains a deep technical topic.
Pointed to as the in-depth talk on exception mechanics and code size for embedded C++.
HN points to it as the clearest frontend explanation of why McMaster-Carr feels so snappy, often contrasted with slow modern UIs.
Recommended as the clearest explanation of Halide's ideas and of scheduling for performance.
HN points to it as proof that a small, straightforward renderer can beat Windows Terminal on speed and memory, whenever software slowness comes up.
HN returns to it as the go-to talk on string internals, small string packing and why small percentage optimizations matter at scale.
It is the go-to viral demo whenever HN discusses vibration, acoustic attacks, or sound affecting hard drives.
HN points to it whenever undefined behavior comes up, as the best explanation of the reasoning behind UB, though some dispute its framing.
Recommended as the best presentation on how modern CPUs run code, and why speculative execution matters for performance.
HN calls it a surprisingly fun, approachable talk on a hard problem and cites it in floating-point threads.
HN recommends the series as a thorough look at low-level game programming by someone with deep knowledge, offered free.
Recommended for explaining why Python is hard to optimize and the limits of making it fast.
HN points to it as the go-to explanation of why memory layout beats pointer-chasing structures on real hardware.
HN recommends it as an exciting look at how a browser can be rebuilt for performance and safety, including the WebRender ideas that fed into Firefox Quantum.
A favorite tech talk on HN for showing that hardware knowledge and generalist skills beat simply adding machines.
Recommended as a fascinating technical account of the optimizations behind uv's speed.
Used as evidence that CPU speed for branchy, dependent code has improved only modestly in 15-20 years, so software optimization matters.
HN recommends it as a detailed, entertaining look at the crazy optimizations compilers do.
HN recommends it as an eye-opening primer on benchmarking and performance analysis, especially for people who have not benchmarked on Linux.
HN recommends it as an approachable explanation that makes the famous algorithm finally make sense.
Praised as solid, research-backed advice on front-end web performance.
Recommended in cache-algorithm threads as a fun, informative walk through caching strategies and ARC.
HN commenters cite it as the canonical concrete demonstration that modern developer tools got slower despite vastly faster hardware.
HN points to it as the best explanation of why R is so hard to optimize, often paired with talks on Python and used to explain what makes Julia fast.
Recommended as an accessible refresher on how modern hardware and caches affect software performance.
HN lists it among good resources on building text editors and as a recommended lunch-and-learn talk.
Recommended in Julia threading threads as an insightful, simple explanation of the new task scheduler.
Recommended as a great talk on solving fragmentation for C/C++ and runtimes like Ruby and Python without code changes.
HN recommends it as a striking example of high-performance tree handling with array programming.
Recommended as a classic JavaScript performance talk whose fundamentals about reflow and efficient code still apply.
The go-to reference for why file operations are slow on Windows and how antivirus filters, not NTFS itself, are the cause.
Recommended as a quick, clear overview of allocators and arenas that also shows how Zig approaches allocation.
HN points to it as the best explanation of simdjson internals and of why fast parsing is rarely disk-bound.
HN cites it as a concrete, worked example of data-oriented design and as an alternative to OOP in performance-sensitive code.
HN commenters call it among the best talks of 2020 for understanding Haskell effect systems.
HN admires it as a creative hack and cites it as the inspiration for later tiny-game and QR-code projects.
HN recommends it as a history and analysis of the end of scaling from a well-regarded systems speaker, and lists it among the best talks of 2019.
Recommended as a clear, practical introduction to atomics and lock-free programming in C++.
HN recommends it for Carmack's detailed engineering insight into VR rendering and latency challenges.
Cited for showing how Julia's metaprogramming can beat C and Fortran, along with sound advice not to overuse it.
Recommended as a good watch on how Go's M:N:P scheduler works and why it was designed that way compared with alternative schemes.
HN points to it as the recorded talk behind the Netflix 800Gb/s slides and as a deep look at kernel-level optimizations for high throughput.
Pointed to as evidence that Java can do fast, cheap message-passing concurrency, as an alternative to Erlang or Scala actors.
Cited as evidence that DOM access is not the bottleneck for WebAssembly, and as an explanation of signals-based updates versus virtual DOM.
HN shares it as a concise critique of OOP from a respected systems programmer.
HN points to it as the authoritative talk on Swiss tables, their design rationale, and real-world effects like Hyrum's law.
HN points to it as a practical example of solving a tricky multithreading problem, including using a spinlock to speed up a real-time physics solver.
It is cited as evidence that text scrolling on late-80s hardware was smoother than in many modern editors.
Recommended as a thorough, well-regarded explanation of hash table design tradeoffs and why the standard container is a poor choice.
Used in software bloat debates as a measured look at why binaries got larger.
HN recommends Berger's talks as fascinating and cites Mesh as mind-blowing memory allocator work.
Pointed to as the authoritative source on Go's GC pause improvements, and later revisited when GC latency claims were challenged.
HN recommends it for specifics on how Truffle and Graal achieve strong dynamic-language performance.
Cited as the primary source on React with a custom rendering backend and on Netflix's Gibbon engine.
Recommended for treating benchmarking and profiling scientifically rather than by myth, with innovative tools.
Commenters cite it as the authoritative source for why the port is faster and why Go was chosen.
HN points to it as a detailed, captivating talk by the Noria author, including a good explanation of deduplicating data between maps using unsafe.
HN uses it as concrete data in game engine debates, showing a custom engine far outperforming Unity at several times the effort.
Cited in discussions of sine implementations and whether lookup tables beat computation on memory-bound hardware.
HN recommends it as a careful, entertaining talk on low-level optimization that shows how textbook algorithms can be sped up.
HN points to it as a concrete demonstration of object-oriented versus cache-friendly design and the performance effects of branch misprediction.
It is the go-to explanation of how CPython's JIT works and why its design is so simple.
HN points to it as the practical demonstration of data-oriented design, including structure packing and switching between AOS and SOA.
Held up as the peak of demoscene hardware hacking, especially for its finale and for how good the PC speaker sound gets.
HN commenters cite it as a sharp critique of SOLID, Clean Code and 'non-pessimized' programming, and as context for why software is getting worse.
Cited as a fun, unconventional example of neural networks built from floating point error.
Pointed to as the original talk by the author of the SIMD-in-JavaScript proposal, whenever SIMD on the web comes up.
Cited in discussions of software getting slower and of efforts to reduce friction in programming.
Pulled out in threads about declining software quality, though some commenters distrust Blow's claims about game and web development.
HN uses it as the go-to link to warn people not to trust UserBenchmark for hardware comparisons.
Cited as the evidence that Denuvo DRM measurably hurts game performance.
HN points to it as the explanation of how The Witness solved walking and collision.
Recommended as a recent take on rethinking compiler architecture, and cited in discussions of flattened ASTs and fast lexers.
Used as the reference example when people argue Windows UI responsiveness regressed after XP.
Cited as a fun example of how algorithmic changes can yield enormous performance gains.
HN lists it among C++ optimization talks and cites it for how much optimizer performance comes from inlining, from an experienced compiler engineer.
Brought up as the classic critique of web bloat whenever slow or heavy sites are discussed.
Cited in Rails performance and Rack design discussions for Patterson's analysis of stack depth and garbage collection.
Shared in discussions of useCallback and memoization as the first look at where React was heading with an auto-memoizing compiler.
HN cites it as the Netflix case for staying close to -CURRENT and upstreaming changes.
HN points to it as a real-world example of game engine multithreading and of safety annotations in C.
Cited in ZFS and filesystem threads as the go-to source on ZFS limits and tuning for NVMe.
Cited as the source for criticism of std::deque and move-constructor pitfalls, and as motivation to write custom data structures.
HN cites it as an example of workload-dependent performance tuning at scale and of Netflix's AWS practices.
It is cited for the cost of network round trips and mobile latency limits.
HN cites it as public evidence that Twitter ran GraalVM in production and saw significant performance improvements.
HN cites it as a prime example of FreeBSD tuned for extreme network performance at massive scale.
Cited as a deep dive on coroutines for cache misses and on running huge numbers of coroutines without heap allocation.
Used as a quick visual benchmark of the performance gain WebRender brings in Firefox and Servo discussions.
Mostly cited for its side-by-side rendering demo in Ember and React performance debates, not as a general recommendation.
Which of these have you already seen?
Connect YouTube and HackerTube AI hides what you've watched and ranks the rest for you.