Reference

Glossary

182 terms, one line each. Follow a link to where a term is taught, or open its one-minute short (130 have one).

ACID: Four promises for a transaction: all or nothing, rules kept, no interference from others, and saved even after a crash.; Learn
Acknowledgement (ack): A short reply meaning "got it". Until the sender hears one, it may send the message again.; 1-min short Learn
Adaptive bitrate: The video player picks a sharper or softer version for each short piece, depending on how fast the network is right now.; 1-min short Learn
Anti-entropy: A background job that compares copies of the same data and fixes any that drifted apart, copying only what differs.; 1-min short Learn
Anycast: Many servers around the world share one IP address, and the network sends each user to the nearest one.; 1-min short
API gateway: One front door in front of your services. It checks who is calling, limits traffic, routes each request and logs it.; Learn
At-least-once delivery: A promise that every message arrives, even if that means some arrive twice. So the receiver must cope with repeats.; 1-min short Learn
Autoscaling: Adding or removing servers automatically as load changes, based on things like CPU, request rate or queue length.; 1-min short
B-tree: The sorted, tree-shaped index most SQL databases use. A lookup takes just a few page reads, and changes are made in place.; 1-min short
Backpressure: When a receiver can't keep up, it tells senders to slow down (or some work is dropped) instead of letting it pile up.; 1-min short Learn
Bloom filter: A tiny memory-saving check of whether you have seen something. It may say "maybe", but its "no" is always right.; 1-min short Learn
Blue-green deployment: Run two identical copies of your system. Switch all traffic from the old one to the new one, and back if it goes wrong.; 1-min short
Bulkhead: Giving each outside service its own separate pool of workers, so one slow service can't use up everyone's share. Like ship compartments.; 1-min short Learn
Cache: A small, fast place that keeps the answers you need most, so you rarely go to the slower source.; Learn
Cache hit ratio: The share of reads the cache answers without going to the database. Higher means the cache is helping.; Learn
Cache-aside: The app checks the cache first. If the answer is missing, it asks the database, then saves it in the cache for next time.; 1-min short Learn
Canary release: Send a small slice of users to the new version first and watch for problems before rolling it out to everyone.; 1-min short
CAP theorem: If a network split cuts your copies of the data apart, you can keep answers correct or keep answering, but not both.; 1-min short Learn
CDN: Servers around the world that keep copies of your files, so each user downloads from one nearby.; 1-min short Learn
Circuit breaker: After too many failures, stop calling a broken service for a while and fail right away. Like a fuse in your house.; 1-min short Learn
Columnar storage: Storing each column together instead of each row. Reports that need a few columns read less data, and it compresses well.; 1-min short
Compare-and-set: Update a value only if it still equals what you last saw. If not, it fails, so two writers can't both win.; 1-min short Learn
Condition variable: A place for a thread to sleep until another thread says something it was waiting for is now true.; 1-min short Learn
Congestion control: The sender slowing down when the network starts dropping packets, so everyone shares the links fairly.; 1-min short Learn
Connection pool: A set of already-open connections that requests borrow and return, instead of opening a new one every time.; 1-min short Learn
Consensus: Several machines agreeing on one answer, even when some of them fail or messages get lost.; Learn
Consistent hashing: Servers and keys are placed around a circle. Adding a server moves only about 1/N of the keys, not all of them.; 1-min short Learn
Consumer: The program that takes messages from a queue or topic and does the work.; Learn
Content-defined chunking: Cutting a file where its own bytes say so, not every fixed number of bytes, so a small edit changes only a chunk or two.; 1-min short Learn
Context switch: The moment the CPU stops one thread and starts another, saving the first one’s place so it can resume later.; 1-min short Learn
CORS: A browser rule: a page can read another site’s reply only if that site’s server says it is allowed.; 1-min short Learn
Count-min sketch: A small grid of counters that estimates how often each item appears. It can guess too high, but never too low.; 1-min short
Covering index: An index that already holds every column a query needs, so the table itself is never read.; 1-min short Learn
CQRS: Splitting a system into one part that handles writes and separate parts, shaped for reading, that answer queries.; 1-min short
CRDT: A data type built so copies can be changed separately, anywhere, and always merge into the same result without conflicts.; 1-min short Learn
Cursor pagination: Fetching the next page with "give me what comes after this item", not "page 3", so new items don't shift the pages.; 1-min short Learn
Database index: A side lookup the database keeps so it can find rows fast, like the index at the back of a book.; Learn
Dead letter queue (DLQ): A holding area for messages that kept failing after every retry, so people can inspect them and try again later.; 1-min short Learn
Deadlock: Two or more threads each hold something the other needs, so none of them can ever move.; 1-min short Learn
Debounce: Wait until typing pauses before doing the work, so you don't call the search server on every keystroke.; 1-min short Learn
Deduplication (dedupe): Spotting and dropping repeats, so the same thing is only handled once.; Learn
DNS: The internet's phone book: it turns a name like example.com into the numeric address of a server.; 1-min short Learn
Double-entry ledger: A money record where every transfer is written twice, as a debit and a credit that cancel out, so balances can always be checked.; 1-min short Learn
Error budget: How much failure you are allowed: 100% minus your reliability target. You can spend it by shipping risky changes.; 1-min short Learn
Event loop: One thread that waits for events and runs the code for each one in turn, so it can serve many connections.; 1-min short Learn
Event sourcing: Instead of storing the current state, store every change as an event, and rebuild the state by replaying them. Like a bank statement.; 1-min short
Eventual consistency: Copies may disagree for a moment, but once writes stop they all end up the same.; Learn
Eviction: Throwing items out of a full cache to make room. A policy such as LRU decides which ones go.; Learn
Exactly-once delivery: A promise that each message is handled once, not twice. In practice it is at-least-once delivery plus ignoring repeats.; Learn
Exponential backoff: Waiting longer after each failed try, such as 1, 2, 4, 8 seconds, so a struggling server gets room to recover.; 1-min short Learn
Failover: Switching to a backup when the main machine fails, so the service keeps running.; Learn
Fan-out: Copying one event to many places, like a post going to every follower's feed.; 1-min short Learn
Fan-out on write: When someone posts, copy it into every follower's feed right away, so reading a feed is quick.; 1-min short Learn
Feature flag: A switch in the code you can flip while it runs, to show a feature to some users without deploying again.; 1-min short
Fencing token: A number that goes up with every lock handed out. Storage refuses any holder with an older number, so a stale one can't do damage.; 1-min short Learn
Flow control: The receiver telling the sender how much data it has room for, so a fast sender cannot overrun a slow reader.; 1-min short Learn
GeoDNS: A DNS that gives different answers depending on where the asker is, so users reach a nearby server.; 1-min short
Geohash: Turns a map position into a short text code. The longer the start two codes share, the closer the places.; 1-min short Learn
Gossip protocol: Every machine regularly tells a few random others what it knows, so news spreads through the whole cluster fast, like a rumor.; 1-min short
GraphQL: A way to ask one endpoint for exactly the fields you want, in a single request.; 1-min short
gRPC: A fast way for services to call each other, using compact typed messages (Protobuf) over HTTP/2, with streaming.; 1-min short
Hash join: A join that puts one table in a hash table, then looks up each row of the other. Fast on unsorted data.; 1-min short Learn
Head-of-line blocking: One lost or slow item at the front of a line holds up everything queued behind it.; 1-min short Learn
Heartbeat: A regular "I'm alive" message. If several in a row are missed, the sender is assumed to be down.; 1-min short
Hinted handoff: When a copy's machine is down, a healthy neighbour holds its writes and hands them over when the machine returns.; 1-min short Learn
Horizontal scaling: Handling more load by adding more machines, instead of buying one bigger machine.; Learn
Hot key: One key that gets far more traffic than the others, so whichever machine holds it is overloaded.; 1-min short Learn
Hot spot: One machine, key or shard that gets far more traffic than the rest, while the others sit idle.; Learn
HTTP/2: A newer HTTP that sends many requests at once over a single connection and compresses the headers.; 1-min short
HTTP/3 (QUIC): The newest HTTP, run over QUIC (which is built on UDP). One lost packet doesn't stall everything, and it connects faster.; 1-min short
HyperLogLog: Counts roughly how many different items you have seen using only a few kilobytes of memory, with about 1% error.; 1-min short
Idempotency key: A unique id sent with a request. On a retry, the server sees the id and returns the saved result.; 1-min short Learn
Idempotent: Safe to repeat: doing it twice has the same effect as doing it once. Like pressing an elevator button again.; Learn
Inverted index: A list that maps each word to the documents containing it, like a book's index. It powers search.; 1-min short
Isolation level: A setting for how much concurrent transactions may see of each other’s unfinished work.; 1-min short Learn
Jitter: A little random delay added to waits, so many clients don't all retry at the same moment.; 1-min short Learn
JWT: A signed token the server can check without a lookup. Anyone can read it, nobody can forge it, and it's hard to cancel early.; 1-min short
Kafka: A system that keeps a never-ending ordered log of messages, which many programs can read at their own pace.; Learn
Keep-alive: Leaving a connection open after a request so the next one skips the setup work.; 1-min short Learn
L4 / L7 load balancing: Two ways to balance load: by network address and port only (L4), or by reading the request itself, like its URL (L7).; 1-min short Learn
Lamport timestamp: A simple counter that orders events by cause and effect, without relying on clocks that may disagree.; 1-min short
Latency: How long one request takes, from asking to getting the answer. Like the wait at a shop counter.; 1-min short Learn
Leader election: Picking one machine to be in charge of writes, usually by majority vote. If it dies, the rest vote for a new one.; 1-min short Learn
List virtualization: Drawing only the rows currently on screen in a long list, and reusing them as you scroll.; Learn
Little's law: How many things are in a system at once equals how fast they arrive times how long each one stays.; Learn
Load balancer: A traffic director that spreads incoming requests across several servers, so none gets overloaded.; Learn
Load shedding: When overloaded, refuse some requests early so the rest still get a good answer.; 1-min short
Long polling: The client asks, and the server waits to answer until it has news (or time runs out). Then the client asks again.; 1-min short Learn
LOOK scheduling: An elevator keeps going one way while stops remain ahead, then turns around, so no floor waits forever.; 1-min short Learn
LRU: Least recently used: when the cache is full, throw out the item nobody has touched for the longest time.; Learn
LSM tree: A storage design for fast writes: save to memory and a log first, flush to sorted files, and merge those files later.; 1-min short
Merkle tree: A tree of fingerprints (hashes) where each parent summarizes its children, so two copies find their differences by comparing a few hashes.; 1-min short
Message queue: A waiting line for messages. One program drops work in, another picks it up later, at its own pace.; Learn
Mutex: A lock that lets one thread at a time into a piece of code. The thread that locked it unlocks it.; 1-min short Learn
MVCC: Keeping several versions of each row, so readers see a steady snapshot and never block writers.; 1-min short
Normalization: Storing each fact in exactly one place, so a change cannot leave two copies disagreeing.; 1-min short Learn
NoSQL: Databases that give up the strict table-and-join model for flexibility and easier scaling. Cassandra and DynamoDB are examples.; Learn
OAuth 2.0: A standard way to let an app use part of your account without ever giving it your password.; 1-min short
Object storage: A cheap place to keep big files like photos and videos by name, such as S3. Not made for fast tiny lookups.; Learn
Operational transformation: Rewriting one person's edit so it still means the same thing after someone else's edit was applied first.; 1-min short Learn
Optimistic locking: Don't lock while you work. When saving, check nobody else changed the row (with a version number), and retry if they did.; 1-min short
Outbox pattern: Save the message to send in the same transaction as the data change. A separate worker sends it later, so a crash can't lose it.; 1-min short Learn
p99: The time that 99 out of 100 requests beat. It shows how slow the unlucky few are, which an average hides.; Learn
PACELC: Extends CAP: during a network split, choose availability or consistency; otherwise, choose between fast answers and consistent ones.; Learn
Page fault: The CPU asking the operating system for a memory page that is not ready, so the system loads it and retries.; 1-min short Learn
Password hashing: Storing passwords as a deliberately slow, salted scramble (Argon2id, scrypt, bcrypt), never a fast hash like SHA-256.; 1-min short
PKCE: An extra check for OAuth login in apps that can't keep a secret, like phone or browser apps.; 1-min short
Poison message: A message that fails every time it is processed, so retrying it never helps.; Learn
Polling: Asking the server again and again whether anything is new, like checking the mailbox every minute.; 1-min short Learn
Primary database: The one copy of a database that accepts writes. The replicas copy from it.; Learn
Primary key: A column whose value is unique for every row, so each row can be found directly and never duplicated.; Learn
Pub/sub (publish-subscribe): Senders publish messages to a named channel, and everyone subscribed to it gets a copy. The sender doesn't know who listens.; Learn
QPS: Queries per second: how many requests hit your system each second. A way to size how much load you must handle.; 1-min short Learn
Quadtree: A map split into four squares, then each busy square split into four again, wherever points crowd together.; 1-min short
Query plan: The database’s chosen steps for running a query: which indexes to use and how to join. EXPLAIN shows it.; 1-min short Learn
Quorum: With N copies, writing to W and reading from R overlap on a fresh copy whenever R + W > N.; 1-min short Learn
Race condition: A bug where the result depends on which of two actions happens first. Like two people grabbing the last seat.; Learn
Raft: A way for machines to agree: a majority elects one leader, and a change counts as saved once a majority has it.; 1-min short
Rate limiting: Capping how many requests one client can make in a time window, so no one can overwhelm the service.; 1-min short Learn
Read repair: When a read finds one copy out of date, the newest value is written back to it right away.; 1-min short Learn
Read replica: A copy of the database that answers reads. If the main one fails, it can take over.; 1-min short Learn
Read-your-writes: A promise that after you save something, you see it when you read, even if the read comes from a copy that is behind.; Learn
Redis: A very fast database that keeps data in memory. Often used as a cache, a counter store, or a leaderboard.; Learn
Rendezvous hashing: Score every node for a key and pick the highest. Losing a node moves only that node's keys, spread over all the others.; Learn
Replica: A copy of a database that follows the main one. It can answer reads and take over if the main one dies.; 1-min short Learn
Replication: Keeping copies of the same data on several machines, so you survive a failure and can spread out reads.; Learn
Replication lag: How far a replica is behind the main database. During that gap, a read from the replica can return old data.; Learn
Resharding: Moving data between shards when you add or remove machines. It is slow and risky, so pick the key well.; Learn
Reverse proxy: A server that sits in front of your servers, takes every request first, and passes it on to the right one.; 1-min short Learn
Rollup: A coarser copy of old data, such as one summary per minute or hour, kept for a long time at a fraction of the space.; 1-min short Learn
RPO: Recovery point objective: the most recent data you can afford to lose in a disaster, measured in time, like the last 5 minutes.; Learn
RTO: Recovery time objective: how long you can stay down before you must be back up.; Learn
Saga: A long task split into small steps, each with an "undo" step in case a later one fails. Used instead of one big all-or-nothing transaction.; 1-min short Learn
Scatter-gather: Sending a query to every shard and merging the answers. It works, but it is only as fast as the slowest shard.; Learn
Schema: The blueprint of a database: which tables and columns exist, and what kind of value each one holds.; Learn
Semaphore: A counter of permits. Up to N threads may hold one at once, and any thread can hand one back.; 1-min short Learn
Server-Sent Events (SSE): The server keeps one web response open and keeps pushing events to the browser. The browser reconnects by itself if it drops.; 1-min short Learn
Service discovery: How one service finds the live, healthy copies of another, using a registry or DNS.; 1-min short
Shard: One slice of a split-up database. Each shard keeps part of the data on its own machine.; Learn
Shard key: The field that decides which shard a row goes to, like user id. A poor choice piles load onto one shard.; 1-min short Learn
Sharding: Splitting a database into pieces by a key, each on its own machine, so no one machine holds everything.; 1-min short Learn
Single flight: When many requests miss for the same key at once, only the first loads it and the rest wait for that same result.; 1-min short Learn
Single point of failure (SPOF): One part that, if it breaks, takes the whole system down with it.; Learn
Skip list: Layers of linked lists where upper layers let you skip ahead, so search is fast and sorted ranges are easy to scan.; 1-min short
SLI / SLO / SLA: What you measure (SLI), the goal you set (SLO), and the promise you put in a contract (SLA).; 1-min short Learn
Snapshot isolation: Each transaction reads the data as it was when it started, and never waits for writers.; 1-min short Learn
Snowflake ID: A 64-bit id made from the time, a machine number and a counter, so ids come out roughly in time order.; 1-min short Learn
Sorted set (ZSET): A Redis structure that keeps items ordered by a score. Adding, finding a rank and fetching the top K are all fast.; 1-min short Learn
Split brain: After a network split, two parts of a cluster each think they are the leader and accept conflicting writes.; 1-min short
SQL: The standard language for asking a relational database (tables, rows, joins) for data or changing it.; Learn
Stampede: Many requests find the same cache entry missing at once and all hit the database together.; 1-min short Learn
State pattern: Each state is its own object that knows how to react to every event, replacing tangled if/else checks on a status field.; 1-min short Learn
Stateless: A server that remembers nothing between requests, so any copy of it can answer any request.; Learn
Sticky session: Sending a user's requests to the same server every time, because that server remembers them.; Learn
Stream processing: Handling data continuously as it arrives, with results in seconds instead of waiting for a nightly batch.; 1-min short
Stream watermark: A stream processor's guess that all events up to a certain time have arrived, so it can close that time window.; 1-min short
Tail latency: How slow the slowest few requests are, like the slowest 1 in 100. Users feel these even when the average looks fine.; 1-min short Learn
TCP: The usual way computers send data reliably: it sets up a connection first and resends anything that gets lost.; 1-min short Learn
TCP vs UDP: TCP delivers data reliably and in order, after a setup handshake. UDP just sends separate packets with no guarantees, but faster.; 1-min short
Thread pool: A fixed group of worker threads that take tasks from a queue, instead of starting a new thread for each task.; 1-min short Learn
Throughput: How much work a system finishes per second. Like cars passing a toll booth each minute.; Learn
Thundering herd: Lots of clients all acting at the same moment, like retrying or reconnecting together, and swamping a server.; Learn
Ticket server: A database counter that hands out ids, usually in blocks, so servers get unique numbers without asking for each one.; 1-min short Learn
Time to live (TTL): A timer on a stored item. When it runs out, the item is deleted, so stale copies don't stay forever.; Learn
Time-series database: A database for numbers that arrive with a timestamp, built to append fast and to compress neighbouring samples tightly.; 1-min short Learn
TIME-WAIT: The minute a closed TCP connection lingers so late packets cannot be mistaken for a new connection.; 1-min short Learn
TLB: A tiny, fast cache of recent address translations, so the CPU rarely has to read the page table.; 1-min short Learn
TLS: The encryption behind https. It scrambles traffic so nobody in between can read or change it.; Learn
Token bucket: A rate-limit method: a bucket gets tokens at a steady rate and each request takes one. No token, no request.; 1-min short Learn
Tombstone: A marker that says a value was deleted, kept so the delete reaches every copy and is not undone by repair.; Learn
Transaction: A group of database changes that all succeed together or not at all. Like a bank transfer: both sides, or neither.; Learn
Transcoding: Converting a video into several sizes and formats so every device can play a version that suits it.; 1-min short Learn
Two-phase commit (2PC): A coordinator asks everyone "can you commit?" and only if all say yes does it tell them to. If it dies midway, they wait.; 1-min short
Vector clock: A counter per machine attached to every update, so you can tell if one came before another or they happened independently.; 1-min short
Virtual memory: Each program sees its own private run of addresses, and the system quietly maps them to real memory.; 1-min short Learn
Virtual nodes: Extra points per server on the hash ring, so load spreads more evenly and a failure is shared among many servers.; 1-min short Learn
Webhook: A web address you give a provider so it calls you when something happens. It may call twice, so ignore repeats by event id.; 1-min short Learn
WebSocket: One connection that stays open, so browser and server can send each other messages at any time.; 1-min short Learn
Write skew: Two people check the same rule at once, both see it holds, both act, and together they break it.; 1-min short Learn
Write-ahead log (WAL): A log where changes are written to disk before they are confirmed, so after a crash the database can replay them.; 1-min short
Write-behind: Save to the cache right away and write to the database later, in batches. Fast, but a crash can lose recent writes.; Learn
Write-through: Every write goes to the cache and the database together, so the cache is never behind. Writes are a bit slower.; 1-min short Learn