Glossary

Every term is defined in the words of the board that teaches it. Select a board name to see the term in context.

902terms

134boards defining them

14tracks

902 of 902 shown

A

A*Graphs: Dijkstra + heuristic
ABAC Authorization and Identity: attribute-based
abort Transactions: roll back
Absorption Why the Ocean Is Blue: a material soaks up certain wavelengths (water eats red). Scattering = light bounces off in new directions (sky).
abstraction ladder Logic From Switches: each layer built from the one below and hiding it: transistor → gate → adder/register → CPU. Moore's law = transistors-per-chip roughly doubling every ~2 years.
access token Authorization and Identity: API access (authZ)
accidental complexity What a Data System Promises: complexity from the tools, not the problem
ACID Transactions: atomicity/consistency/isolation/durability
ACL Authorization and Identity: per-resource permission list
acquirer The Pipes: the shop's bank
activation function What a Neural Network Is: the non-linearity (ReLU / sigmoid / tanh)
active vs passive S2 - Build a Load Balancer: active: LB pings on a timer. passive: LB marks a backend DOWN after a real request to it fails.
actor / message passing Concurrency and the Hardware: share nothing, send messages
Adaptive immunity A Wanted Poster for Your Immune System: the slow-but-specific system that keeps MEMORY. mRNA vaccine = gives your cells the recipe to display the antigen themselves.
adjacency list Graphs: vertex→neighbours (O(V+E), sparse)
adjacency matrix Graphs: V×V grid (O(V²), O(1) edge test, dense)
ADT Linked Lists Stacks and Queues: abstract data type (interface, not storage)
AES-GCM Cryptography Foundations: authenticated encryption (confidentiality + integrity)
agent Agents and Tool Use: an LLM that uses tools in a loop toward a goal
agent loop Agents and Tool Use: think → act → observe → repeat (ReAct)
Aggregation The Statistic That Reverses Itself: squashing groups into one number. Simpson's paradox = when doing so reverses the real trend.
algorithmic bias Where Data Systems Are Heading: models encoding past discrimination
alignment From Transformer to LLM: teaching assistant behavior on top of the base modelAlso on Fine-tuning and Alignment
alignment tax Fine-tuning and Alignment: capability lost to safety
allowlist vs denylist Application Hardening: accept-known-good vs block-known-bad
ALU Logic From Switches: arithmetic logic unit (the adder + more)Also on The CPU
Amdahl's law Concurrency and the Hardware: speedup capped by the serial fraction
amortisation The Tank: each payment split into interest plus paying the loan downAlso on The Minimum Payment
amortized Complexity and Big-O: cost averaged over a sequence of ops
amp Why a Fuse Is a Weak Link on Purpose: how much charge flows past per second - volt = the push behind it - watt = volts x amps, the power an appliance pulls -
Amphiphile How Soap Destroys Germs: a molecule with a water-loving (hydrophilic) end and a water-hating/oil-loving (hydrophobic) end. Soap is one.
Amplitude Silence Built From More Noise: wave height = loudness. Phase = where in its cycle a wave is; 'out of phase' = shifted.
analogy arithmetic Tokens and Embeddings: king−man+woman≈queen
AND/OR/NOT/XOR Logic From Switches: both/either/invert/differ
Angular size The Moon Illusion: how wide something looks in degrees of your view (the moon is ~0.5 deg — always, high or low).
Anode/cathode A Battery Stores a Chemical Cliff: the two electrodes; the anode gives up electrons (oxidation), the cathode accepts them (reduction) = 'redox'.
Antigen A Wanted Poster for Your Immune System: a molecular 'face' the immune system recognises. Antibody = a protein that locks onto one specific antigen. B/T cells = the makers & killers.
API server Under the Hood: the single front door to the cluster | etcd = Raft-backed key-value store holding ALL cluster state | scheduler = assigns pods to nodes
Apparent distance / Ponzo illusion The Moon Illusion: the brain judging size by perceived distance & context, not the raw image.
APR The Tank: the yearly interest rate on a loanAlso on The Minimum Payment
arithmetic average The Borrowed Bucket: the plain mean of yearly returns
array Arrays and Strings: contiguous same-size slots (O(1) index)
ASCII Everything Is a Number: 1-byte character code (A=65)
ask The Water Market: the best price a seller will take
assembly The CPU: human-readable ISA
assume breach The Security Mindset: design for a compromised layerAlso on Anatomy of a Breach
AST How Code Becomes Execution: the parsed syntax tree
asymmetric / public-key Cryptography Foundations: a key pair (RSA/ECC, slow, key exchange)
async / event loop Concurrency and the Hardware: one thread, non-blocking I/O
atomic Concurrency and the Hardware: uninterruptible op
attack surface The Security Mindset: all points an attacker can interact with
attention matrix Attention and the Transformer: n×n who-attends-to-whom
auditing Where Data Systems Are Heading: verify, don't trust
authentication (authN)Authentication: prove who you are
authenticity The Security Mindset: provably who they claim
authorisation The Pipes: the issuer agrees to pay later, and holds the amount
authorization (authZ)Authentication: what you may doAlso on Authorization and Identity
automatic differentiation How It Learns: the framework doing it for you
autoregressive From Transformer to LLM: generate one token at a time, feeding output back
availability The Cut Phone Line: every request gets an answer
average O(1) vs worst O(n)Hashing: typical vs all-collide

B

B-tree Trees: high-fan-out balanced tree for disk (DDIA)
backoff The Bouncer at the Door: wait longer each retry (+ jitter)
backpropagation How It Learns: the chain rule computing every weight's gradient in one backward pass
backtracking Algorithm Design Patterns: incremental build + prune dead branches (DFS over solutions)
backward compat Encoding and Schema Change: new code reads old data
balanced Trees: h ≈ log n
BASE Transactions: the vague 'eventually consistent' opposite
base case Recursion and Dynamic Programming: the stopping condition
base model From Transformer to LLM: raw pretrained predictor (not an assistant)
Base pair You Are Written in 4 Letters: one rung (A-T or G-C). Genome = your full set of ~3B pairs. Codon = 3 letters = 1 amino acid.
Base rate The 99 Percent Test That Is Usually Wrong: how common it is BEFORE the test (1 in 1000). Ignore it and you'll fool yourself.
base vs aligned model Fine-tuning and Alignment: raw predictor vs assistant
batch / mini-batch How It Learns: a subset processed per step
batch vs service vs stream Batch Processing: offline bulk / online requests / near-real-time
Bayes' theorem The 99 Percent Test That Is Usually Wrong: the math that folds the base rate back in: P(sick | +) = real / (real + false).
bcrypt/scrypt/argon2 Authentication: slow, memory-hard password hashes
Bellman-Ford Graphs: handles negatives
best/average/worst case Complexity and Big-O: the input that gives least/typical/most cost
beta The Water Market: how much one asset moves with the whole market
BFS Graphs: level-order via a queue (shortest unweighted)
BFT When Machines Fail: tolerating it
bias What a Neural Network Is: a learned offsetAlso on Numbers for Real
bid The Water Market: the best price a buyer will pay
Big-O Complexity and Big-O: upper bound on growth (drop constants & lower terms)
Bijection (1-to-1)Some Infinities Are Bigger Than Others: a perfect pairing between two sets; if one exists, the sets are the SAME size — even if infinite.
binary Everything Is a Number: base 2Also on A Transistor Is Just a Switch
binary search Sorting and Searching: halve a SORTED range → O(log n)
binary tree Trees: ≤2 children
binary-search-on-the-answer Sorting and Searching: search a monotonic predicate (optimization)
bit Everything Is a Number: one 0/1 switch
Black-Scholes The Drought Right: the 1973 formula that prices it
blameless post-mortem Anatomy of a Breach: fix the bug class, not the person
blast radius Anatomy of a Breach: what one compromise can reach (limited by least privilege)
blocking I/O IO Interrupts and the Bus: thread parked until data arrives
Bloom filter Storage Engines: probabilistic 'maybe/definitely-not' setAlso on Hashing
bootloader (GRUB)IO Interrupts and the Bus: loads the kernel
boundary layer Why a Fan Cools You, Not the Room: the stuck film on every surface - wet-bulb = temp limit evaporation can reach
bounded input Batch Processing: finite dataset, so the job finishes
BPE Tokens and Embeddings: byte-pair encoding (merge frequent pairs → vocab)
branch prediction The CPU: guessing a jump to keep the pipeline full
break The Nightly Match: an entry with no matching twin
brittleness Agents and Tool Use: loops/stuck/compounding errors
brute force Algorithm Design Patterns: try all possibilities (correct baseline)
BST Trees: left < node < right (in-order = sorted)
bucket Hashing: an array slot
buffer overflow How Code Becomes Execution: writing past a buffer (overwrites the return address → exploit)
buffer pool The Map: page cache in RAM dirty = changed in RAM only checkpoint = 'all dirty pages <= this LSN are on disk' MVCC = readers get a snapshot, never block
build context The Recipe: the folder sent to the daemon | layer cache = reuse unchanged slabs | multi-stage = compile in one image, copy the artifact into a small one
bulk string S3 - Build a Redis Server: a binary-safe string sent as $<byte-count>\r\n<bytes>\r\n (can hold nulls, newlines, anything).
burst The Bouncer at the Door: a short spike
bus IO Interrupts and the Bus: shared wiring (memory bus, PCIe)
byte Everything Is a Number: 8 bits (0–255)
bytecode How Code Becomes Execution: portable mid-level code for a VM
Byzantine fault When Machines Fail: a node that lies/acts arbitrarily

C

C2 Anatomy of a Breach: command & control channel
CA Transport and Network Security: certificate authority
cache The Memory Hierarchy: small fast memory near the CPU
cache coherence (MESI)Concurrency and the Hardware: keeping cores' caches consistent
cache line The Memory Hierarchy: the ~64B unit moved between levelsAlso on Cache Line Life
Calibration The Less You Know the More Sure You Feel: how well your confidence matches your actual accuracy. Well-calibrated = sure when right, unsure when wrong.
call The Drought Right: the right to buy
call stack Linked Lists Stacks and Queues: the CPU/OS stack of frames
CALL/RET How Code Becomes Execution: push-addr-and-jump / pop-and-jump
canonicalize Application Hardening: normalize before checking
CAP The Cut Phone Line: under partition, pick A or C
capacity vs length Arrays and Strings: allocated vs used
CAS Concurrency and the Hardware: compare-and-swap (the lock-free primitive)
cash flow The Tank: what comes in minus what goes out
causal consistency Consistency and Consensus: preserve cause→effect order, cheaply
causal mask Attention and the Transformer: can only attend to earlier tokens (for generation)
CDC Replication: change data captureAlso on Stream Processing
certificate Cryptography Foundations: a public key signed by a CAAlso on Transport and Network Security
Certificate Transparency (CT)Transport and Network Security: public log of issued certs
chaining Hashing: bucket holds a linked list
Chinchilla From Transformer to LLM: balance params & data
Chirality / handedness Why a Mirror Flips Left-Right but Not Up-Down: 'left vs right' shape you can't rotate into its mirror (like gloves). Mirrors flip it.
chunk RAG: a passage-sized piece of a document
chunk/segment Adaptive Bitrate Streaming: a few seconds of video, one file . bitrate = bits/sec = quality . manifest = list of available qualities + chunks . rebuffer = playback stalls to refill . QoE = quality of experience
chunking strategy RAG: size / overlap / boundaries
CI The Assembly Line: build+test every commit | CD = auto deliver/deploy | runner = machine running the pipeline | artifact = the built image | gate = approval before prod
CIA triad The Security Mindset: confidentiality (secret) / integrity (untampered) / availability (up)
CISC vs RISC The CPU: complex-variable vs simple-fixed instructions
Claude Code / this assistant Agents and Tool Use: an agent (tools: read/write/bash/canvas + loop)
clearing The Pipes: working out who owes whom
clock Logic From Switches: the tick that advances flip-flopsAlso on The CPU
clock skew/drift When Machines Fail: clocks disagree/wander
cloud metadata endpoint Web Vulnerabilities: 169.254.169.254
cluster From One Crate to a Fleet: the machines together | node = one machine | pod = smallest unit (1+ containers) | control plane = the brain running the reconcile loop
ClusterIP/NodePort/LoadBalancer Getting Traffic In: exposure levels | Ingress = L7 routing rules | Ingress controller = the proxy | TLS termination = decrypt at the edge
Coastline paradox How Long Is a Coastline: the measured length keeps growing as your measuring stick shrinks, so there's no single true coastline length.
cold miss Cache Line Life: first touch, always RAM
collision Hashing: two keys → same bucket (inevitable, pigeonhole)
combinational Logic From Switches: output depends only on current inputs
commit Who Holds the Pen: stored on a majority, now safe
compaction Storage Engines: merge segments, drop stale versionsAlso on S1 - Build Your Own Database
compare-and-set (CAS)Transactions: write only if unchanged
comparison sort Sorting and Searching: orders by comparing pairs (≥ n log n)
compatibilism — free will Free Will Identity and the Self: uncoerced, not uncaused
compiler How Code Becomes Execution: source → machine code ahead of time
complete mediation The Security Mindset: check every accessAlso on Authorization and Identity
complete tree Trees: filled level-by-level (→ array storage)
compounding The Tank: growth on the growth
compression Every Sound Is Sine Waves: drop tones you won't miss.
concatenated index Storage Extras: several fields glued into one key (prefix queries only)
concurrency Concurrency and the Hardware: handling many tasks (structure)
ConfigMap Config, Secrets & Storage: non-secret config | Secret = sensitive (base64, guard w/ RBAC) | PVC = a claim for storage | PV = the real disk | StatefulSet = stable pods w/ own disks
Confounder (lurking variable)The Statistic That Reverses Itself: a hidden factor (stone size, department) that skews BOTH the groups and the outcome.
confused deputy Authorization and Identity: a privileged component tricked into acting for someone (CSRF/SSRF)Also on Web Vulnerabilities
consensus Consistency and Consensus: nodes agree on one value (agreement/integrity/validity/termination)Also on Who Holds the Pen
consent Where Data Systems Are Heading: meaningful, revocable permission to use data
consistency (linearizable)The Cut Phone Line: everyone sees the latest write, as if one copy
consistent hashing Splitting the Ledger: scheme where adding a shard moves only a small slice of keys, not all of them
Constitutional AI Fine-tuning and Alignment: self-critique against written principles (Anthropic)
constraint satisfaction Algorithm Design Patterns: find an assignment meeting all rules (backtracking)
containerd / runc Under the Hood: pull image / create the namespaced + cgrouped process | CNI = gives pods their IPs & networking | kube-proxy = makes Service VIPs work
context switch Processes Threads and the Kernel: save one thread's state, load another's (~µs + cache cost)
context window Inference: max tokens the model sees at once
controller manager Under the Hood: runs the reconcile loops | kubelet = the per-node agent that runs pods | CRI = container runtime interface
Convection Hot Water Can Freeze Faster Than Cold: heat moving via a fluid's own circulation. Evaporation = fastest molecules escaping as vapour, carrying heat off.
convergence How It Learns: the loss stops dropping
coordination service Consistency and Consensus: ZooKeeper/etcd, consensus-as-a-service
coordinator/participant Consistency and Consensus: the 2PC roles
core The CPU: one full CPU on the die
coroutine/channel Concurrency and the Hardware: cooperative concurrency (Go/CSP)
correlation The Water Market: how much two things move togetherAlso on One Cloud Many Rivers
cosine similarity Tokens and Embeddings: closeness by angle between vectorsAlso on RAG
Countable Some Infinities Are Bigger Than Others: pairs up with 1,2,3,... (aleph-0). Uncountable = provably can't (the reals, size c = the continuum).
counting/radix/bucket Sorting and Searching: non-comparison sorts (integer keys, beat the wall)
CRDT Replication: auto-merging data type
critical section Concurrency and the Hardware: code that must not interleave
CRL/OCSP Transport and Network Security: revocation checks
CRLF framing S3 - Build a Redis Server: every part ends in \r\n, so the parser always knows where a token stops -- no guessing.
cross-attention Attention and the Transformer: attend to another sequence
cross-shard query Splitting the Ledger: a question that must visit every shard
cryptographic hash Cryptography Foundations: one-way fixed digest (SHA-256; deterministic, collision-resistant, avalanche)
CSP Web Vulnerabilities: Content-Security-Policy (restrict script sources)
CSRF Web Vulnerabilities: your browser tricked into an authenticated request (fix: CSRF token / SameSite)
CVE Application Hardening: a known published vulnerability

D

daemon Running a Container: engine the CLI talks to | pull = fetch image from registry | volume = storage that outlives the box | exec = run a command in a live box
DAG Graphs: directed acyclic graph
data cube Storage Extras: precomputed aggregate grid
data integration Where Data Systems Are Heading: keeping many specialized stores in sync
data minimization Where Data Systems Are Heading: collect/keep less
data-intensive What a Data System Promises: bottleneck is data (amount/complexity/change), not CPU
dataflow engine (Spark/Flink)Batch Processing: one DAG, in-memory, no forced materialization
deadlock Transactions: mutual lock-waitAlso on Concurrency and the Hardware
declarative Data Models and Query Languages: say WHAT
decoder-only From Transformer to LLM: a stack of causal transformer blocks (GPT-style)
Decoherence Watch a Particle and It Changes: when contact with the environment (a detector) collapses that wave-ness into one definite outcome.
deep learning What a Neural Network Is: many hidden layers
defense in depth The Security Mindset: layered controlsAlso on Anatomy of a Breach
dense vector Tokens and Embeddings: all-numbers representation (vs one-hot)
density Why Ice Floats: mass per space
deque Linked Lists Stacks and Queues: double-ended queue (O(1) both ends)
dereference (*)How Code Becomes Execution: follow it
derivation function Where Data Systems Are Heading: app as input-streams → output-streams
derived view Where Data Systems Are Heading: a store computed FROM it (deterministic, rebuildable)
desired state From One Crate to a Fleet: what you declared (5 replicas) | reconcile = observe, compare, act -- repeat | scheduler = decides which node a pod lands on
device driver IO Interrupts and the Bus: kernel code speaking one device's protocol
DFS Graphs: deep-first via a stack/recursion
Diagonal argument Some Infinities Are Bigger Than Others: Cantor's proof: from any list of reals, build one it missed. So the reals outnumber the list.
Dielectric heating Why the Microwave Heats the Food Not the Plate: heat made by forcing polar molecules to flip in an oscillating field (the whole trick).
Diffie-Hellman Cryptography Foundations: shared secret over a public channel
digest Cryptography Foundations: the hash output
digital signature Cryptography Foundations: sign(private) / verify(public) → authenticity + non-repudiation
Dijkstra Graphs: min-cost path via a priority queue (non-negative weights, O((V+E)log V))
dimension d Tokens and Embeddings: size of the vector (768…12288)
directed vs undirected Graphs: one-way vs mutual
dirty read/write Transactions: seeing/overwriting uncommitted data
distributed filesystem (HDFS)Batch Processing: replicated blocks across shared-nothing nodes
distributed limit The Bouncer at the Door: shared redis count, usually approximate
distribution From Transformer to LLM: probabilities over the vocab
diversification One Cloud Many Rivers: owning many things so their bad years partly cancel
diversify The Tank: many small bets instead of one big one
divide & conquer Algorithm Design Patterns: split/solve/combine
DMA IO Interrupts and the Bus: device moves data to/from RAM itself, CPU freed
dominant term Complexity and Big-O: the fastest-growing part (all that survives Big-O)
Doppler effect Why the Siren Drops as It Passes: motion squeezes/stretches wavelength, so a moving source sounds/looks shifted.
Double helix You Are Written in 4 Letters: the twisted ladder shape; the two strands are mirror copies, which is how DNA duplicates.
double-entry The Pipes: every movement written twice, out of one account and into another
Downwash How Planes Actually Fly: the sheet of air a wing pushes down. Angle of attack = tilt between wing and oncoming air.
Drake equation Where Is Everybody: a chain of odds estimating alien civilizations. Great Filter = a barrier that keeps the galaxy empty.
DRAM The Memory Hierarchy: main memory (RAM)
dual write Where Data Systems Are Heading: the anti-pattern (drifts)
dwell time Anatomy of a Breach: how long undetected (often months)
dynamic array Arrays and Strings: auto-growing array (amortized O(1) append, l.01)
dynamic programming Recursion and Dynamic Programming: recursion + remembering solved subproblemsAlso on Algorithm Design Patterns
dynamic/short-lived secret Transport and Network Security: generated on demand, auto-expiring

E

ECB penguin Cryptography Foundations: why block mode matters
edit distance Storage Extras: # of edits between two strings (fuzzy match)
edit graph The Map: the grid where a diff is a path; diagonal edge = a matching line
edit script The Map: the list of insert/delete ops that turns old into newAlso on Two Files, One Question
Efference copy Why You Cannot Tickle Yourself: a duplicate of your motor command the brain keeps, to predict the result of your own action.
election timeout Who Holds the Pen: random wait before a follower runs
Electrolyte A Battery Stores a Chemical Cliff: the paste/liquid that lets IONS move inside but blocks electrons, forcing them through your device instead.
embedding Tokens and Embeddings: a token's learned vector (d dims)Also on RAG
embedding matrix Tokens and Embeddings: the vocab×d lookup table (learned)
Emergence No One Is in Charge - Emergence: complex global behaviour arising from simple local rules with no central control. Self-organisation is its engine.
emergent ability From Transformer to LLM: capability appearing abruptly at scale
encoding / serialization Encoding and Schema Change: object → bytes
end-to-end argument Where Data Systems Are Heading: enforce correctness at the endpoints, not just each hop
endianness Everything Is a Number: byte order of a multi-byte value (big = network order, little = x86)
Endogenous opioids The Sugar Pill That Actually Works: painkillers your own brain makes (endorphins). Naloxone = a drug that blocks them.
envelope encryption Transport and Network Security: a key encrypts data keys
Enzyme Why Onions Make You Cry: a protein that speeds a chemical reaction. Lachrymatory factor = the specific volatile gas that triggers tears.
Episodic memory Why You Cannot Remember Being a Baby: replayable personal events ('my 5th birthday'). Implicit memory = skills/associations you can't narrate (riding a bike).
epoch How It Learns: one pass over all data
epsilon compare Numbers for Real: |a-b| < tiny instead of ==
Escape velocity The Place Where Light Cannot Escape: speed needed to break free of gravity. If it exceeds light speed, nothing escapes.
event Stream Processing: an immutable record of something that happened
Event horizon The Place Where Light Cannot Escape: the boundary of no return. Singularity = the crushed point at the center.
event loop IO Interrupts and the Bus: one thread servicing many sockets
event sourcing Stream Processing: events as source of truth
event time vs processing time Stream Processing: when it happened vs when seen
eventual consistency Replication: copies converge given timeAlso on The Cut Phone Line
eviction Cache Line Life: something had to leave to make room
exactly-once Stream Processing: a replayed event has no extra effect (idempotence / transactions)
exchange argument Algorithm Design Patterns: the proof technique that a greedy choice is safe
exfiltration Anatomy of a Breach: stealing data out
Exponential / geometric growth Why You Cannot Fold Paper Past Seven Times: multiply by a fixed factor each step (here x2). Grows past intuition fast.
exposure The Netting Window: value promised but not yet moved
external sort Sorting and Searching: sorting data bigger than RAM

F

fact/dimension table Storage Extras: event row / its descriptors
factors Authentication: know/have/are
fail secure The Security Mindset: deny on error
fail securely Application Hardening: deny + generic error on failure
failover Replication: promote a new leader
failure What a Data System Promises: whole system stops
False positive The 99 Percent Test That Is Usually Wrong: test says + but you're fine. Rare disease + big crowd = these dominate.
fan-out What a Data System Promises: reaching many targets from one op
fault What a Data System Promises: one part wrong
fault-tolerant What a Data System Promises: a fault never becomes a failure
feature What a Neural Network Is: a learned intermediate representation (edges, words)
feed-forward (FFN/MLP)Attention and the Transformer: the per-token 'thinking' layer
feedback loop Where Data Systems Are Heading: a prediction that makes itself come true
fencing token When Machines Fail: a rising number the resource checks to reject stale holders
fetch-decode-execute The CPU: the CPU's core loop
field tag Encoding and Schema Change: a field's stable number (Protobuf/Thrift)
fine-tuning Fine-tuning and Alignment: extra training on a specific task
firmware (BIOS/UEFI)IO Interrupts and the Bus: first code at power-on
fixed / sliding window The Bouncer at the Door: count per clock-bucket / over a moving window
fixed vs variable window Arrays and Strings: constant size vs condition-driven
fixed-partition-count / dynamic partitioning Partitioning: pre-split many / split-on-growth
flags The CPU: status bits set by compares
flip-flop / latch Logic From Switches: 1 bit of memory via feedback
floating point Numbers for Real: binary scientific notation (sign
Floyd's cycle detection Arrays and Strings: fast/slow pointers
FLP Consistency and Consensus: no async consensus can always terminate with 1 crash
Fold ratio Why You Cannot Fold Paper Past Seven Times: length lost to the rounded bend per fold; it's what makes the length blow up faster than 2^n alone.
fork/exec Processes Threads and the Kernel: clone a process / replace its program
forward compat Encoding and Schema Change: old code reads new data
Forward model Why You Cannot Tickle Yourself: the brain's simulator that turns that copy into an expected sensation. Cerebellum = where it runs.
forward pass What a Neural Network Is: compute output from input
forward secrecy Cryptography Foundations: past traffic stays safe if a key leaks
Fractal How Long Is a Coastline: a shape with detail at every scale that looks (statistically) like itself when magnified. Coined by Mandelbrot, 1975.
Front-back (depth) reversal Why a Mirror Flips Left-Right but Not Up-Down: the only thing a flat mirror does: it swaps toward-you with away-from-you.
full adder Logic From Switches: adds a carry-in
full-text index Storage Extras: search by words
fully-connected (dense)What a Neural Network Is: every neuron wired to the next layer
functionalism — mind The Mind-Body Problem: functional/causal role, not the stuff
fuse Why a Fuse Is a Weak Link on Purpose: a deliberate thin spot in the circuit that melts first - rated = the current a part is made to carry without getting dangerously hot
future The Water Market: a deal to trade later at a price fixed now

G

GABA / NMDA receptors The Off Switch for You - Anaesthesia: the brain's main 'brake' and 'accelerator' signalling; anaesthetics push the brake and cut the gas.
GC How Code Becomes Execution: garbage collector (auto-frees the heap)
Gene You Are Written in 4 Letters: a stretch of DNA that codes one protein. Only ~1-2% of your genome is genes; the rest regulates & more.
generalization How It Learns: working on unseen data (the goal)
global (term-partitioned) index Partitioning: index split by term (cross-partition writes)
gossip Partitioning: nodes share the map peer-to-peer
gradient How It Learns: slope of the loss w.r.t. the weights
gradient descent How It Learns: step downhill to reduce loss
greedy Inference: always take the top tokenAlso on Recursion and Dynamic Programming, Algorithm Design Patterns
gross settlement The Netting Window: every payment moved on its own
grounding Inference: RAG/tools to tie answers to real sourcesAlso on RAG
grounding/computation/action/memory Agents and Tool Use: what tools add
guardrails Agents and Tool Use: limits, human approval, verification

H

half adder Logic From Switches: XOR(sum)+AND(carry)
hallucination Inference: confident, fluent, but false output
handshake Transport and Network Security: authenticate + agree a key
happens-before Concurrency and the Hardware: the visibility guarantee you can rely on
hardening Application Hardening: l.01 principles applied everywhere
harness Agents and Tool Use: the code around the model that executes tools
hash function Hashing: arbitrary input → fixed-size int (fast, uniform, deterministic)
hash join Hashing: build-a-map + probe
hash set / map Hashing: keys only / key→value
hash table Hashing: key→index→bucket store
HashDoS Hashing: adversarial colliding keys forcing O(n)
head/tail Linked Lists Stacks and Queues: first/last node
health check S2 - Build a Load Balancer: a periodic probe; a backend that fails is marked DOWN and skipped until it passes again (self-healing).
heap Trees: complete tree, parent≤children (min) or ≥ (max)Also on How Code Becomes Execution
heapsort Sorting and Searching: repeated extract-max (in-place)
heartbeat Who Holds the Pen: leader's 'still alive' ping
height h Trees: longest root-to-leaf path
hexadecimal Everything Is a Number: base 16 (0–F), 1 hex digit = 4 bits (a nibble), 2 hex = 1 byte
HHH Fine-tuning and Alignment: helpful, harmless, honest
Hippocampus Why You Spend a Third of Life Unconscious: the brain's memory-filer. Glymphatic system = the fluid 'plumbing' that rinses brain waste, mostly during deep sleep.
hit rate The Memory Hierarchy: fraction of hits
hit/miss The Memory Hierarchy: found in cache / had to go slower
HMAC Cryptography Foundations: hash + secret key (integrity + authenticity)
hot shard Splitting the Ledger: one overloaded slice
hot spot / hot key Partitioning: an overloaded partition / single key
HSTS Transport and Network Security: force-HTTPS header
httpOnly / Secure / SameSite Authentication: cookie flags (XSS-safe / HTTPS-only / CSRF-blocking)
HTTPS Transport and Network Security: HTTP over TLS
hybrid search RAG: keyword + vector

I

I/O-bound vs CPU-bound IO Interrupts and the Bus: waiting on devices vs on compute
IaC IaC and GitOps: infra as files | Terraform = provision cloud | Helm = package k8s | GitOps = git as source of truth + a controller reconciles | drift = reality diverging from declared
ID token Authorization and Identity: who the user is (authN)
idempotence Encoding and Schema Change: a retried op is safe to apply twice
idempotency id Where Data Systems Are Heading: a request id that makes retries safe
idiosyncratic risk One Cloud Many Rivers: the part one river has alone
IDL Encoding and Schema Change: interface definition language (the schema)
IDOR Authorization and Identity: accessing another user's object by changing an id (authN-but-not-authZ)
IEEE 754 Numbers for Real: the standard (float32 = 1/8/23, float64 = 1/11/52)
image The Shipping Container: sealed box on disk | container = image running | Dockerfile = the recipe to build it | registry (Docker Hub) = the box warehouse (push / pull)
immediate The CPU: a literal value baked into an instruction
immutable Arrays and Strings: can't edit in place (→ += in a loop is O(n²))
impedance mismatch Data Models and Query Languages: app objects don't match flat tables (ORMs bridge it)
imperative Data Models and Query Languages: say HOW
in-context learning From Transformer to LLM: learning from prompt examples, no weight change
in-degree Graphs: incoming edges
in-place Complexity and Big-O: uses O(1) extra spaceAlso on Arrays and Strings, Sorting and Searching
incident response Anatomy of a Breach: contain→eradicate→recover→learn
index Storage Engines: derived read-accelerator (slows writes)
index fund The Tank: owning every share in a market at once, at low cost
Inf Numbers for Real: overflowed-to-infinity
Infantile amnesia Why You Cannot Remember Being a Baby: the normal absence of episodic memories from early childhood. Neurogenesis = the brain making new neurons.
inference Inference: generating text from the trained model
inflation The Tank: prices rising, so stored water shrinks
init / systemd IO Interrupts and the Bus: PID 1, starts everything
init/systemd Processes Threads and the Kernel: PID 1, root of the process tree
initial access Anatomy of a Breach: the foothold (phishing / exploit / stolen creds)
injection Web Vulnerabilities: untrusted input parsed as code
input validation Application Hardening: check untrusted input at the boundary
input-sensitive Complexity and Big-O: cost depends on which input, not just its size
instruction tuning Fine-tuning and Alignment: SFT across many task types
Integration / connectivity The Off Switch for You - Anaesthesia: brain regions exchanging signals to form one experience. Hard problem = why physical activity feels like anything.
interface vs implementation Linked Lists Stacks and Queues: the contract vs the swappable backing structure
interpreter How Code Becomes Execution: runs source line-by-line
interrupt IO Interrupts and the Bus: a device signal that yanks the CPU to a handler
invariant Sorting and Searching: the loop condition that keeps the answer in range (off-by-one killer)
IPC The CPU: instructions per cycle
ISA The CPU: instruction set architecture (the CPU's opcode menu; x86 / ARM / RISC-V)
ISR / interrupt handler IO Interrupts and the Bus: the code that runs on an interrupt
iss/sub/aud OIDC - Passport and Stamp-Book: issuer/subject/audience
issuer The Pipes: the cardholder's bank

J

jargon How Learning Sticks: the exact gap. teaching is the most demanding retrieval.
JIT How Code Becomes Execution: compile hot paths to native at runtime
JWT OIDC - Passport and Stamp-Book: the signed tokenAlso on Authentication

K

K8s Secret Transport and Network Security: base64 (not encryption!)
Kelly fraction The Borrowed Bucket: the leverage that maximises long-run growth
kernel Processes Threads and the Kernel: the privileged core of the OS
key distribution Cryptography Foundations: the problem asymmetric solves
kill chain Anatomy of a Breach: the ordered stages of an intrusion (MITRE ATT&CK / Lockheed)
KL penalty Fine-tuning and Alignment: stay close to the original model
KMP Arrays and Strings: O(n+m) substring search
KMS/HSM Cryptography Foundations: key storage
knapsack / edit distance / LCS Recursion and Dynamic Programming: classic DP problems
KV cache Inference: stored Keys/Values of past tokens (speeds generation)

L

Lamport timestamp Consistency and Consensus: a counter giving causal total order
latency vs bandwidth The Memory Hierarchy: per-access delay vs throughput
latent heat Why a Fan Cools You, Not the Room: energy carried by phase change
lateral movement Anatomy of a Breach: spreading to other systems
layer What a Neural Network Is: a row of neurons
layer norm Attention and the Transformer: stabilizes activations
LCS Two Files, One Question: longest common subsequence = the most lines both files agree on, in order.
LCS (longest common subsequence)The Map: the longest set of lines, in order, present in both
leader / follower / candidate Who Holds the Pen: the three Raft roles
leader/follower Replication: master/replica
leaderless Replication: no primary (Dynamo)
Leading digit Real Numbers Start With 1 Too Often: the first non-zero digit (the '3' in 342 or 0.0389). Benford predicts how often each 1-9 appears.
leaky bucket The Bouncer at the Door: queue drains at a constant rate
learning rate How It Learns: step size
lease When Machines Fail: a time-limited lock
least privilege The Security Mindset: minimum access needed
ledger The Pipes: the book of entries
lessons written AS explanations How Learning Sticks: the FEYNMAN technique, baked in
Let's Encrypt / ACME Transport and Network Security: free automated certs
Levenshtein Two Files, One Question: edit distance WITH substitution allowed (cost 1). git does not use it.
leverage The Water Market: investing with borrowed moneyAlso on The Borrowed Bucket
LIFO/FIFO Linked Lists Stacks and Queues: last-in-first-out / first-in-first-out
Lift How Planes Actually Fly: upward force = the rate of downward momentum the wing hands to the air (Newton's 3rd law).
light Your Phone Runs on Einstein: 30 cm / ns.
linearithmic Complexity and Big-O: n log n
linearizability Consistency and Consensus: act like one copy, reads always see the latest write (recency)
linked list Linked Lists Stacks and Queues: nodes + next pointers (non-contiguous)
linker How Code Becomes Execution: joins code + libraries
liquidity The Tank: how fast you can get it out without a lossAlso on The Netting Window
listener rule The Two Planes - Permission vs Network: which URL goes to which target group
liveness Self-Healing and Autoscaling: restart if dead | readiness = route only if ready | HPA = auto replica count from a metric | rollout undo = rollback | maxSurge = extra pods mid-update
load balancing vs fan-out Stream Processing: share work vs everyone-gets-all
load factor α Hashing: entries/buckets
load parameter What a Data System Promises: the number that describes load (e.g. fan-out)
local (document-partitioned) index Partitioning: each partition indexes its own docs (scatter/gather reads)
locality Data Models and Query Languages: related data stored together
lockfile Application Hardening: pinned dependency versions
log compaction Stream Processing: keep latest value per key
log entry Who Holds the Pen: one command in order
log-based broker (Kafka)Stream Processing: append-only, retained, replayable log
log-structured S1 - Build Your Own Database: never edit in place; only append. Reads follow the index, not a scan.
Logarithmic time Why Time Speeds Up as You Age: equal FELT durations map to equal RATIOS of age (doublings), not equal counts of years.
logic gate Logic From Switches: a circuit computing a boolean rule
logical clock When Machines Fail: order by causality not time (Lamport/version vector)
logits From Transformer to LLM: raw pre-softmax scores over the vocabAlso on Inference
long-run (geometric) growth The Borrowed Bucket: what actually compounds
LoRA Fine-tuning and Alignment: cheap parameter-efficient fine-tuning (small adapters)
loss / cost function How It Learns: how wrong the prediction is (cross-entropy, MSE)
Lossy compression The Map Is Not the Territory: keeping the useful signal, discarding the rest. No model is complete — see also Godel (board 12).
lost update Transactions: one write clobbers another
LRU/associativity The Memory Hierarchy: the cache's eviction policy
LSM Storage Engines: log-structured merge-tree
Lucene Storage Extras: the search library behind Elasticsearch/Solr
LWW Replication: last-write-wins

M

Magnetron Why the Microwave Heats the Food Not the Plate: the tube that generates the waves. Standing wave = a fixed pattern of hot/cold spots from reflections.
mantissa Numbers for Real: the significant digits
many-to-one / many-to-many Data Models and Query Languages: shared references (people → one company) — relational/graph turf
Map / territory The Map Is Not the Territory: the model vs the reality it represents (Alfred Korzybski, 1931). Abstraction = deliberately dropping detail.
map-side (broadcast hash) join Batch Processing: small table in every mapper's RAM
MapReduce Batch Processing: map → shuffle(sort) → reduce over a cluster
margin The Borrowed Bucket: the share of your own money the lender insists on
margin call The Borrowed Bucket: the demand to top up, or be sold out
masked variable Application Hardening: hidden in logs
Master theorem Complexity and Big-O: recurrence → complexityAlso on Algorithm Design Patterns
materialization Batch Processing: writing full intermediate output to disk
materialized view Storage Extras: cached-on-disk query result
matrix multiply What a Neural Network Is: a layer's core op (→ GPUs)
MCP (Model Context Protocol)Agents and Tool Use: a standard tool/data interface ('USB-C for AI')
memoization Complexity and Big-O: cache results to trade space for timeAlso on Recursion and Dynamic Programming
memory barrier/fence Concurrency and the Hardware: force write visibility & ordering
memory leak How Code Becomes Execution: never freeing
memory reordering Concurrency and the Hardware: CPU/compiler reorders for speed
memory wall The Memory Hierarchy: CPU-vs-RAM speed gap
memory-mapped I/O IO Interrupts and the Bus: device registers appear as memory addresses
memtable Storage Engines: in-RAM sorted buffer
merge sort Sorting and Searching: split/sort/merge (stable, O(n) space)
message broker Encoding and Schema Change: async queue between services (Kafka, RabbitMQ)Also on Stream Processing
Metacognition The Less You Know the More Sure You Feel: thinking about your own thinking / judging your own ability. The core skill Dunning-Kruger says beginners lack.
MFA Authentication: 2+ factors
Micelle How Soap Destroys Germs: a ball of soap molecules trapping oil inside. Lipid envelope = the fatty outer coat of many viruses that soap dissolves.
microbatch / checkpoint Stream Processing: recovery techniques
Microwave Why the Microwave Heats the Food Not the Plate: an invisible radio/light wave. Polar molecule = one with a + end and a - end (like water).
minimum payment The Minimum Payment: the smallest payment the lender accepts; often set near the interest, which is why it can take decades
MITM Transport and Network Security: man-in-the-middle
MLP What a Neural Network Is: multi-layer perceptron
MMU + page table Processes Threads and the Kernel: the translator
MMU/page table The Memory Hierarchy: the address translator
modular arithmetic Numbers for Real: clock/wheel wraparound
monotonic deque Linked Lists Stacks and Queues: keeps a sorted window (sliding-window-max)
monthly rate The Minimum Payment: APR / 12 (2%)
Mpemba effect Hot Water Can Freeze Faster Than Cold: the observation that, in some conditions, initially HOTTER water freezes sooner than cooler water.
MPP Partitioning: massively parallel processing (analytic queries)
MST Graphs: minimum spanning tree (Kruskal/Prim)
mTLS Transport and Network Security: both sides present certs
MTTD/MTTR Anatomy of a Breach: mean time to detect / respond
multi-agent Agents and Tool Use: specialized agents collaborating / dispatched in parallel
multi-dimensional index Storage Extras: query several ranges at once (R-tree)
multi-head Attention and the Transformer: parallel attentions capturing different relations
multi-leader Replication: many writable copies
mutex/lock Concurrency and the Hardware: serializes a critical section
mutual exclusion Concurrency and the Hardware: one-at-a-time

N

namespaces + cgroups Processes Threads and the Kernel: the kernel features that make a container
NaN Numbers for Real: 'not a number', ≠ itself
NAND (NOT-AND)Logic From Switches: UNIVERSAL — builds every other gate
narrow waist Where Data Systems Are Heading: the shared log/dataflow interface
nearest-neighbour / ANN RAG: find the closest vectors fast (HNSW/IVF)
net settlement The Netting Window: only each bank's difference moved, later
netting The Pipes: paying only the differenceAlso on The Netting Window
network The Pipes: the rails between them
neuron What a Neural Network Is: weighted sum of inputs + bias, through an activation
next-token prediction From Transformer to LLM: the objective (predict the following token)
nibble Everything Is a Number: 4 bits
no security through obscurity (Kerckhoffs)The Security Mindset: assume the design is known
node Linked Lists Stacks and Queues: value + pointer(s)
non-blocking / async I/O IO Interrupts and the Bus: fire many, poll readiness (epoll/io_uring)
non-linearity What a Neural Network Is: the kink that stops layers collapsing into one
Non-measurable set Cut One Ball Into Two Identical Balls: a point-cloud so pathological it has no definable volume. Axiom of Choice = pick one item from each of infinitely many sets at once. Rigid motion = rotate/slide only (no stretching).
non-repudiation The Security Mindset: can't deny you did it
nonce Cryptography Foundations: a number used once
normalization Data Models and Query Languages: store each fact once, reference it by id
NREM vs REM Why You Spend a Third of Life Unconscious: deep dreamless stages vs Rapid-Eye-Movement (vivid dreams). Slow-wave = the deepest, most restorative NREM.
NUMA The Memory Hierarchy: memory closer to some cores than others (many-socket)

O

O(n²)Attention and the Transformer: attention's cost in sequence length (the context bottleneck)
OAuth 2.0 Authorization and Identity: delegated authorization (scoped ACCESS TOKEN, no password shared)
observability The Watchtower: infer internal state from outputs | SLI/SLO = measured 'good' & its target | error budget = allowed failure | golden signals = latency/traffic/errors/saturation
offset Stream Processing: a consumer's positionAlso on S1 - Build Your Own Database
OIDC Authorization and Identity: OAuth + an ID TOKEN (authentication / 'login with…')
OIDC provider The Two Planes - Permission vs Network: whose tokens this acct trusts
OIDC-to-cloud Application Hardening: short-lived CI creds, no static keys
one-to-many Data Models and Query Languages: a tree (résumé → jobs)
opcode The CPU: which operation
open addressing Hashing: probe for the next free slot (linear/quadratic/double hash)
operability / simplicity / evolvability What a Data System Promises: the three faces of maintainability
operand The CPU: what it acts on (register / immediate / address)
Optic disc / blind spot You Have a Hole in Your Vision: the patch of retina with no photoreceptors, where the optic nerve exits the eye.
optimal substructure Recursion and Dynamic Programming: optimum built from sub-optima
optimizer (SGD/Adam)How It Learns: the downhill-stepping algorithm
option The Water Market: a paid right to trade at a fixed priceAlso on The Drought Right
out-of-order The CPU: reorder to avoid stalls
output encoding Web Vulnerabilities: escape input to render as textAlso on Application Hardening
overfitting How It Learns: memorizing train data, failing on new
overflow Numbers for Real: a result too big for the width, wraps around (mod 2^n)
overlapping subproblems Recursion and Dynamic Programming: the same call recurs (the waste DP removes)
OWASP Top 10 Web Vulnerabilities: the canonical web-risk list

P

P(d)Real Numbers Start With 1 Too Often: log10(1+1/d): digit 1 -> 30.1%, 2 -> 17.6%, ... 9 -> 4.6%. Holds across many independent real-world datasets.
PACELC The Cut Phone Line: adds 'else: latency vs consistency'
page The Map: the 8KB unit of ALL I/O tuple = one row version WAL = write-ahead log, the append-only truth LSN = a byte position in the WAL
page (~4KB) / frame Processes Threads and the Kernel: unit of virtual / physical memory
page fault Processes Threads and the Kernel: touched a not-in-RAM page
pairs The Birthday Paradox: n(n-1)/2
parallelism Concurrency and the Hardware: running many at once (needs cores)
parameterized query / prepared statement Web Vulnerabilities: bind data separately from the query (the fix)
parameters What a Neural Network Is: all weights + biases (LLMs: billions)
parameters / data / compute From Transformer to LLM: the three scale levers
parameters/weights How It Learns: what's being tuned
Parity Why a Mirror Flips Left-Right but Not Up-Down: the physics word for a mirror-flip of space; it's why the reflection is a genuine 'opposite-handed' you.
partial failure When Machines Fail: some parts broken, others fine
partial vs total order Consistency and Consensus: some-events-unordered vs one-timeline
partition The Cut Phone Line: the network drops messages between nodes (NOT a crash)
partition / shard Partitioning: a slice of the data
Paxos Who Holds the Pen: the original (harder) consensus protocol
Paxos/Raft/Zab Consistency and Consensus: consensus algorithms
PC (program counter)The CPU: address of the next instruction
pepper Authentication: app-wide secret added before hashing
per-key The Bouncer at the Door: tracked per user/IP/API-key
percentile pN What a Data System Promises: N% of requests are faster
persistence Anatomy of a Breach: surviving reboots/rotations
pgvector/Pinecone/Chroma RAG: vector-DB options
phantom Transactions: a write changes another query's result
Photoreceptors You Have a Hole in Your Vision: the rod & cone cells that actually catch light. Filling-in = the brain guessing the missing area.
PID Processes Threads and the Kernel: process id
pipelining The CPU: overlapping instruction stages
pivot/partition Sorting and Searching: quicksort's split step
PKI Transport and Network Security: public-key infrastructure
Placebo The Sugar Pill That Actually Works: an inert treatment that heals via expectation. Nocebo = expectation of harm causing real harm.
planning Agents and Tool Use: decompose a goal into steps
pod The Harbor Master: 1+ containers together | replicaset = keeps N pods | deployment = manages replicasets + rollouts | service = stable name load-balancing pods | label = the glue
pointer How Code Becomes Execution: a variable holding an address
policy The Two Planes - Permission vs Network: what it opens
polling IO Interrupts and the Bus: busy-asking if a device is ready (wasteful)
positional encoding Tokens and Embeddings: added so order is knownAlso on Attention and the Transformer
PPO Fine-tuning and Alignment: the RL algorithm
predicate lock Transactions: a lock on a search condition
preemption Processes Threads and the Kernel: interrupting a thread on its time slice
prefetch The Memory Hierarchy: CPU guesses & preloads the next lineAlso on Cache Line Life
prefill vs decode Inference: process the prompt vs generate token-by-token
prefix sum Arrays and Strings: cumulative array for O(1) range queries
premium The Drought Right: what the right costs today
present value The Tank: what water promised later is worth today
pretraining From Transformer to LLM: the big self-supervised training run
principal The Minimum Payment: what you still owe before interestAlso on Compound Interest The 8th Wonder
priority queue Linked Lists Stacks and Queues: highest-priority-first (→ heap, l.05)Also on Trees
privilege escalation Anatomy of a Breach: gaining higher rights
process Processes Threads and the Kernel: isolated running program (own address space)
process pause When Machines Fail: a thread frozen mid-run (GC, VM, paging)
producer/consumer Stream Processing: writer/reader
projection Storage Extras: a copy of column data in a specific sort order
property graph Data Models and Query Languages: Neo4j + Cypher
Proportional (Janet) theory Why Time Speeds Up as You Age: a span feels like its share of your total life, so years shrink as you age.
pruning Algorithm Design Patterns: cutting a branch that can't succeed
put The Drought Right: the right to sell

Q

query rewriting RAG: reformulate the question for better recall
Query/Key/Value Attention and the Transformer: 'what I seek / what I offer / what I give'
queue Linked Lists Stacks and Queues: FIFO (enqueue/dequeue, O(1))
quicksort Sorting and Searching: pivot + partition (in-place, O(n²) worst)
quorum Replication: w + r > nAlso on When Machines Fail
quorum / majority Who Holds the Pen: N/2+1

R

R-tree Storage Extras: geospatial index structure
race condition Concurrency and the Hardware: result depends on timing
Raft Who Holds the Pen: a readable consensus algorithm
RAG RAG: retrieval-augmented generation (retrieve real docs → answer from them)
rainbow table Authentication: precomputed hash→password lookup
range vs hash partitioning Partitioning: sorted intervals vs scrambleAlso on Splitting the Ledger
rate limit The Bouncer at the Door: cap on requests per key per window
RBAC Authorization and Identity: role-based
RDD / lineage Batch Processing: recompute lost data from its recipe
re-ranking RAG: reorder retrieved results by relevance
read committed Transactions: no dirty reads/writes
read repair / anti-entropy Replication: fix stale copies on-read / in-background
read skew Transactions: inconsistent multi-read
read-your-writes / monotonic / consistent-prefix Replication: the three lag-read guarantees
ReBAC Authorization and Identity: relationship-based (Zanzibar)
rebalancing Partitioning: redistribute partitions across nodes
recon Anatomy of a Breach: studying the target
reconciliation The Pipes: checking your book against theirsAlso on The Nightly Match
recurrence Recursion and Dynamic Programming: how a state depends on smaller states
recursion Recursion and Dynamic Programming: a function calling itself on a smaller input
recursion tree Recursion and Dynamic Programming: the tree of calls
Redshift Why the Siren Drops as It Passes: light stretched (moving away). Blueshift = squeezed (coming closer). Cosmic speedometer.
reduce-side (sort-merge) join Batch Processing: join in the reducer after a shuffle
refresh token Authentication: re-issues short-lived access tokens
refrigerant Cold Is a Lie: the loop liquid, chosen for its boiling point - latent heat = energy absorbed/released at
register The CPU: a tiny in-CPU storage slot
Regression to the mean The Less You Know the More Sure You Feel: a statistical pull toward average that explains PART (not all) of the measured effect.
regularization How It Learns: dropout / weight decay to prevent overfitting
relation/tuple Data Models and Query Languages: table/row
relax an edge Graphs: update a node's best-known distance
reliabilism — knowledge What Is Knowledge: belief from a reliable process
reliability Agents and Tool Use: the current frontier
ReLU What a Neural Network Is: max(0,x)
replication lag Replication: how far a follower trails
request routing Partitioning: find the node for a key
resharding Splitting the Ledger: change shard count, re-file data
residual connection Attention and the Transformer: add the input back (deep-net enabler)
resize/rehash Hashing: grow the table & re-place keys (amortized O(1))
Resonance Why the Microwave Heats the Food Not the Plate: a system's natural 'easy' frequency; here NOT used, so the waves reach the middle instead of the skin.
RESP S3 - Build a Redis Server: REdis Serialization Protocol: a tiny text protocol; type is the first byte, strings are length-prefixed.
response time What a Data System Promises: what the client sees (service time + queueing + network)
REST Encoding and Schema Change: resource + HTTP-verb style
retrieval hit-rate & faithfulness RAG: how you evaluate RAG
Retrospective duration Why Time Speeds Up as You Age: your brain reconstructs 'how long' from memory density, so novelty literally lengthens time.
Retry-After The Bouncer at the Door: when to try again
reverse proxy S2 - Build a Load Balancer: a server that forwards a client's request to a backend and relays the reply; the client never talks to the backend directly.
reward hacking Fine-tuning and Alignment: over-optimizing the proxy
reward model Fine-tuning and Alignment: predicts human preference score
RGB Everything Is a Number: red/green/blue, one byte each
ring / circular buffer Linked Lists Stacks and Queues: array with wrapping head+tail (O(1) dequeue)
ripple-carry Logic From Switches: chained full adders
RLAIF Fine-tuning and Alignment: feedback from an AI instead of humans
RLHF Fine-tuning and Alignment: reinforcement learning from human feedback
rolling array Recursion and Dynamic Programming: keep only the recent rows to cut space
root / intermediate / leaf Transport and Network Security: the trust chain
rotation Trees: local re-link to rebalance
round-robin S2 - Build a Load Balancer: hand each new request to the next backend in turn → even spread with zero per-request state.
rounding error Numbers for Real: a value not exactly representable in binary (0.1)
RPC Encoding and Schema Change: remote call as a local one (gRPC)
RSA / ECC Cryptography Foundations: asymmetric algorithms
RTGS The Netting Window: real-time gross settlement
Rule of 72 Compound Interest The 8th Wonder: quick doubling-time = 72 / annual-% . Works for growth AND debt.

S

Saccades You Have a Hole in Your Vision: tiny constant eye-jumps; combined with filling-in, they hide the hole and stitch a seamless world.
safety vs liveness When Machines Fail: nothing-bad-ever vs something-good-eventually
salt Authentication: random per-user value defeating rainbow tables
salting Batch Processing: split a hot key
sampling Inference: picking the next token from the distribution
sanitization Web Vulnerabilities: strip dangerous markup
SAST/DAST Application Hardening: static / dynamic app security testing
SBOM Application Hardening: software bill of materials
Scale invariance Real Numbers Start With 1 Too Often: the pattern looks the same in dollars, euros, or feet — a hallmark of log-distributed data.
scaled dot-product attention Attention and the Transformer: softmax(QKᵀ/√d)V
scaling laws From Transformer to LLM: loss falls predictably with params/data/compute
scheduler Processes Threads and the Kernel: picks who runs
schema evolution Encoding and Schema Change: changing schema without breakage
schema registry Encoding and Schema Change: versioned schema store
schema-on-read Data Models and Query Languages: structure interpreted at read (flexible)
schema-on-write Data Models and Query Languages: DB enforces structure at write
Schwarzschild radius The Place Where Light Cannot Escape: how small you must squeeze a mass to make it a black hole (Sun -> ~3 km; Earth -> ~9 mm).
scope Authorization and Identity: a token's permission
secondary index Partitioning: lookup by a non-key field
secret scanning Application Hardening: detect committed keys (trufflehog/gitleaks)
secrets manager Transport and Network Security: Vault / KMS (encrypted, access-controlled, rotated)
security headers Application Hardening: CSP/HSTS/X-Frame-Options/nosniff
security mindset The Security Mindset: think like an attacker
security misconfiguration Application Hardening: unsafe defaults/settings (OWASP)
segfault How Code Becomes Execution: touching memory you don't ownAlso on Processes Threads and the Kernel
segmentation Anatomy of a Breach: isolate networks so lateral movement fails
self-attention Attention and the Transformer: each token attends to the others in its own sequence
self-balancing BST (AVL / red-black)Trees: rotations keep O(log n) worst case
Self-similarity How Long Is a Coastline: the part resembles the whole. Fractal dimension = a fraction (e.g. 1.25) measuring how 'rough' or space-filling it is.
self-supervised From Transformer to LLM: labels come free from the text itself
semantic search Tokens and Embeddings: nearest-vector retrieval (RAG, l.08)
Sensory attenuation Why You Cannot Tickle Yourself: dialling DOWN sensations you caused yourself, so external (surprising) ones stand out.
serial execution / 2PL / SSI Transactions: one thread / locks (pessimistic) / detect-at-commit (optimistic)
serializability Transactions: as-if one-at-a-time
service Many at Once: one container-type in the file | compose network = auto private net with DNS by service name | this is the model K8s scales up
service account The Two Planes - Permission vs Network: pod's badge-hook
session Authentication: server-side state + a cookie id (revocable)
SETI Where Is Everybody: Search for Extra-Terrestrial Intelligence (scanning radio for signals). Light-year = distance light travels in a year.
settlement The Pipes: the money actually moves
SFT Fine-tuning and Alignment: supervised fine-tuning on instruction→response pairs
shard Splitting the Ledger: one slice of the split data
shard key (partition key)Splitting the Ledger: the field that picks the slice
shared-nothing What a Data System Promises: nodes share no memory/diskAlso on When Machines Fail
shuffle Batch Processing: partition + sort by key
SIEM/EDR Anatomy of a Breach: detection tooling
sift up/down Trees: restore heap property
signed Numbers for Real: allows negatives
Simple interest Compound Interest The 8th Wonder: only the principal earns (a straight line). Compound = the curve (a hockey stick).
singly / doubly linked Linked Lists Stacks and Queues: next only / next+prev
SipHash Hashing: a keyed hash that defeats it
skew Partitioning: uneven distributionAlso on Batch Processing
sliding window Arrays and Strings: a growing/shrinking [L..R] range
SLSA/sigstore Application Hardening: build provenance & signing
snake The Map: a run of free diagonal moves (a block of unchanged lines)
snapshot isolation Transactions: read a consistent point-in-time (MVCC)
source of truth Where Data Systems Are Heading: the one authoritative log
sparse vs dense Graphs: few vs many edges relative to V²
spatial locality The Memory Hierarchy: use nearby dataAlso on Cache Line Life
speed of light The Night Sky Is a Time Machine: the speed of causality
split brain Replication: two leaders at once
split-brain fence Who Holds the Pen: old-term leaders ignored
spread The Water Market: the gap between them
SQL injection Web Vulnerabilities: input becomes SQL
SRAM Logic From Switches: fast memory made of flip-flops (cache)Also on The Memory Hierarchy
SSRF Web Vulnerabilities: your server tricked into fetching an internal URL (fix: allowlist, block metadata IP)
SSTable Storage Engines: sorted on-disk segment
stable sort Sorting and Searching: preserves order of equal keys
stack Linked Lists Stacks and Queues: LIFO (push/pop/peek, all O(1))Also on How Code Becomes Execution
stack frame How Code Becomes Execution: one call's locals + args + return address
stack of N blocks Attention and the Transformer: the depth of the model
stack overflow How Code Becomes Execution: too-deep recursion
Stall How Planes Actually Fly: when the tilt is so steep the smooth flow separates from the top and lift suddenly drops.
star vs snowflake schema Storage Extras: flat dimensions vs normalized dimensions
starvation / livelock Concurrency and the Hardware: never / busy-never progressing
state Recursion and Dynamic Programming: the parameters identifying a subproblem
stateless Inference: no memory between calls (history is re-sent)
static vs contextual embedding Tokens and Embeddings: fixed per word vs context-shifted
step How It Learns: one weight update
stopping distance Twice the Speed, Four Times the Stop: the two added together - kinetic energy = the energy of motion, 1/2 x m x v squared
straggler Stream Processing: a late event
stream-stream / stream-table join Stream Processing: window-correlate / enrich
strict serializability Consistency and Consensus: linearizable + serializable
stride Cache Line Life: the gap between accessesAlso on The Security Mindset
strike The Drought Right: the fixed price
string Arrays and Strings: array of characters/code points
StringBuilder / join Arrays and Strings: the O(n) fix
structured output Agents and Tool Use: force valid JSON matching a schema
subsequence Two Files, One Question: keep the order, may skip. ('ACE' is a subsequence of 'ABCDE')
substring Two Files, One Question: must be contiguous. NOT what diff wants — one inserted line would break it.
Supercooling Hot Water Can Freeze Faster Than Cold: staying liquid BELOW the normal freezing point until something triggers ice; unstable, can flip suddenly.
Superposition Silence Built From More Noise: when waves overlap, they simply ADD. Destructive interference = opposite waves cancel to flat.Also on Watch a Particle and It Changes
superscalar The CPU: >1 instruction per cycle
supply chain Application Hardening: your dependencies (+transitive)
swap Processes Threads and the Kernel: paging RAM to disk
swap/paging The Memory Hierarchy: spilling RAM to disk when full
symmetric encryption Cryptography Foundations: one shared key (AES, fast, bulk)
sync/async/semi-sync Replication: wait / don't wait / wait for one
syscall Processes Threads and the Kernel: user code trapping into the kernel for a privileged op
system model When Machines Fail: timing + failure assumptions
systematic risk One Cloud Many Rivers: the shared part nobody can mix away (the cloud)

T

tabulation Recursion and Dynamic Programming: bottom-up table fill
tail latency What a Data System Promises: the slow high-percentile requests
target group The Two Planes - Permission vs Network: boxes behind a load balancer
temperature Inference: randomness dial (0 = deterministic)
temporal locality The Memory Hierarchy: reuse soon
term Who Holds the Pen: an epoch that increments each election
the 2038 problem Numbers for Real: 32-bit Unix time overflow
the cache caveat Complexity and Big-O: Big-O ignores the constant, and the constant is often memory locality
the KV cache grows with context Inference: the memory cost of long context
the meta-method Algorithm Design Patterns: brute force → find bottleneck → apply the pattern that removes it → verify
the O(n log n) wall Sorting and Searching: info-theoretic lower bound for comparison sorts
the spaced-review schedule How Learning Sticks: SPACED REPETITION (revisit, don't read once)
the universal cure Web Vulnerabilities: separate data from code + validate/allowlist + least privilege (l.01) + defense in depth
the whole track Anatomy of a Breach: the chain's defense
the wikilinks / 'ties to'How Learning Sticks: ELABORATION (connect new to known)
thinking distance Twice the Speed, Four Times the Stop: road covered before your foot moves - braking distance = road covered once the brakes bite -
thread Processes Threads and the Kernel: an execution unit sharing a process's memory
threat model The Security Mindset: the structured 'what can go wrong' at each trust boundary
three-way match The Nightly Match: order, invoice and payment all agree
throttling The Bouncer at the Door: slow/reject once over the cap
throughput Inference: tokens/secAlso on What a Data System Promises
thumbprint OIDC - Passport and Stamp-Book: fingerprint of the office's stamp
time Recursion and Dynamic Programming: #states × work/state
time vs space complexity Complexity and Big-O: ops vs memory as a function of n
time-of-day vs monotonic clock When Machines Fail: wall time (can jump) vs forward-only elapsed
timeliness vs integrity Where Data Systems Are Heading: up-to-date vs uncorrupted
timeout When Machines Fail: the only failure detector
timer interrupt IO Interrupts and the Bus: the tick that preempts
timing break The Nightly Match: the twin is coming, late
Timsort/introsort Sorting and Searching: the real-world hybrids
TLB The Memory Hierarchy: a cache of translations
TLS Transport and Network Security: transport-layer security (confidentiality + integrity + authenticity on the wire)
TLS / HTTPS A Secret Shouted Across a Room: the padlock.
TLS 1.3 Transport and Network Security: 1-RTT, forward secrecy always
token Tokens and Embeddings: the atomic unit a model reads (a subword)
token bucket The Bouncer at the Door: refill r, hold B, spend 1 per request
token ID Tokens and Embeddings: an integer index
token/JWT Authentication: stateless signed credential (scales, hard to revoke)
tokenizer Tokens and Embeddings: text ↔ token IDs (a fixed pre-step)
tolerance The Nightly Match: how far apart two entries may be and still match
tombstone Storage Engines: a delete markerAlso on Hashing
tool / function calling Agents and Tool Use: the model emits a structured request; the harness runs it
tool schema Agents and Tool Use: name/params
tool server Agents and Tool Use: exposes tools over MCP
top-k RAG: the k most similar chunks
top-k / top-p (nucleus)Inference: sample only from the top tokens / the top cumulative mass
topological sort Graphs: a dependency-respecting order of a DAG (DFS post-order or Kahn's)
total order broadcast Consistency and Consensus: same-order delivery to all = a replicated log = consensus
TOTP Authentication: time-based one-time code (HMAC of the clock)
training What a Neural Network Is: finding the weights
transaction Transactions: a group of ops that commit/abort together
transformer block Attention and the Transformer: attention + FFN + residual + LayerNorm
transistor (MOSFET)Logic From Switches: a voltage-controlled switch
traversal Trees: visit all nodes (in/pre/post-order = DFS; level-order = BFS)
tree Trees: hierarchical nodes, one root, no cycles
trie Trees: character-keyed prefix tree (O(len) lookup)
triple-store Data Models and Query Languages: (subject,predicate,object) + RDF/SPARQL
TrueTime When Machines Fail: clock as an interval
trust boundary The Security Mindset: line between trust levels (validate crossings)
trust policy The Two Planes - Permission vs Network: who may wear it
trust store Transport and Network Security: the roots your device trusts
truth table Logic From Switches: the gate's full input→output map
TTFT Inference: time to first token
tunable consistency The Cut Phone Line: choose per query via quorum — R + W > N guarantees a read sees the latest write (Cassandra/Dynamo)
two-pointer Arrays and Strings: two indices sweeping (converging or fast/slow) → O(n) instead of nested O(n²)
two's complement Numbers for Real: negate by flip-bits-then-+1; one adder does both; range -2^(n-1)..2^(n-1)-1
type Everything Is a Number: the agreement on how to read bytes

U

unbounded delay When Machines Fail: no ceiling on network latency
unbundling the database Where Data Systems Are Heading: compose storage/index/replication as separate tools over a log
Unicode / UTF-8 Everything Is a Number: variable-length code for all writing
union-find Graphs: fast connected-components
universal approximation What a Neural Network Is: enough neurons can fit any function
Unix pipe Batch Processing: stream one tool's output into the next
unsigned Numbers for Real: non-negative, 0..2^n-1
use-after-free / dangling pointer How Code Becomes Execution: using freed memory
user vs kernel mode (ring 3/0)Processes Threads and the Kernel: restricted vs full hardware access

V

vacuum The Map: collect dead row versions latch = lock on a data structure (microseconds) lock = lock on data (whole txns) fsync = 'disk, PROMISE me it is durable'
validation set / early stopping How It Learns: monitor & stop in time
vector database Tokens and Embeddings: stores/searches embeddingsAlso on RAG
vector space Tokens and Embeddings: where meaning lives geometrically
version vector Replication: per-replica versions
vertex/edge Data Models and Query Languages: node/relationshipAlso on Graphs
vertical vs horizontal What a Data System Promises: bigger box vs more boxes
virtual memory The Memory Hierarchy: per-process address spaceAlso on Processes Threads and the Kernel
Viterbi Recursion and Dynamic Programming: DP over sequences (ML/bio)
vocabulary Tokens and Embeddings: the ~50-100k known tokens
Volatile Why Onions Make You Cry: evaporates easily, so it flies to your eyes. Cornea = the eye's clear front surface, packed with irritant-sensing nerves.
volatility The Water Market: how widely returns swingAlso on One Cloud Many Rivers, The Drought Right
Voltage A Battery Stores a Chemical Cliff: energy per charge (the push). Capacity (mAh) = how much total charge is available before the cliff is flat.

W

WAL Storage Engines: write-ahead log (crash recovery)Also on S1 - Build Your Own Database
watermark Stream Processing: 'seen everything up to T'
wavelength Your Remote Throws Invisible Light: size of one wiggle - frequency = wiggles/sec (they're inverses) -Also on Why the Siren Drops as It Passes, Why the Ocean Is Blue
WebAuthn / passkeys Authentication: phishing-resistant hardware auth
weight What a Neural Network Is: a learned knob (input importance)
weighted Graphs: edges carry a cost
Weighted average The Statistic That Reverses Itself: a total where big groups count more; unequal groups let a subgroup winner lose the pooled number.
window Stream Processing: tumbling/sliding/session bucket
word size Everything Is a Number: bits the CPU handles at once (32/64-bit) → also the address space
work factor Authentication: tunable slowness
workflow/DAG Batch Processing: chained jobs
working set The Memory Hierarchy: the memory a program touches often
write conflict Replication: concurrent edits to one record
write skew Transactions: read-same/write-different breaks an invariant
writer's/reader's schema Encoding and Schema Change: Avro's two schemas resolved by name

X

XSS Web Vulnerabilities: attacker JS runs in a victim's browser (stored/reflected/DOM)

Y

yield The Water Market: what a bond pays, as a rate on today's price

Z

ZooKeeper Partitioning: coordination service holding the map

#

.well-known/openid-configuration OIDC - Passport and Stamp-Book: where the office publishes its public keys
1 microsecond Your Phone Runs on Einstein: 1000 nanoseconds
12-factor Least Privilege and 12-Factor: app rules for portability/scale | RBAC = role-based access | least privilege = minimum rights | supply chain = source->deploy trust | distroless = minimal base
2PC Consistency and Consensus: two-phase commit (prepare → commit); BLOCKING if coordinator dies
429 The Bouncer at the Door: Too Many Requests
Θ (theta)Complexity and Big-O: tight bound (matches above & below)
Ω (omega)Complexity and Big-O: lower bound

About this glossary

Terms come from the JARGON, DECODED line at the end of many boards, which lists each term with its meaning. Coverage varies by track. Some tracks contribute hundreds of terms, and tracks whose boards do not include that line contribute none.

Glossary

A61 words

B54 words

C84 words

D50 words

E34 words

F40 words

G13 words

H29 words

I41 words

J3 words

K10 words

L54 words

M47 words

N21 words

O22 words

P57 words

Q6 words

R62 words

S100 words

T67 words

U9 words

V13 words

W15 words

X1 word

Y1 word

Z1 word

#7 words

About this glossary

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

Y

Z

#