Cache Invalidation

Browsers keeping a whole page frozen in memory when you navigate away, so pressing Back restores it instantly, unless something on the page makes it ineligible.

A probabilistic set membership structure that can say "definitely not present" but only "probably present."

Reusing the outputs of build and test steps whose inputs haven't changed, keyed by a hash of those inputs, so large codebases build in minutes instead of hours.

Turning a database's own internal write log into a stream other systems can subscribe to, without touching the application.

A hashing scheme where adding or removing a node remaps only a small fraction of keys, not nearly all of them.

A CDN answers requests from servers near the requester, trading a single origin for many cached edges.

The property that identical inputs produce identical outputs, and the foundation of caching and verification.

The distributed directory translating names to addresses, and the layer where propagation delays live.

An opaque fingerprint of a response's content that lets a client ask a server whether it's changed without re-downloading it.

A guarantee that replicas converge given no further updates, without guaranteeing when.

A hash over everything that determined a result, used to detect when the result has gone stale.

A function mapping arbitrary input to a fixed-size digest, used for identity, integrity, and addressing.

The set of headers that let a browser or intermediary reuse a previous response instead of re-fetching it.

Serving a cached static page while regenerating it in the background after a chosen interval.

A signed, self-contained token that carries claims a server can verify without a database lookup.

A fixed-capacity cache that evicts whichever entry has gone untouched the longest.

The stored result of a query, kept as a table so that expensive reads become cheap, at the cost of keeping that result up to date.

The meta tags a page uses to describe its own preview card when a link is shared, how chat apps and social networks fetch them, and why a preview shows only what the page claims about itself.

Updating the UI as if a server request has already succeeded, before the server has actually responded.

A website that can be installed like a native app, launched from the home screen in its own window and used offline, built from a manifest, a service worker and HTTPS.

Reusing the computed state of a prompt's unchanged prefix across requests, which only works if that prefix stays byte-identical.

Components that execute only on the server and never ship their code to the browser.

Frame hitches caused by compiling GPU programs the first time they are needed, and the caching schemes that try to move that work elsewhere.

How a front-end application keeps track of the data that changes as people use it, and decides where each piece lives, from local component state to global stores to server caches.

Rendering every page to a file at build time, so serving is just handing over bytes.

A limit on how long something may live, counted in hops or seconds, which keeps lost packets from circling forever and tells caches when their copies go stale.

A cache that acknowledges a write immediately and persists it to the real store later, trading durability for write latency.