hash tables

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.

Matt Kulukundis explains how Google designed SwissTable, a fast, cache-friendly hash table, step by step from std::unordered_map. The talk covers open addressing, SIMD probing and the tradeoffs of changing a fundamental data structure.

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.

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.

Python core developer Raymond Hettinger explains how Python's dictionary implementation evolved into the compact, ordered dict in Python 3.6. He uses pictures and small bits of pure Python, and covers key-sharing, compaction and versioning.

Shashi Tharoor's Oxford Union speech arguing that Britain owes reparations to its former colonies, focused on the effects of British rule in India. It lists economic and political damage done by colonialism.

Anders Brownworth gives a basic visual introduction to blockchain using an interactive web demo, covering SHA256 hashes, blocks, chains, distribution, tokens and coinbase transactions.

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 step-by-step animated explanation of how SHA-256 works, from padding and message schedule to the compression function and final hash, with source code for the animations.

Chandler Carruth's CppCon 2014 talk on writing fast C++, explaining why data structure choice and memory layout matter more than clever algorithms. It covers why standard containers like unordered_map perform poorly on modern CPUs.

Mitchell Hashimoto walks through his setup for running a NixOS virtual machine on a Mac as his development environment, with a config repo on GitHub.

Isao Hashimoto's time-lapse map shows all 2053 nuclear explosions between 1945 and 1998, with each nation getting a blip and a running tally. Each second represents one month.

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.

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.

A reupload of Joel Spolsky's talk teaching spreadsheet users the Excel features they are probably missing, such as keyboard navigation, named ranges, tables and lookups. The original disappeared and this copy comes from the Wayback Machine.

Mathologer shows how times table diagrams on a circle produce cardioids and other curves connected to the Mandelbrot set. He explains the patterns and links to a tool for making your own diagrams.

3Blue1Brown illustrates how enormous the 256-bit search space is, showing how infeasible it is to find a hash or key by guessing and checking.

Mobileye co-founder and CTO Amnon Shashua explains what goes into sensing for autonomous driving and whether end-to-end deep learning can work for it. He argues for decomposing the problem.

Reducible's visual walkthrough of the Fast Fourier Transform, motivated by polynomial multiplication. It shows how the FFT's key ideas can be discovered by asking the right questions.

Juan Pedro Bolivar Puente explains immutable and persistent data structures in C++ and how they support value semantics. He presents the Immer library, rrb-trees, and a prototype text editor that opens a huge file instantly.

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.

CGP Grey compares airplane boarding methods, based on an arXiv paper, and shows why the intuitive back-to-front approach is slow while random or outside-in boarding does better.

Tom Scott-style absurdist tour by Tom7 of SIGBOVIK chess projects: a tournament of 30 weird chess algorithms used to rate a color- and piece-blind chess program. Topics include mirrors, arithmetic encoding, perverted game tree search and a diluted Stockfish.

Dave Ackley demonstrates the Demon Horde Sort, an inherently robust sorting machine running in his Movable Feast Machine simulator. This is the uncut version with all details and side thoughts.

Donald Knuth's 2017 Christmas Tree Lecture at Stanford about a combinatorial geometry problem whose computed numbers matched a striking formula. He tells the story of the conjecture and its sequel.

A Dyalog demonstration of developing a Sudoku solver in APL, using an algorithm by Arthur Whitney with performance work by John Scholes. The narration steps through the array-oriented solution.

A feature-length Defunctland documentary on the history of Disney's FastPass and FastPass+ expedited queue systems. It covers how the systems evolved and how they were designed, with simulation of their effects on park lines.

Lee Byron of Facebook explains how persistent immutable data structures work and how to use them in React apps with Immutable.js. He covers memoization benefits and avoiding coupling through shared mutable state.

James Long's dotJS 2019 talk on how CRDTs enable local-first apps and how simple they can be to implement. He shows how to use them to build robust offline-capable frontends.

Guy Steele presents a small geometric problem and compares four computational approaches: a classic sequential solution and three parallel-friendly ones. Each is illustrated pictorially and with working code, weighing total work against time to solution.

Martin Kleppmann's QCon London 2018 talk on keeping data consistent in distributed systems without a central leader. It surveys CRDT algorithms for syncing devices and collaborative editing over peer-to-peer networks.

John Scholes builds a depth-first tree-search operator step by step in a Dyalog APL session. It covers higher-order functions and runs the search on the N-Queens problem.

A JSConf 2014 talk visually breaking down algorithms behind everyday UI patterns, such as dropdown menus that vanish when the mouse drifts and picking the nearest target to the cursor. It shows how these are implemented in JavaScript.

Erik Demaine's MIT 6.006 lecture introducing dynamic programming through Fibonacci numbers and shortest paths. It covers memoization, subproblems and optimal substructure.

A visualization and sonification of 15 sorting algorithms, from selection sort to bogo sort, run on shuffled integers in six minutes. Each algorithm gets a size and speed scaled to its complexity.

Two Google engineers perform a mock coding interview and then discuss best practices for candidates, including asking clarifying questions and communicating while solving.

Veritasium tells the story of the Fast Fourier Transform, from its use in detecting nuclear tests to Cold War politics, and how it could have changed the arms race. It includes a short, intuitive explanation of what the Fourier transform does.

Sean Parent's CppCon 2015 talk on better use of standard containers and the goal of having no incidental data structures. It argues that proper containers can greatly simplify code.

Redis Labs and Tim Davis present RedisGraph, which uses GraphBLAS to treat graph queries in Cypher as sparse linear algebra for lower latency.

Martin Donald explains the Wave Function Collapse algorithm using Sudoku-like constraint solving and shows how he implemented it with Blender and Godot. It links demos and reference articles.