Glossary

Glossary

One line per term, in alphabetical order, each linked to the post that explains it. Terms are defined the way they are used on this blog, which is the way you should use them in an interview.

A to C

  • Algebraic data type. A type built as a fixed set of alternatives (a sealed hierarchy), each carrying its own fields, so the compiler can check that every case is handled. The Kotlin tool for making illegal states unrepresentable. Functional programming in Kotlin
  • Aliasing bug. Two names for one mutable object, so a change through one is seen through the other: a live list stored in results, a single row shared across a grid. Find the bug
  • ADR (Architecture Decision Record). A short document recording a decision, its context, and its consequences, ideally with a “we will revisit this if” clause. Decision went wrong
  • Analysis paralysis. Gathering information past the point where it would change the decision, because gathering feels like progress and deciding feels like exposure. Not deciding selects the default, which had no analysis at all. Biggest weakness
  • At-least-once. A delivery guarantee: every message is delivered, and some are delivered more than once. The honest guarantee of every queue, relay, and scheduler; paired with idempotent consumers. Job scheduler, Idempotency
  • Backpressure. A consumer signaling a producer to slow down. A neighbor of rate limiting and load shedding, not a synonym. Rate limiter
  • Binary search on the answer. Searching a monotonic answer space instead of an index: if speed k works, every faster speed works, so bisect for the smallest k that works. Coding questions part three
  • Boxing. Wrapping a primitive such as Int in an object so it can live in a generic collection. Array<Int> boxes; IntArray does not. Coding questions in Kotlin
  • Backtracking. Building a candidate solution incrementally and undoing the last step when it cannot lead to a result. Subsets, permutations, and constraint problems. More coding questions in Kotlin
  • Borrowed authority. Getting a sponsor or an escalation to mandate what you could not get adopted by influence. A real lever for security, compliance, and one-way doors; used last, transparently, with the evidence the other levers produced. Influence without authority
  • Brooks’s law. Adding people to a late software project makes it later, because onboarding costs time first and communication overhead grows with headcount. Applies least to parallelizable, well-understood work started early. Pushed back on a deadline
  • Cache stampede. Many requests miss on the same hot key at once, usually at expiry, and all rebuild it from the database simultaneously. Prevented by request coalescing and jittered or early refresh. Read-heavy lookup
  • Cache-aside. The application checks the cache, reads the database on a miss and fills the cache, and deletes the key on write. The default pattern, with a race where a slow reader repopulates a stale value. Read-heavy lookup
  • CAP. During a network partition, a system must choose between refusing operations (consistent, meaning linearizable) and serving possibly stale data (available). Says nothing about the normal case. Consistency
  • Cardinality explosion. The number of distinct time series grows far beyond plan because a metric label takes unbounded values (user ID, request ID). Exhausts memory and index size even though each sample is tiny. Write-heavy ingest
  • Causal consistency. If operation B could have depended on A, everyone sees A before B; concurrent operations may be seen in different orders. Prevents a reply appearing before its post. Consistency
  • CDC (Change Data Capture). Tailing a database’s log to publish changes. The log-based way to run an outbox relay. Sagas and the outbox
  • Channel. A hot, point-to-point conduit between coroutines: each value goes to exactly one receiver, with a capacity you choose. Use for handing work between coroutines. Concurrency in Kotlin
  • Choreography. A saga style where each service reacts to events and emits its own, with no central coordinator. Fine for two or three steps. Sagas and the outbox
  • Circuit breaker. Protects a caller from a failing callee by stopping calls after repeated failures. The opposite direction from a rate limiter. Rate limiter
  • Co-location. Sharding related tables by the same key (orders by their user_id, like users) so a user and everything that belongs to them land on one shard, where joins and transactions still work. What sharding takes away
  • Compare-and-set (conditional write). An update that succeeds only if the row still has the value or version the writer expects. Prevents lost updates at read committed. Isolation
  • Compensation. A new forward transaction that semantically undoes a completed saga step. Not a rollback; it can fail and must be retried. Sagas and the outbox
  • Conditional update. A single statement whose WHERE clause encodes the precondition, so the check and the write are atomic. The mechanism behind holds, decrements, and fencing. Ticket booking, Isolation
  • Connection registry. An in-memory map from user to the gateway server holding that client’s long-lived connection, kept fresh by heartbeats with a TTL, so messages reach the right socket. Real-time
  • Consistent hashing. Placing keys and nodes on a hash ring so each key belongs to the next node clockwise; adding a node moves only about 1/N of keys. Virtual nodes keep the spread even. How to shard
  • Cooperative cancellation. Cancelling a coroutine sets a flag; only code that checks the flag, by suspending or calling isActive or ensureActive(), actually stops. Concurrency in Kotlin
  • Conway’s Law. Systems mirror the communication structure of the organizations that build them. Service boundaries that do not match team boundaries do not hold. Monolith or microservices
  • CRDT (Conflict-free Replicated Data Type). A data structure whose concurrent updates merge deterministically without coordination. The alternative to last-writer-wins for shopping carts and counters. Consistency, Real-time

D to H

  • Dead reckoning. Estimating an object’s current position on the client from its last known position, heading, and speed, so a marker moves smoothly between infrequent updates. Real-time
  • Dead-letter queue. Where a message goes after exhausting its retries, so that it is not silently dropped and someone looks at it. Job scheduler
  • Disagree and commit. Stating a disagreement fully, with evidence, then executing the decision as if it were your own once it is made, with the dissent and a revisit trigger written down. Disagree with a senior engineer
  • Dijkstra’s algorithm. Shortest paths from one source over non-negative weights, settling nodes in distance order with a heap and skipping stale entries. Coding questions part three
  • Dispatcher. The component that decides which thread runs a coroutine’s code: Default for CPU work, IO for blocking calls, Main for a UI thread, or one you create for confinement. Concurrency in Kotlin
  • Downsampling. Replacing high-resolution data with coarser rollups as it ages (10-second, then 1-minute, then 1-hour), each storing sum, count, min, max, and a histogram so aggregates stay correct. Write-heavy ingest
  • Dual write. Writing to a database and then publishing to a broker as two separate operations. The bug the outbox fixes. Sagas and the outbox
  • Durable execution. A workflow model where ordinary code survives crashes because the engine records every step’s result in an event history and rebuilds state by replaying the code (for example Temporal). Coordination
  • Escape analysis. A JIT optimization that proves an object never leaves the method that created it and then allocates it on the stack or eliminates it entirely. Why boxing sometimes costs nothing in a hot loop. JVM runtime
  • Escrow (quota) allocation. Granting portions of a fungible quantity to servers, regions, or channels so they sell locally without coordinating, rebalancing near the end. Contended writes
  • Event time versus processing time. Event time is when something happened on the client; processing time is when the pipeline saw it. Aggregating by processing time puts late events in the wrong window. Write-heavy ingest
  • Eventual consistency. If writes stop, all replicas converge; anything may be observed in between. Always name the anomaly you are accepting. Consistency
  • Fail open / fail closed. What a protective component does when its own dependency is down: let everything through, or block everything. Decided per rule. Rate limiter
  • Fan-out on read (pull). Building a recipient’s feed at read time by fetching and merging the recent items of everyone they follow; cheap writes, expensive reads. Fan-out
  • Fan-out on write (push). Copying a reference to each new item into every recipient’s precomputed feed or inbox when it is created, so reads are a single list fetch. Fan-out
  • Fan-out. Delivering one write to many recipients, as in feeds and notifications. The shape where the hard part is delivery to hot users. First five minutes, Fan-out
  • Fencing token. A monotonically increasing number attached to a lease, checked on every write, so a stale holder’s late writes are rejected. Job scheduler, Ticket booking, Coordination
  • Flow. A cold asynchronous stream: the producer block runs anew for each collector, with backpressure built in because emitting suspends until the collector takes the value. Concurrency in Kotlin
  • Fixed time, variable scope. Holding the date and negotiating what ships by it, rather than holding the scope and letting the date slip. The lever that usually works. Pushed back on a deadline
  • Fixed window. A rate limiting algorithm with one counter per window; allows double the limit across a boundary. Rate limiter
  • Geohash. A base-32 string made by interleaving longitude and latitude bits; each character divides the cell into 32. A shared prefix means the points are close, but close points can have unrelated prefixes at cell boundaries. Geohash vs. quadtree
  • Global secondary index. A separate table mapping another field to the shard key (email to user_id), itself sharded by that field. Serves lookups without the shard key and can enforce uniqueness; usually kept in sync asynchronously. How to shard
  • Graceful drain. Taking a connection-holding server out of service by refusing new connections and moving existing clients elsewhere in batches, avoiding a reconnect storm. Real-time
  • H3. Uber’s hierarchical geospatial index that tiles the earth in hexagons at 16 resolutions. All six neighbors of a cell are equidistant, so “cell plus k rings” approximates a radius search. Real-time, Geohash vs. quadtree
  • Happens-before. The Java memory model’s relation guaranteeing that one thread’s write is visible to another’s read. Created by locks, volatiles, atomics, thread start and join, and constructor completion for val fields. JVM runtime
  • Haversine formula. The great-circle distance between two latitude and longitude points. The exact filter after a grid or tree returns candidates; raw degrees are not distance. Geohash vs. quadtree
  • Hold. A time-limited reservation stored as a status and an expiry in the row, taken and released by conditional updates. Not a lock. Ticket booking
  • Hot key / hot row / hot shard. One key, row, or partition receiving a disproportionate share of traffic. The seat during an on-sale; the celebrity in a feed. Ticket booking, Rate limiter, Read-heavy lookup, Contended writes, How to shard
  • Hybrid fan-out. Push for normal authors and pull-and-merge for authors above a follower threshold, so celebrity posts do not generate millions of writes. Fan-out
  • Hydration. Turning a page of IDs from a feed or inbox into displayable content with batched multi-gets, filtering out deleted or hidden items. Fan-out

I to L

  • Idempotency key. A client-generated identifier for an intent, reused on every retry, so the server can detect and dedupe repeats. Idempotency
  • Inbox pattern. A consumer records each processed message ID in its own database, in the same transaction as the processing, so duplicates are no-ops. The mirror of the outbox. Idempotency, Sagas and the outbox
  • Isolation level. How much concurrent transactions on one copy can interfere with each other: read uncommitted, read committed, repeatable read, snapshot, serializable. Isolation
  • JIT (just-in-time compilation). The JVM runs bytecode in an interpreter, compiles hot methods with a fast tier, then recompiles the hottest with full optimization, and deoptimizes when a speculation fails. Why the first call is slow. JVM runtime
  • Jitter. Randomizing retry delays or scheduled times so that many clients do not act in the same instant. Job scheduler
  • Kadane’s algorithm. Maximum-sum subarray in one pass by choosing at each element to extend the current run or restart. More coding questions in Kotlin
  • KMP (Knuth-Morris-Pratt). Linear-time substring search using a failure table that records, for each pattern prefix, the longest proper prefix that is also a suffix, so a mismatch slides the pattern instead of restarting it. Coding questions part three
  • KGS (Key Generation Service). A background service that pre-generates unique keys for a URL shortener. One of five ID strategies. URL shortener
  • k-nearest neighbors (kNN) search. Return the k closest points, with no fixed radius. Exact in a tree with best-first search; on a grid, expand rings until the k-th result is closer than the edge of the searched area. Geohash vs. quadtree
  • Leader election. Choosing a single node to act for a group: in effect a lease on “leader” whose epoch or term number acts as the fencing token. Coordination
  • Lease. A lock with an expiry, renewed by heartbeat while the holder is alive, so a dead holder’s work can be taken over. Job scheduler, Coordination
  • Leaky bucket. A rate limiting algorithm that drains a queue at a fixed rate; smooths traffic and adds latency. Rate limiter
  • Linearizability. Every operation appears to take effect instantaneously at some point between its start and its acknowledgment, in real time. The strongest single-object guarantee, and what CAP means by consistency. Consistency
  • Little’s law. Concurrency equals throughput times latency. Sizes thread pools, connection pools, and server counts. Numbers
  • Load shedding. A server dropping requests because it is at capacity, regardless of who sent them. A policy about the server, not the client. Rate limiter
  • Logical shard. A fixed, large number of hash buckets (1,024, say) mapped onto a smaller number of physical databases. Growth moves whole logical shards between machines instead of rehashing keys. How to shard
  • Lost update. Two transactions read, compute, and write; one write silently overwrites the other. Permitted at read committed. Isolation

M to P

  • Minimal reproduction. The smallest input that makes a bug observable: "abba", [3, 3], an all-negative array. Producing it is the difference between a hypothesis and a finding. Find the bug
  • Misfire policy. What a scheduler does with runs it missed while down: skip, fire once, or fire all. Per-job configuration. Job scheduler
  • Modular monolith. One deployable with enforced module boundaries that could become services later. The default for a new system. Monolith or microservices
  • Monotonic stack. A stack kept in sorted order by popping until the new element fits; each index is pushed and popped once, giving amortized O(n) for next-greater-element problems. More coding questions in Kotlin
  • Monotonic reads. A client never sees time go backward: a value once seen is not later replaced by an older one. Consistency
  • MVCC (Multi-Version Concurrency Control). Keeping multiple versions of a row so readers see a consistent snapshot without blocking writers. How snapshot isolation is implemented. Isolation
  • Negative caching. Caching a “not found” result briefly so that misses do not each become a database read. URL shortener, Read-heavy lookup
  • One-way and two-way doors. Decisions that are hard to reverse versus easy to reverse. Spend the analysis on the one-way doors; decide the two-way ones quickly with a written reversal condition. Decision went wrong, Biggest weakness
  • Orchestration. A saga style where one component sends commands to each service and tracks the state machine. Preferred for flows with branches or more than three steps. Sagas and the outbox
  • OT (Operational Transformation). A collaborative-editing technique that rewrites an operation made against an older version against the operations it missed, using a central server’s order so all copies converge. Real-time
  • Outbox (transactional outbox). Writing the event to an outbox table in the same transaction as the business data, with a relay that publishes it afterward. The fix for the dual write. Sagas and the outbox
  • PACELC. Extends CAP: during a partition choose availability or consistency; else, choose latency or consistency. Describes the normal case. Consistency
  • Paved road. The default that makes the right choice the easy one: a template, a shared library, a scaffold, a lint rule. How an adopted change outlives the person who pushed it. Influence without authority
  • Phantom. A predicate query returning new rows on a second execution within the same transaction. Isolation
  • Planning fallacy. The systematic tendency to underestimate how long work will take, even with experience of similar work running late. Countered with breakdowns, ranges, and comparison to past projects. Pushed back on a deadline
  • Pilot (adoption). The smallest ask that produces evidence: one service, a few weeks, success criteria the owning team sets, a rollback they control, and the first work done by the person proposing it. Influence without authority
  • Pivot transaction. The saga step that is the point of no return. Before it, failures compensate backward; after it, steps are retried forward until they succeed. Sagas and the outbox
  • Priority lane. A separate queue and sender pool for one class of notification (critical, transactional, bulk), so a large low-priority send cannot delay urgent ones. Fan-out
  • Proxy bidding. The bidder submits a hidden maximum and the system bids for them in minimum increments, so the visible price is the second-highest maximum plus one increment. Contended writes

Q to S

  • Psychological safety. A team norm in which people can disagree, ask, and be wrong without penalty. What the senior person in the room is responsible for creating. Disagree with a senior engineer
  • Pseudo-polynomial. A runtime that is polynomial in the numeric value of an input rather than in its length, as in coin change’s O(amount × coins). Coding questions in Kotlin
  • Pure function. A function whose result depends only on its inputs and that changes nothing observable outside itself. Local mutation that nobody can see does not break purity; the property belongs to the interface. Functional programming in Kotlin
  • Quadtree. A tree that splits a region into four quadrants whenever it holds more than a threshold of points, so cells are small where data is dense. Even load per leaf and exact nearest-neighbor search; usually held in memory. Geohash vs. quadtree
  • Quickselect. Partition-based selection of the kth element in expected O(n) time with a random pivot, O(n²) worst case. More coding questions in Kotlin
  • Quorum. Reading from and writing to enough replicas that any read set overlaps any write set (R + W > N). Close to linearizable, with caveats. Consistency
  • R-tree. An adaptive tree of overlapping bounding rectangles designed for disk pages; the spatial index behind PostGIS (via GiST), MySQL, and SQLite. Handles polygons as well as points. Geohash vs. quadtree
  • Reaper. A background process that finds abandoned work, such as expired leases or claimed-but-never-enqueued rows, and releases or re-queues it. Job scheduler
  • Redlock. A Redis algorithm that acquires a lock on a majority of independent Redis nodes. Disputed for correctness because it assumes bounded pauses and clock drift and provides no fencing token. Coordination
  • Reference table. A small, rarely changing table (countries, currencies, categories) copied whole to every shard so any shard can join to it locally. What sharding takes away
  • Regret minimization framework. Bezos’s test for hard personal and strategic decisions: project yourself forward, look back, and choose the option you would regret least, since errors of omission weigh more over time. Biggest weakness
  • Railway-oriented error handling. Chaining operations on a success-or-failure type with map and flatMap so the happy path reads as a pipeline and the first failure short-circuits. Functional programming in Kotlin
  • Read-your-writes. A client always sees its own writes. Enforced by routing the client to the writer briefly, or by a version token. The session guarantee users notice most. Consistency
  • Regression test. A test built from a bug’s minimal reproduction so the bug cannot silently return. Stating it is the second half of a debugging answer. Find the bug
  • Request coalescing (single-flight). Concurrent misses for the same key share one backend fetch; the first rebuilds the value and the rest wait for it. Read-heavy lookup
  • S2. Google’s spherical geometry library: the sphere projected onto a cube, each face a quadtree, cells ordered on a Hilbert curve as 64-bit IDs at 31 levels. Good for region coverings and polygons. Geohash vs. quadtree
  • Safe publication. Making an object visible to other threads such that they see its fully constructed state. Final and val fields set in the constructor get it for free; that is why immutable objects need no synchronization. JVM runtime
  • Saga. A sequence of local transactions across services, each with a compensating transaction, that together end in a consistent state. Sagas and the outbox
  • Scatter-gather. Sending a query to every shard and merging the results. Acceptable for rare admin queries; too slow and too expensive on a hot path. How to shard
  • Semantic lock. A status such as PENDING on a record that tells other processes a saga is in flight, standing in for the isolation sagas lack. Sagas and the outbox
  • Sequence (Kotlin). A lazy, cold pipeline over elements: nothing runs until a terminal call, each element flows through every step, early termination stops work, and every terminal call reruns the pipeline. Functional programming in Kotlin
  • Sessionization. Grouping one user’s events into sessions separated by an inactivity gap, commonly 30 minutes. In a stream it requires partitioning by user or device ID. Write-heavy ingest
  • Seventy percent rule. Make most decisions with about seventy percent of the information you wish you had; waiting for ninety is slow for certain, while being wrong is often cheap if you correct course. The stopping test is “what would the rest change?” Biggest weakness
  • Serializable. The isolation level whose result equals some serial ordering of the transactions. Implemented by locking, optimistic detection, or literal serial execution; requires retries. Isolation
  • Safepoint. A point in execution where a thread’s state is fully known and it can be stopped by the runtime, such as a method return or loop back-edge. Stop-the-world pauses begin only after every thread reaches one. JVM runtime
  • Shard key. The column that decides which shard a row lives on. Needs high cardinality, must be present in the main query, and should be shared by data read or written together. How to shard
  • Shard map. The table that maps logical shards to physical clusters, kept in a small strongly consistent store and cached by every router. Moving a shard is a versioned map update. How to shard
  • Sharded counter. A fungible count split across several rows so decrements spread out. The total is the sum, and “sold out” requires checking every bucket. Contended writes
  • Sharding. Partitioning data across nodes by a key. The key choice is the whole decision; hot partitions are the risk. Job scheduler, Ticket booking, How to shard
  • Sliding window. Two indices that only move forward over a sequence, maintaining an invariant about the range between them. The pattern for longest-substring problems. Coding questions in Kotlin
  • SKIP LOCKED. A SELECT FOR UPDATE modifier that skips rows already locked by another transaction, letting many workers claim distinct rows from one table atomically. Job scheduler
  • Sliding window counter. A rate limiting algorithm that blends the current and previous fixed windows; accurate and cheap. Rate limiter
  • Snapshot isolation. Each transaction reads from a consistent snapshot taken at its start; first committer wins on write conflicts to the same row. Prevents everything in the standard’s list except write skew. What most “repeatable read” implementations actually are. Isolation
  • Snowflake ID. A 64-bit ID built from a timestamp, a machine number, and a per-machine sequence, so every node generates unique, roughly time-ordered IDs without coordinating. How to shard, What sharding takes away
  • Soft close. An auction rule that extends the end time when a bid arrives in the final minutes. Discourages sniping and flattens the closing spike. Contended writes
  • Space-filling curve. A line that passes through every cell of a grid (Z-order, Hilbert), used to fold two-dimensional coordinates into one sortable key so a map region becomes a few index ranges. Geohash vs. quadtree
  • SSI (Serializable Snapshot Isolation). An optimistic serializable implementation that tracks read-write dependencies and aborts transactions that could form a cycle. PostgreSQL’s serializable. Isolation
  • Steelman. Restating someone’s position in its strongest form, better than they did, before disagreeing with it. The first step of the disagreement playbook. Disagree with a senior engineer
  • Stop-the-world pause. A period in which every application thread is halted so the garbage collector can work. Its length tracks the live set and allocation rate more than the collector choice. JVM runtime
  • Storage tiering. Moving data from hot (indexed, SSD, days) to warm to cold (object storage, years) as it ages, so cost follows the falling value of old data. Write-heavy ingest
  • Strangler fig. Migrating from a monolith by routing traffic feature by feature to new services until the old system can be retired. Monolith or microservices
  • Structured concurrency. Every coroutine belongs to a scope that owns a tree of jobs: the parent waits for its children, cancellation flows down, and failure flows up unless a supervisor stops it. Concurrency in Kotlin
  • Strict serializability. Serializable transactions that are also linearizable. What most people mean by “strong.” Consistency
  • Sync cursor. The last sequence number a device has seen in each conversation, sent on reconnect so the server returns only what was missed. Fan-out
  • System shape. The category a design problem falls into (read-heavy lookup, write-heavy ingest, fan-out, contended writes, coordination, real-time). Naming it in minute one tells you where the difficulty lives. First five minutes

T to Z

  • Tail recursion. A recursive call as the very last action of a function, which the tailrec modifier lets the Kotlin compiler rewrite into a loop. The JVM does not do this on its own. Functional programming in Kotlin
  • Thundering herd. Many clients acting at the same instant, such as an on-sale, a cache expiry, or a retry storm. Shaped by a waiting room, jitter, or a queue. Ticket booking
  • Timing wheel. An in-memory hierarchical timer structure for finding due jobs with sub-second precision. Job scheduler
  • Token bucket. A rate limiting algorithm with a bucket that refills at a fixed rate and holds a burst capacity. The default for API limits. Rate limiter
  • Topological sort. An ordering of a directed acyclic graph’s nodes so every edge points forward. Kahn’s algorithm peels nodes with no remaining incoming edges; if any remain, there is a cycle. More coding questions in Kotlin
  • Tortoise and hare. Floyd’s cycle detection: a slow pointer and a fast pointer that meet if and only if the list has a cycle. Coding questions in Kotlin
  • Trie. A prefix tree where each node’s children are indexed by character and a terminal flag marks the end of a stored word. More coding questions in Kotlin
  • Two heaps. A max-heap for the smaller half and a min-heap for the larger, kept balanced, so the median of a stream is at the tops. Coding questions part three
  • Two-phase commit (2PC). A distributed transaction protocol in which a coordinator asks every participant to prepare, then commit. Blocking, coordinator-dependent, and unsupported by most brokers and APIs. Sagas and the outbox, What sharding takes away
  • Union-find (disjoint set). A structure that tracks which elements are in the same set with near-constant amortized find and union when path compression and union by rank are both used. Coding questions part three
  • Unit of contention. The smallest piece of state concurrent writers must serialize on (a seat, a SKU count, an auction’s high bid). Sets the partition key and the throughput ceiling. Contended writes
  • Vertical partitioning. Splitting a database by table or by column group rather than by row, such as moving a write-heavy field into its own store. Needs no shard key and is usually tried before sharding. How to shard
  • Waiting room. An edge component that queues arrivals and admits them at a chosen rate with a signed token, providing fairness and a place for bot control. Ticket booking
  • Watermark. A stream processor’s estimate that all events up to a given event time have arrived. Lets a window close; later events go to a lateness policy. Write-heavy ingest
  • Workflow replay. Rebuilding a workflow’s state by re-running its code against its recorded history, returning recorded results instead of repeating side effects. Requires deterministic workflow code. Coordination
  • Write skew. Two transactions read overlapping data, decide, and write to different rows; each write is fine alone and together they break an invariant. Permitted by snapshot isolation. Isolation
  • 301 vs. 302. A permanent redirect that browsers cache, versus a temporary one that sends every click through the server. The analytics decision in a URL shortener. URL shortener
  • Zipf distribution. A skewed popularity pattern where a small fraction of keys gets most requests. Why caching works for lookups, and why hot keys exist. Read-heavy lookup