Evergreen

Explainers

How things actually work — written to outlast the news cycle. These pages teach mechanisms, trade-offs, and history without assuming you already live inside the niche. For timely analysis, see News; for step-by-step how-tos, see Guides.

All explainers

  • How HyperLogLog and cardinality estimation work: distinct counts in fixed memory 7 Jun 2026 — Register arrays and leading-zero hash statistics, bias correction and HyperLogLog++, precision vs memory trade-offs (p=12/14/16), Redis PFADD/PFCOUNT/PFMERGE, mergeable distributed sketches, and when approximate distinct counts beat exact hash sets.
  • How the saga pattern and transactional outbox work: compensations, choreography, and reliable events 7 Jun 2026 — Why 2PC breaks in microservices, saga choreography vs orchestration, compensating transactions, transactional outbox tables and relay workers, at-least-once delivery with idempotent consumers, stuck-saga observability, and when sagas beat distributed commit.
  • How thread pools and worker pools work: queues, sizing, and backpressure 7 Jun 2026 — Fixed vs cached pools, bounded work queues, sizing for CPU-bound vs I/O-bound tasks (W/C heuristic), rejection policies, fork-join work stealing, pools vs event loops, graceful shutdown, and common production pitfalls.
  • How database replication and read replicas work: primary-follower, lag, and failover 7 Jun 2026 — Primary-follower topology, physical vs logical replication, sync vs async commit, replication lag and stale reads, read-your-writes routing, connection pool split, failover and split-brain prevention, and when replicas scale reads vs when they do not.
  • How dynamic programming and memoization work: overlapping subproblems and tabulation 7 Jun 2026 — Optimal substructure and overlapping subproblems, top-down memoization vs bottom-up tabulation, state design for knapsack and LCS, coin change and Fibonacci, space rolling arrays, pseudopolynomial time, when greedy beats DP, and production uses in alignment and allocation.
  • How cache replacement policies work: LRU, LFU, clock, and ARC 7 Jun 2026 — FIFO vs LRU vs LFU, clock and second-chance page algorithms, ARC adaptive caching, CPU L1/L2 eviction, OS page replacement and thrashing, Redis maxmemory policies, CDN edge caches, TTL vs size eviction, and matching policy to workload.
  • How backpressure and flow control work: queues, TCP windows, and reactive streams 7 Jun 2026 — Producer-consumer speed mismatch, bounded vs unbounded queues, TCP receive windows and HTTP/2 stream flow control, Node.js Writable drain events, Kafka consumer lag, reactive-streams demand signaling, and designing systems that slow producers instead of OOMing.
  • How checksums and error detection codes work: parity, CRC, and Hamming ECC 7 Jun 2026 — Parity and RAID XOR stripes, Internet additive checksum vs CRC-32 polynomial remainder, Hamming SECDED and SSD ECC, Ethernet FCS and TCP/IP checksums, ZFS block verification, checksums vs cryptographic hashes and MACs, and common offload pitfalls.
  • How sorting algorithms work: comparison sorts, stability, and O(n log n) 7 Jun 2026 — Quicksort partition and pivot selection, mergesort and heapsort, stable vs unstable ordering, counting and radix sort for bounded keys, introsort and timsort in production, cache locality, and the Omega(n log n) comparison-sort lower bound.
  • How idempotency keys and safe retries work 7 Jun 2026 — Why POST retries double-charge, Idempotency-Key header deduplication stores, at-least-once message delivery with idempotent consumers, natural keys for payments and webhooks, database unique constraints, and building effectively-once systems.
  • How Git version control internals work 7 Jun 2026 — Content-addressable blobs, trees, and commits; the staging index; branches as refs; merge vs rebase on a DAG; packfiles and garbage collection; remotes, fetch, and push; and why CI pins immutable commit SHAs.
  • How B-trees and B+ trees work: database index internals 7 Jun 2026 — Wide balanced nodes and shallow tree height for disk-friendly lookups, B-tree vs B+ tree leaf chains, splits and merges on insert/delete, clustered vs secondary indexes in InnoDB and Postgres, and comparison to hash maps, skip lists, tries, and LSM trees.
  • How vector clocks and logical timestamps work 7 Jun 2026 — Why wall clocks fail across datacenters, Lamport timestamps and happened-before, vector clocks for detecting concurrent writes, version vectors vs process clocks, hybrid logical clocks, Dynamo-style sibling conflicts, and pairing logical time with CRDTs or consensus.
  • How two-phase commit and distributed transactions work 7 Jun 2026 — Coordinator and participant roles, prepare and commit phases, blocking and partition failure modes, XA/JTA in databases, comparison to sagas and outbox patterns, and when Raft beats cross-service 2PC.
  • How tries and prefix trees work: autocomplete, routing, and radix trees 7 Jun 2026 — Trie node layout and child maps, insert and exact lookup, prefix search and autocomplete, longest-prefix match for IP routing, Patricia/radix compression, memory trade-offs vs hash maps, and production uses in search and DNS.
  • How public key cryptography works 7 Jun 2026 — Key pairs, RSA and elliptic curves, Diffie-Hellman and ECDHE, digital signatures (ECDSA, Ed25519), PKIX certificates, Solana wallet authorization, hybrid TLS design, and post-quantum migration basics.
  • How memory allocators work: malloc, free lists, and jemalloc 7 Jun 2026 — Stack vs heap, glibc malloc chunks and bins, internal and external fragmentation, thread caches and arenas, jemalloc vs tcmalloc, brk vs mmap, why RSS stays high after free, and pairing allocators with virtual memory and GC.
  • How regular expressions and finite automata work 7 Jun 2026 — NFAs and DFAs, Thompson construction and subset conversion, backtracking vs DFA engines, greedy quantifiers, catastrophic backtracking (ReDoS), capture groups vs regular languages, and when to use a real parser instead.
  • How data serialization formats work: JSON, Protobuf, MessagePack, and Avro 7 Jun 2026 — Text vs binary encoding, schema-first vs schemaless, protobuf field tags and varints, Avro reader/writer schema evolution, MessagePack trade-offs, money as integers, and how to pick a format for APIs, Kafka, and caches.
  • How heaps and priority queues work 7 Jun 2026 — Binary heap invariants and array indexing, sift-up and sift-down, O(n) heapify, lazy decrease-key for Dijkstra, d-ary and Fibonacci heap trade-offs, and where priority queues power schedulers, merge-k streams, and top-K analytics.
  • How database query execution plans work 7 Jun 2026 — Parse trees to physical operators, sequential scans vs index seeks, nested-loop vs hash vs merge joins, cost models and cardinality estimates, reading EXPLAIN ANALYZE, and a practical workflow for fixing slow production queries.
  • How HTTP/2 and HTTP/3 work 7 Jun 2026 — Binary framing and stream multiplexing, HPACK header compression, TCP head-of-line blocking limits, QUIC over UDP, 0-RTT resumption, connection migration, and when HTTP/3 beats HTTP/2 on lossy mobile links.
  • How graph algorithms work: BFS, DFS, and shortest paths 7 Jun 2026 — Adjacency lists vs matrices, breadth-first and depth-first search, Dijkstra and A* routing, topological sort, cycle detection, and where graph traversals power DEX routing, dependencies, and social graphs.
  • How symmetric encryption and AES work 7 Jun 2026 — Shared-key encryption, AES block rounds and key sizes, ECB/CBC/CTR/GCM modes, IV and nonce reuse risks, password KDFs, ChaCha20 alternatives, and where AES secures TLS, disks, and wallet backups.
  • How skip lists and probabilistic search structures work 7 Jun 2026 — Tower promotion and express lanes, O(log n) search without tree rotations, Redis ZSET internals, LevelDB memtables, concurrent skip lists, and when to pick skip lists over B-trees or hash maps.
  • How event loops and async I/O models work 7 Jun 2026 — Blocking vs non-blocking sockets, epoll and kqueue multiplexing, the reactor pattern, Node.js libuv, async/await state machines, backpressure, and when worker threads still beat a single loop.
  • How mutexes, locks, and concurrency primitives work 7 Jun 2026 — Mutexes and spinlocks, read-write locks and semaphores, atomics and lock-free queues, deadlock ordering, and when message passing beats shared memory.
  • How IEEE 754 floating point works 7 Jun 2026 — Sign, exponent, and mantissa bits, why 0.1 + 0.2 ≠ 0.3, NaN and infinity, float32 vs float64 precision, Kahan summation, and why ledgers use integers instead of floats.
  • How LSM trees work 7 Jun 2026 — Write-ahead logs and memtables, immutable SSTables, leveled vs tiered compaction, read/write/space amplification, RocksDB and LevelDB internals, and when log-structured merge trees beat B-tree indexes.
  • How rate limiting algorithms work 7 Jun 2026 — Token bucket vs leaky bucket, fixed and sliding windows, GCRA, distributed Redis counters, and pairing limits with circuit breakers at API gateways.
  • How CPU process scheduling works 7 Jun 2026 — Run queues and context switches, preemptive multitasking, Linux CFS and nice values, real-time classes, CPU affinity, cgroup CPU limits, and why runnable thread piles hurt p99 latency.
  • How Unicode, UTF-8, and character encoding work 7 Jun 2026 — Code points vs graphemes, UTF-8 variable-width byte rules, NFC/NFD normalization, BOM pitfalls, collation, and the string-length bugs that still ship in production APIs.
  • How Linux containers, cgroups, and namespaces work 7 Jun 2026 — Containers vs VMs, PID/mount/network namespaces, cgroup v2 CPU and memory limits, overlay image layers, OCI runtimes, Kubernetes pods, and common security pitfalls.
  • How file systems, inodes, and journaling work 7 Jun 2026 — Block devices and mount points, inodes and extents, directories as name maps, journaling vs copy-on-write crash recovery, page cache and fsync durability, SSD TRIM, and ext4/XFS/BTRFS/ZFS trade-offs.
  • How TCP congestion control and reliable transport work 7 Jun 2026 — IP datagrams vs byte streams, three-way handshake, sequence numbers and ACKs, flow control vs congestion control, Reno slow start and fast retransmit, BBR and bufferbloat, and when UDP or QUIC wins.
  • How inverted indexes and full-text search work 7 Jun 2026 — Forward vs inverted indexes, tokenization and analyzers, posting lists and positions, boolean AND/OR, TF-IDF and BM25 ranking, Lucene segments, phrase queries, and when to pair keyword search with vector embeddings.
  • How CPU caches and the memory hierarchy work 7 Jun 2026 — L1/L2/L3 levels, cache lines and locality, associativity and eviction, false sharing, prefetching, TLB pressure, and why data layout can dominate Big-O on modern hardware.
  • How virtual memory and paging work 7 Jun 2026 — Virtual vs physical addresses, multi-level page tables and the TLB, minor and major page faults, demand paging, copy-on-write forks, swapping and thrashing, mmap, and how runtimes sit on top of OS paging.
  • How CRDTs and conflict-free replication work 7 Jun 2026 — State-based vs op-based merges, G-Counters and OR-Sets, last-writer-wins registers, sequence CRDTs for collaborative text, tombstone compaction, and when eventual consistency beats Raft consensus.
  • How hash tables and hash maps work 7 Jun 2026 — Hash functions and uniform distribution, chaining vs open addressing, load factor and rehashing, hash flooding defenses, and how Python, Java, Rust, and Go implement dictionaries.
  • How lossless compression algorithms work 7 Jun 2026 — Entropy and redundancy, LZ77 dictionary matching, Huffman coding, DEFLATE/gzip, zstd and Brotli trade-offs, and when compression fails on encrypted or random data.
  • How circuit breakers and resilience patterns work 7 Jun 2026 — Closed, open, and half-open states, bulkheads, timeouts, fallbacks, pairing with retries and rate limits, and stopping cascading failures before they sink the fleet.
  • How consistent hashing works for distributed caches 7 Jun 2026 — Hash rings, virtual nodes, minimal key remapping when nodes join or leave, replication on the ring, and alternatives like jump consistent hash.
  • How the Raft consensus algorithm works 7 Jun 2026 — Leader election, log replication, majority commit, safety proofs, membership changes, and how Raft compares to Paxos and blockchain BFT.
  • How ACID database transactions work 7 Jun 2026 — Atomicity, consistency, isolation levels, write-ahead logs, deadlocks, two-phase commit vs sagas, and when to relax guarantees for distributed scale.
  • Garbage collection algorithms explained 7 Jun 2026 — Reachability and root sets, mark-sweep and mark-compact, copying and generational GC, reference counting cycles, tri-color concurrent collectors, and how to read pause metrics.
  • Zero-knowledge proofs explained 7 Jun 2026 — Prove statements without revealing witnesses; completeness, soundness, zk-SNARKs vs STARKs, rollups, range proofs, identity credentials, and practical limitations.
  • CAP theorem and distributed consistency trade-offs 7 Jun 2026 — Consistency, availability, partition tolerance; CP vs AP during network splits; PACELC latency trade-offs; quorums, blockchains, and how to choose for your product.
  • How garbage collection algorithms work 7 Jun 2026 — Mark-sweep, generational heaps, concurrent tri-color marking, write barriers, and the throughput vs pause-time trade-offs in JVM, Go, V8, and .NET.
  • How Bloom filters and probabilistic data structures work 7 Jun 2026 — Bit arrays, k hash functions, false positive tuning, counting and cuckoo variants, and where databases, CDNs, and light clients use "maybe in set."
  • How recommendation algorithms work 7 Jun 2026 — Collaborative filtering, embeddings, two-tower rankers, cold start, bandits, feedback loops, and why your feed is a pipeline not a single model.
  • How Merkle trees and content-addressable storage work 7 Jun 2026 — Hash-linked trees, inclusion proofs, tamper detection, and why Git, IPFS, and blockchains name data by its digest.
  • How load balancing and reverse proxies work 7 Jun 2026 — L4 vs L7 routing, round-robin and consistent hashing, health checks and draining, TLS termination, sticky sessions, and how one hostname hides many backends.
  • How DNS and domain name resolution work 7 Jun 2026 — Recursive resolvers, authoritative zones, TTL caching, DNSSEC validation, and the lookup path from browser to IP.
  • How TLS and HTTPS certificate chains work 7 Jun 2026 — TLS 1.3 handshake, leaf and intermediate CAs, OCSP stapling, mixed content failures, and why transport encryption is not wallet custody.
  • How browser fingerprinting works 7 Jun 2026 — Canvas, WebGL, and TLS entropy; cross-site tracking without cookies; fraud vs surveillance; and defenses that actually help.
  • How passkeys and WebAuthn work 7 Jun 2026 — FIDO2 registration and authentication ceremonies, platform vs roaming authenticators, origin-bound phishing resistance, and how passkeys differ from crypto seed phrases.
  • How stablecoin pegs actually work 7 Jun 2026 — Fiat reserves, crypto collateral, arbitrage loops, redemption queues, and the depeg cascade from $0.97 to crisis.
  • How NAT traversal and game relay networks work 7 Jun 2026 — STUN, ICE, UDP hole punching, TURN relays, and Steam SDR — why direct P2P fails and when relays add 100 ms even between neighbors.
  • Symbolica 2.0: programmable symbols in computer algebra 7 Jun 2026 — Normalization, derivative, series, printing, and evaluation hooks that let custom math objects behave like built-ins — plus JIT evaluators and the HN naming collision.
  • Harness engineering: how agent-first repositories actually work 7 Jun 2026 — AGENTS.md maps, mechanical linters, observability APIs, and the Ralph Wiggum review loop behind OpenAI's million-line Codex experiment.
  • Field of clones: how somatic cell nuclear transfer rewrote elite polo 7 Jun 2026 — SCNT, epigenetics, Kheiron Biotech, and why a pasture of genetic replicas climbed Hacker News beside IOCCC craft code.
  • How ntsc-rs emulates analog TV and VHS without LUT shortcuts 7 Jun 2026 — Composite video physics, chroma subsampling, head-switching noise, and why simulation beat Instagram filters on Hacker News.

Related reading