Algorithms

Algotree: Algorithm and Data Structure Reference

Algotree is a reference site for algorithms and data structures with implementations in Python, Java, C++, and Go — covering sorting, graph traversal, dynamic programming, and more. Targeted at students, interview prep, and developers filling knowledge gaps.

pytudes: Peter Norvig's Python Skill-Building Programs

Peter Norvig's collection of Python programs of "considerable difficulty" designed to perfect specific programming skills — a curated library of well-crafted exercises in algorithms, puzzles, and problem-solving by one of the most respected programmers alive.

A Generalist Neural Algorithmic Learner

CRDT: Fractional Indexing

Evan Wallace's visual explainer of fractional indexing as a CRDT technique for ordered lists — items get floating-point positions between existing neighbors. A clean conceptual foundation for understanding how collaborative list ordering works without central coordination.

Notes on Theory of Distributed Systems

James Aspnes's freely-distributed lecture notes on the theory of distributed systems, covering fault tolerance, consensus, synchrony models, and randomized algorithms. A rigorous but accessible graduate reference that grounds distributed computing in formal models.

Algorithms and Data Structures for Massive Datasets

Manning 2021 textbook covering algorithms and data structures built for massive datasets — Bloom filters, HyperLogLog, Count-Min Sketch, LSH, and streaming algorithms. Practical treatment of how to handle data that won't fit in memory or where exact answers are too expensive.

Advanced Algorithms and Data Structures

Marcello La Rocca's Manning textbook on advanced algorithms and data structures, organized around practical problems like caching, nearest-neighbor search, clustering, and graph planarity. A useful reference for engineers who have outgrown intro-level algorithms and need principled solutions to real design challenges.

Patterns to Ace Coding Interviews

A pattern-based framework for coding interview preparation — reduces hundreds of LeetCode problems to ~20 recognizable patterns. Knowing which pattern applies is usually harder than solving once the pattern is identified.

What's a Linked List, Anyway? (BaseCS)

The first part of Vaidehi Joshi's BaseCS series on linked lists — a beginner-friendly explanation of singly and doubly linked lists with illustrations. Part of a comprehensive CS fundamentals series written for self-taught developers.

Algorithms for Modern Hardware

A free online textbook on algorithms for modern hardware — covers SIMD, cache optimization, branch prediction, and CPU microarchitecture from a performance engineering perspective. One of the most practical resources for writing truly fast code on real hardware.

Zillow Did Not Have Metallic Balls

Steve Buccini's post-mortem on Zillow Offers dissects why Zillow's iBuying program failed — they were making a market in illiquid assets with a flawed pricing model and no mechanism to cut losses. A case study in the difference between algorithmic pricing and actual market-making discipline.

The Complete FAANG Preparation Repository

A comprehensive GitHub repository for FAANG interview preparation — DSA problems, technical subject theory (OS, DBMS, networking, OOP), and curated question sets. One of the large open-source interview prep aggregators.

Indexing 1,600,000,000 Keys with Automata and Rust

Andrew Gallant's deep technical post on using finite state transducers to index 1.6 billion keys in a compact data structure — the basis for ripgrep and the fst crate. A masterclass in how the right data structure unlocks orders-of-magnitude improvements.

Deterministic Aperture: Twitter's Load Balancing Algorithm

Twitter's Deterministic Aperture load balancing algorithm assigns each client a deterministic subset ('aperture') of backends, reducing connection fan-out while maintaining even load distribution. A principled alternative to round-robin and power-of-two-choices that scales better with horizontal expansion.

Using Python's bisect Module

A practical walkthrough of Python's bisect standard library module — binary search for maintaining sorted lists and efficient data binning. Covers two key use cases with code examples.

Gradient Boosted Decision Trees

An illustrated explainer of gradient boosted decision trees — how sequential weak learners correct prior errors by fitting residuals, and how this connects to gradient descent. Covers regression, binary classification, and multi-class variants.

Machine Learning from Scratch

Machine Learning from Scratch is a free online book deriving seven core ML algorithms from first principles — linear regression, logistic regression, naive Bayes, decision trees, ensembles, and neural networks. Mathematically rigorous, aimed at practitioners who want to understand how algorithms work mechanistically.

Labuladong Algorithm Book (English)

Labuladong's English-translated algorithm patterns book — a framework-first approach to competitive programming and interview preparation that teaches mental models for problem types rather than individual solutions. Popular for its emphasis on patterns over memorization.

Organic Towns from Square Tiles — Oskar Stålberg at IndieCade 2019

Oskar Stålberg's IndieCade 2019 talk on generating organic-looking towns from square tiles using a constraint-propagation algorithm. A beautiful demonstration of how simple local rules produce complex emergent structure.

Gradient Boosting Explained

Alex Rogozhnikov's interactive 3D visualization of gradient boosting — shows how decision boundaries evolve as the ensemble builds up trees. One of the cleaner intuition-builders for gradient boosting before XGBoost dominance made it feel like a black box.

Inconvergent: Generative Art by Anders Hoff

Anders Hoff's (inconvergent) generative art site — algorithmic drawings that simulate natural processes like erosion, growth, and diffusion. His work is notable for making mathematical processes legible as aesthetic objects.

Principles of Distributed Computing — ETH Zurich All-Stars

ETH Zurich's Principles of Distributed Computing lecture series — foundational theory covering consensus, fault tolerance, and distributed algorithms. The "all-stars" edition collects contributions from leading researchers in the field.

Model for Massively Parallel Computation — MapReduce Theory

Grigory Yaroslavtsev's theoretical treatment of MapReduce as a model for massively parallel computation — covering the MRC complexity class and what it tells us about which problems can be solved efficiently at scale.

Introduction to A*

Amit Patel's interactive introduction to pathfinding algorithms, building from breadth-first search through Dijkstra's to A* — the standard reference for understanding the A* algorithm's design rationale. The interactive diagrams make the tradeoffs between algorithms immediately tangible.

A Tour of Machine Learning Algorithms

Jason Brownlee's taxonomy of machine learning algorithms organized by learning style and similarity — a map of the algorithm space useful for orienting newcomers. The categorization gives a mental model for when to reach for which algorithm family.

Data in Practice

Data in Practice is a tutorial blog by Daniel Baumgartel covering coding, algorithms, data science, machine learning, and distributed computing — practical implementations with working code. A representative example of the practitioner-written technical blogs that shaped the 2014 data science self-education ecosystem.

HyperLogLog in Pure SQL

Periscope Data's post implementing HyperLogLog in pure SQL — a probabilistic cardinality estimator that counts distinct values using a fixed amount of memory regardless of dataset size. Clever engineering that demonstrates how probabilistic algorithms can be embedded in SQL-only environments.

Optimism in the Face of Uncertainty: the UCB1 Algorithm

Jeremy Kun's accessible treatment of the UCB1 algorithm — the principle of 'optimism in the face of uncertainty' formalized as a bandit algorithm with proven regret bounds. Shows why adding a confidence bonus to estimated rewards elegantly solves the exploration-exploitation tradeoff.

Understanding Multi-Armed Bandit Algorithms

DataBozo's conceptual explanation of multi-armed bandit algorithms — epsilon-greedy, UCB, and Thompson Sampling compared from first principles. Aimed at practitioners who want to understand the tradeoffs before implementing.

The Remarkable k-means++

Larry Wasserman's Normal Deviate blog post on k-means++ — the 2007 initialization trick from Arthur and Vassilvitskii that gives k-means an O(log k) approximation guarantee and better convergence in practice.

List of All Content — Grokit Computer Science Review

Grokit's computer science review list — a curated index of CS fundamentals topics for interview preparation and self-study. Covers algorithms, data structures, systems, and theory with links to resources for each topic.

Advanced Data Structures in Python

Pypix overview of advanced data structures in Python beyond the built-in list/dict/set — covering heaps, tries, segment trees, and other structures that Python's standard library either implements partially or not at all.

Advantages of Different Classification Algorithms

Quora thread on the tradeoffs between classification algorithms — naive Bayes, SVM, decision trees, logistic regression, k-NN, and neural networks. A practical reference for choosing the right algorithm given your data characteristics and constraints.

ISchool 296A: Data Science Algorithms (Berkeley Spring 2012)

UC Berkeley's iSchool 296A course on Data Science Algorithms from Spring 2012 — one of the early university data science courses before the field had a standard curriculum. Represents Berkeley's role in formalizing data science education.

SeqAlign: Sequence Alignment Visualization

SeqAlign is a browser-based DNA/protein sequence alignment visualization tool by Chris Fenton. A clean interface for a foundational bioinformatics algorithm — useful for understanding how pairwise alignment works visually.

Random Forests Algorithm

An introduction to the Random Forests algorithm — explaining how ensembling many decorrelated decision trees reduces variance and produces a robust classifier. A standard explainer from the Data Science Central era.

Uber Challenges on Talentbuddy

A set of Uber-branded coding challenges on Talentbuddy, an early technical hiring platform. Saved in September 2013 — likely for interview practice while at Zipfian Academy, targeting data engineering or software engineering roles at Uber.

8 Awesome Books on Algorithms & Big Data

A 2013 roundup of eight books on algorithms and big data — a snapshot of the canonical reading list practitioners were recommending at the start of the data science hiring boom. Most of these titles held up as long-term references.

Interactive Big Data Analysis Using Approximate Answers

O'Reilly Strata coverage of approximate query processing for interactive big data analysis — using sketches and sampling to get fast approximate answers over large datasets when exact computation is too slow. An important design pattern for data products that prioritize responsiveness over precision.

Sorting Algorithms Are Mesmerizing When Visualized

Gizmodo's coverage of a visualization showing 15 different sorting algorithms in motion — the classic side-by-side comparison of bubble sort, quicksort, merge sort, and others that makes their behavioral differences viscerally apparent. A perennial teaching tool.

Big-O Notation Explained by a Self-Taught Programmer

A self-taught programmer's accessible guide to Big-O notation — explaining time and space complexity from first principles without assuming a CS degree. A good on-ramp for practitioners who need to reason about algorithm performance.

Jeff Erickson's Algorithms Course Materials

Jeff Erickson's algorithms course materials from UIUC — lecture notes covering data structures, graph algorithms, dynamic programming, and computational geometry. Freely available and widely regarded as among the clearest algorithm teaching materials available online.

Mining of Massive Datasets (Stanford)

The Stanford textbook by Rajaraman and Ullman on algorithms for mining massive datasets — locality-sensitive hashing, PageRank, collaborative filtering, stream algorithms, and more. Freely available online and a standard reference for large-scale data algorithms.

Aho/Ullman Foundations of Computer Science

The classic undergraduate CS foundations textbook by Alfred Aho and Jeffrey Ullman, freely available from Stanford. Covers data structures, algorithms, automata, and the mathematical foundations underpinning computer science as a discipline.

Machine Learning Cheat Sheet

Emanuel Ferm's machine learning cheat sheet — a compact reference covering the main supervised and unsupervised learning algorithms with notes on when to apply each. A quick-reference for practitioners who know the algorithms but want a memory aid for their properties.

Solving Google Treasure Hunt Puzzle 4: Prime Numbers

Peteris Krumins' solution to Google Treasure Hunt Puzzle 4 — find the smallest prime expressible as the sum of 7, 17, 41, and 541 consecutive primes simultaneously — solved pragmatically by downloading a pre-computed prime dataset and using Unix pipes instead of writing a sieve.

A Thousand-Foot View of Machine Learning

A high-level orientation to machine learning from 2009 — the major paradigms (supervised, unsupervised, reinforcement), the core families of algorithms, and when to apply each. A useful framing piece for someone entering the field.

The True Power of Regular Expressions

Nikita Popov's deep dive into what regular expressions can theoretically do — connecting regex to finite automata and formal language theory. Goes beyond syntax tutorials to explain why backtracking regex engines can be exponentially slow, and how to avoid it.

What Does O(log n) Mean Exactly?

A Stack Overflow answer explaining O(log n) complexity with a highly upvoted intuitive explanation using binary search. The 'halving' intuition — each step eliminates half the remaining problem space — is the cleanest way to build the mental model.

Modern GPU

Sean Baxter's moderngpu library — a CUDA toolkit providing high-level primitives (sort, reduce, scan, join) for GPU programming. Published by NVIDIA Research, it demonstrated that expressive, composable GPU programming was achievable without sacrificing raw throughput.

Math ∩ Programming Primers

Jeremy Kun's Math ∩ Programming blog primers page — a growing collection of self-contained posts bridging undergraduate mathematics (linear algebra, group theory, topology, probability) and programming. The best resource for programmers who want mathematical depth without a full course sequence.

MapReduce Patterns, Algorithms, and Use Cases

Ilya Katsov's comprehensive taxonomy of MapReduce design patterns — from basic counting and filtering through complex join strategies and graph algorithms. The field guide for wringing correct and efficient computation out of the MapReduce model.

HFT — High-Frequency Trading

Scarce Capital's explainer on high-frequency trading — how co-location, order types, and microsecond latency advantages let HFT firms extract value from modern equity markets. A critical but fair-minded overview of a frequently misunderstood practice.

Locality-Sensitive Hashing

Locality-sensitive hashing (LSH) is a family of algorithms for approximate nearest-neighbor search — hashing high-dimensional vectors so that similar items hash to the same bucket with high probability. The practical solution to similarity search at scale when exact methods are too slow.

Probabilistic Data Structures for Web Analytics and Data Mining

The Highly Scalable Blog's comprehensive survey of probabilistic data structures for web analytics — Bloom filters, HyperLogLog, Count-Min sketch, and MinHash explained with their trade-offs. The standard reference for understanding when to trade exactness for speed and memory.

Coding for Interviews — Book Recommendations

Coding for Interviews was a weekly newsletter and book-recommendation site for software engineering interview preparation — curating the canonical algorithm and data structure books used in technical interviews at top tech companies.

Markov Chains: The Sad Case of Mr. Markov and What's His Face

A practical JavaScript tutorial on Markov chains for text generation — building a next-word predictor from a corpus. A good introductory implementation of a probabilistic sequence model that predates the LLM era by a decade.

Google PageRank: Implementation

A practical explainer on implementing the original Google PageRank algorithm — walking through the iterative link-analysis computation from the Brin/Page paper. Saved when learning graph algorithms and search engine internals.

How to Implement an Algorithm from a Scientific Paper

Emmanuel Goossaert's guide to the specific challenges of implementing an algorithm from a research paper — reading notation, handling undefined edge cases, bridging the gap between mathematical description and working code. Practical advice for a surprisingly common problem.

Algorithms — Dasgupta, Papadimitriou, Vazirani

The free PDF of 'Algorithms' by Dasgupta, Papadimitriou, and Vazirani — Berkeley's undergraduate algorithms textbook. Unusual for a CS textbook in being readable, mathematically rigorous, and freely available from the authors.

Software Development Final Exam Answers: Part 1

Colin Percival grades a software development final exam and finds most developers can recall what data structures do but not why they're useful in specific contexts — the gap between memorization and understanding. Average score: 15.2/25.

Flocks, Herds, and Schools: A Distributed Behavioral Model

Craig Reynolds's 1987 SIGGRAPH paper on Boids — the three-rule algorithm (separation, alignment, cohesion) that produces realistic flocking behavior from local agent interactions alone. One of the most cited demonstrations that complex group behavior emerges from simple rules, not central coordination.

Writing Lock-Free Code: A Corrected Queue

Dr. Dobb's article on writing correct lock-free code using a corrected queue implementation. Lock-free data structures are famously difficult to get right — this piece walked through the subtle bugs that make naive implementations incorrect.

Get That Job at Google

Steve Yegge's definitive guide on how to prepare for and pass Google software engineering interviews, written in 2008 and widely read through the 2010s. The advice is brutally practical: most candidates fail because they stopped practicing algorithms and data structures after college.

MIT 6.046: Introduction to Algorithms — Demaine Lecture 2

Erik Demaine's second lecture from MIT 6.046 (Introduction to Algorithms, Fall 2005) on videolectures.net. Demaine is one of the most celebrated algorithm teachers at MIT, and 6.046 covers divide-and-conquer, dynamic programming, and fundamental complexity results.

Suffix Trees in Computational Biology

A course page on suffix trees in computational biology from the University of Saskatchewan. Suffix trees are the data structure behind fast substring search in genomic sequences — O(n) construction, O(m) query — making genome-scale string matching tractable.

A High Frequency Trader's Apology, Pt 1

Chris Stucchio's defense of high-frequency trading — arguing HFT provides liquidity and tightens spreads rather than front-running retail investors. A careful, data-driven pushback against the popular villain narrative.