The Missing Manual
⌘K
Reference

Glossary

Plain-language definitions for the terms used across the guides — 218 and counting. Each term links to the guide it comes from.

A

A record
A record = a DNS entry mapping a name to an IPv4 address. (AAAA record is the same for an IPv6 address; add one too if your box has an IPv6 address.) TTL = "time to live," how long resolvers are allowed to cache the answer.
From deploying to a vps →
ACL
An ACL is a per-file list of "who → what they're allowed." It's more granular than Unix rwx, which is why Windows permissions are usually managed through the file's Properties → Security dialog rather than a single readable line.
From the filesystem explained →
Address
Address = the number that identifies one specific storage location. Byte = the unit each address points at — 8 bits, enough to hold one number from 0 to 255, or one character.
From how data moves inside a machine →
Address bus
Address bus = the wires that carry the address (which location). Data bus = the wires that carry the data itself. Memory bus = the bus between the CPU and RAM, made of both plus control lines.
From how data moves inside a machine →
API
API stands for Application Programming Interface. Don't let the words intimidate you — "interface" here means the same thing it means on a TV remote: the agreed set of buttons you're allowed to press.
From what an api is →
array
An array is a fixed row of numbered slots laid out one after another in memory. A list is the friendlier, everyday version most languages hand you (Python's list, JavaScript's Array) — it grows and shrinks for you and hides the bookkeeping.
From data structures explained →
artifact
An artifact is the packaged output of the build — a compiled binary, a zip, a container image — the concrete thing you deploy.
From what cicd does →
assertion
An assertion is a statement of what must be true. In Python you write it with the built-in assert keyword: assert result == 110 means "I claim result equals 110." If the claim holds, nothing happens and execution continues.
From your first unit test →
At-least-once
At-least-once = never lost, possibly repeated. At-most-once = never repeated, possibly lost.
From webhooks and message queues →
Attack surface
Attack surface = the sum of all the points where an attacker can try to interact with your system: every form field, URL, API endpoint, file upload, login page, third-party integration, even the people who work there.
From what security means →

B

backend
A backend is where Terraform keeps its state. The default is local (a file on disk).
From infrastructure as code terraform →
Backward-compatible
Backward-compatible means existing users keep working without changing anything. A breaking change is the opposite: the new version drops or changes something people relied on, so they have to adjust.
From build and release basics →
Base image
Base image — the image named in FROM that you build on top of. You almost never start from nothing; you start from an official image (like node, python, nginx) that someone else already assembled.
From docker without the magic →
bearer token
A bearer token is the most common pattern: a long secret string you place in a header, and whoever "bears" (carries) it is treated as you. The header looks like this:
From reading api docs postman →
Blameless postmortem
Blameless postmortem = a written review of an incident that focuses on systemic causes and improvements, deliberately avoiding individual blame, so people feel safe telling the full truth about what happened.
From what devops is →
Blast radius
Blast radius = how much damage a single compromise can do. The goal of "assume breach" is to keep the blast radius small: one account, one server, one table — not the whole company.
From what security means →
Blocking
Blocking means an operation stops your code dead until it finishes — the line data = read_file() doesn't return until the file is fully read, and nothing else runs in the meantime.
From async await and the event loop →
bottleneck
The bottleneck is the slowest stage — the narrow neck of the bottle that limits how fast anything can flow through the whole thing.
From what performance means →
Broadcast domain
Broadcast domain = the set of devices that receive each other's broadcast traffic. Blast radius = how far the damage spreads when one thing goes wrong — the number of systems a single failure or breach can reach.
From designing an enterprise network →
Bundle
Bundle = a folder that macOS treats as a single object in the Finder. App bundles end in .app; there are other bundle types too (.framework, .bundle). The "it's one icon but really a folder" trick is the whole idea.
From macos under the hood →
Bus
Bus = shared wiring that carries data between components. The name comes from the old "omnibus" idea: one shared line that everything rides, rather than a private wire from each part to every other part.
From how data moves inside a machine →

C

Cache invalidation
Cache invalidation is the act of telling a cache "this copy is no longer trustworthy — throw it away (or refresh it)." Good caching is mostly about getting invalidation right: making sure stale copies get removed before they're served.
From caching explained →
Caching
Caching means storing an answer so the next request can reuse it instead of looking it up again. Each DNS answer carries a TTL (time to live) — a countdown in seconds saying how long it's safe to remember before checking again.
From ip dns and ports →
Cargo-culting
Cargo-culting means imitating the visible rituals of a practice while missing the substance that made it work — going through the motions and expecting the magic to follow.
From tdd and bdd honestly →
CIA triad
CIA triad = the three goals of security: Confidentiality (keep secrets secret), Integrity (keep data correct and un-tampered), Availability (keep the system working and reachable).
From what security means →
Client
Client = the machine that initiates a request (your phone, your browser). Server = the machine that waits for requests and responds.
From how the internet works →
Cloud instance
Cloud instance = a virtual machine you rent from a cloud provider, running in their data center. Cloud provider = a company (AWS, Google Cloud, Azure, etc.) that owns the physical machines and rents out slices of them.
From what a server is →
Code
Code is the instructions you write, in a language a computer can be made to understand. A program is a complete set of those instructions that does something.
From programming from zero →
Code coverage
Code coverage is the percentage of your code lines that get run while the tests execute. It's a useful hint about what's untested, but it's a terrible goal.
From why test at all →
collection
A collection is a saved folder of requests — your "Bookshelf API" set, grouped together so you (and your team) can reopen and re-send them. - A variable is a named placeholder you write as {{name}} in a request.
From reading api docs postman →
column
A column is one labeled slot every row has (name, age). A row (also called a record) is one complete entry — one user. A table is the whole grid.
From querying basics select where →
commit
A commit is one saved snapshot, with its message, ID, and a record of what came before it. "Commit your work" means "take a snapshot now."
From git from zero →
component
A component is one of the boxes — a meaningful, self-contained part of the system with a clear job (the browser, the server, the database). When someone says "component," picture one box.
From what architecture means →
Concurrency
Concurrency is dealing with many tasks over the same period by interleaving them — making progress on several by switching between them.
From async await and the event loop →
condition
A condition is any expression that evaluates to True or False — usually a comparison like >=, ==, != (not equal), <, >. The block under if runs when the condition is True.
From python from zero →
constraint
A constraint is a rule the database enforces on a column — for example, "this value can't be empty," or "every id must be unique." It's the database catching bad data at the door, rather than you finding it three weeks later in a broken report.
From spreadsheets to sql to pipelines →
core
A core is one independent processing unit inside the CPU. "How many cores" = how many processes can truly run at the same instant.
From processes memory and cpu →
CPU
CPU = Central Processing Unit, the chip that executes instructions. People also say "the processor." The brand names you've seen — Intel Core, AMD Ryzen, Apple M-series, Snapdragon — are all CPUs.
From how a computer works →
crate
A crate is the unit Rust compiles: one binary or one library is a crate. Your project is a crate.
From rust from zero →
cron
cron is a background service that runs commands on a schedule. A single scheduled entry is a cron job, and the list of them is your crontab ("cron table").
From automating the boring stuff →

D

Data center
Data center = a building purpose-built to run many computers reliably and continuously — power, cooling, and network redundancy under one roof.
From what a server is →
Data leakage
Data leakage is when information that wouldn't really be available at prediction time sneaks into the features the model trains on.
From ml basics for data people →
Data warehouse
Data warehouse = structured, query-optimized storage for analytics. Data lake = cheap, flexible storage for raw data in any format.
From what is data engineering →
database
A database is an organized store of data, managed by software built to keep it correct and fast. A table is one collection of data inside it — rows and columns, like a single spreadsheet tab.
From spreadsheets to sql to pipelines →
DBMS
DBMS = Database Management System: the software that stores your data, enforces the rules about it, and answers every request to read or change it. PostgreSQL, MySQL, and SQLite are all DBMSs.
From what a database is →
Default gateway
Default gateway = the device your computer hands traffic to when the destination isn't on your local network. For a home network, that's your router.
From your home network →
dependency
A dependency is anything your code calls and waits on to do its job — a database, an internal service, a third-party API. When people say "a dependency failed," they mean one of those calls didn't come back the way you needed.
From designing for failure →
Deprecate
Deprecate = officially mark as going-away, while keeping it working. Sunset = the date it actually stops working. The gap between them is the migration window.
From designing apis that last →
Descriptor
Descriptor = the device's self-description (who made it, what it is, what it can do). Enumeration = the whole detect → address → interview → match sequence.
From how devices connect →
Desired state
Desired state is that description: the complete picture of what your infrastructure should look like, written in files. Declarative means you specify the end state and let the tool work out how to reach it.
From infrastructure as code terraform →
Device class
Device class = a standard behavior category a device claims during enumeration.
From how devices connect →
DNS
DNS stands for Domain Name System. Think of it as the internet's phone book: you know the name, DNS gives you the number.
From ip dns and ports →
DOM
DOM = Document Object Model. An element is one node in that tree (a <button>, a <div>). document is the global object that is the root of the tree and your entry point to it.
From javascript from zero →
Domain name
Domain name = the human-friendly name of a site, like example.com or wikipedia.org. It's a label that points to an IP address, not the address itself.
From how the internet works →
Driver
Driver = the translator between the OS and one kind of hardware. "Install the printer driver" means "give the OS the translator for this printer."
From what an operating system is →

E

edge case
An edge case is an input at the boundary of what the code handles — zero, empty, negative, the largest allowed value, the unexpected-but-legal.
From your first unit test →
Encryption
Encryption is reversible by design: you scramble data with a key, and anyone holding the key can unscramble it back to the original.
From how passwords are stored →
environment variable
An environment variable is a named setting the shell (and the programs it runs) can read — PATH is the most important one.
From the terminal and shell →
Escaping
Escaping means putting a backslash before a special character to strip its power and make it match literally. When in doubt about whether a punctuation character is special, escaping it is harmless for most punctuation — \. and .
From regular expressions explained →
Exception
Exception is just the word many languages use for "an error that interrupts normal running." Traceback (or stack trace) is the list of steps the program was in the middle of when it failed.
From what an error message tells you →
Execution policy
Execution policy = a PowerShell safety setting that controls whether (and which) script files are allowed to run.
From windows for power users →
exit code
An exit code is the number a command returns when it finishes: 0 means success, anything else means failure. This is how CI knows whether a step passed without understanding anything about your test framework — it just checks the exit code.
From testing in ci →
Expand
Expand = add the new thing without removing the old (the schema temporarily holds both). Contract = once everything uses the new thing, remove the old. The safe middle is the period where both exist.
From database migrations →

F

Fan-out
Fan-out = a join that matches each input row to many rows on the other side, multiplying the row count (often a sign of a missing or wrong join key).
From data quality and observability →
feature
A feature is one input column. Feature engineering is the craft of turning your raw data into features that actually carry signal — and it's where data people quietly win or lose projects.
From ml basics for data people →
Feature branch
Feature branch is the common name even when the work is a bug fix or a tweak — it just means "a short-lived branch for one unit of work, off main."
From git with other people →
filesystem
A filesystem is exactly that story: the system the OS uses to turn dumb numbered storage into named files organized in folders, and to remember which boxes belong to which file.
From the filesystem explained →
First bad commit
First bad commit is what bisect hunts for: the earliest commit where the bug is present. Every commit before it is good; it and everything after are bad.
From bisecting a bug →
flag
A flag is an extra option you pass to a command, usually starting with -- (or a single -). --version is asking the command "tell me your version and exit."
From javascript from zero →
foreign key
A foreign key is a column in one table whose value refers to a row in another table. Here, orders.user_id is a foreign key pointing at users.id. It's the thread that ties the two tables together, and it's the column a join will match on.
From sql joins explained →

G

garbage collector
A garbage collector is a component of the language runtime that automatically finds heap objects your program can no longer use ("garbage") and reclaims their memory.
From memory and garbage collection →
Generalizing
Generalizing means the model performs well on new inputs it never saw during training — it grasped the pattern.
From how a model learns →
Gherkin
Gherkin is the name of the plain-text Given/When/Then syntax used by tools like Cucumber and Behave. A scenario is one concrete Given/When/Then example. A feature is a group of related scenarios.
From tdd and bdd honestly →
goroutine
A goroutine is not an operating-system thread. It's a lightweight task the Go runtime schedules onto a small pool of real threads for you.
From go from zero →

H

Hallucination
Hallucination = when an AI generates confident, plausible-sounding output that is flatly false.
From what ai and ml are →
Hashing
Hashing is turning a key into a number that points at a storage spot. You almost never call the hash function yourself — the map does it for you on every lookup and every insert.
From data structures explained →
Headless
Headless = a computer running without an attached display or input devices. You interact with it remotely (over the network) instead of sitting in front of it.
From what a server is →
health check
A health check is a small request the load balancer sends to each backend on a schedule — often a hit to a dedicated endpoint like /health — to ask "are you alive and able to serve?" A backend that responds correctly is healthy and stays in rotation; one that fails (errors, times out, or returns…
From designing for scale →
heap
The heap is the region of memory used for longer-lived or dynamically-sized data. Unlike the stack, items here don't disappear just because a function returned — they persist until something decides they're no longer needed.
From what happens when code runs →
heisenbug
A heisenbug is a bug that changes or vanishes when you try to observe it — named after the physics idea that observing something can disturb it.
From how to reproduce a bug →
Hive
Hive = a top-level section of the registry (its own root). Key = a container, like a folder. Value = a single setting (name + type + data) stored inside a key.
From windows for power users →
hop
A hop is one router-to-router handoff. "Three hops out" means three routers between you and there. The hop count also tells you roughly how far, network-wise, a destination is.
From troubleshooting networks →
Host
Host = the remote machine (its IP or DNS name). Host key = the server's permanent cryptographic identity; the fingerprint is its short, human-checkable form.
From linux for servers →
HTTP
HTTP = HyperText Transfer Protocol, the agreement web browsers and web servers use to request and deliver pages. The s in https means the same thing, encrypted so others can't read it in transit.
From how the internet works →

I

I/O
I/O = Input/Output: anything the computer uses to take information in or send it out. Your keyboard is input; your screen is output; the network is both.
From how a computer works →
Idempotent
Idempotent = safe to repeat; the end state is the same no matter how many times you do it.
From designing for failure →
Image
Image = the frozen template on disk. Container = a live process running from that template. You build images and you run containers.
From docker without the magic →
In isolation
In isolation means the piece runs without its real collaborators. The stand-ins you swap in for those collaborators are called test doubles (fakes, stubs, mocks).
From unit integration e2e →
index
The index is the slot number. Almost every language starts counting at 0, not 1 — so the first item is at index 0, and a list of five items has indexes 0 through 4.
From data structures explained →
Input size
Input size is what n stands for: how much stuff your code has to chew through. 1,000 users? n is 1,000. The whole point of Big-O is to describe behavior as n gets large, because that's when the differences become impossible to ignore.
From big o without the math panic →
instruction
An instruction is one tiny step the CPU knows how to do: "add these two numbers," "copy this value over here," "if that number is zero, jump to a different instruction." Programs aren't single grand commands — they're long lists of these tiny steps.
From cpu ram and storage →
Interrupt
Interrupt = a hardware signal that makes the CPU pause its current work, jump to a small piece of code to handle the event, then resume exactly where it left off.
From how data moves inside a machine →
IP address
IP address = the numeric address of a machine on a network. IP stands for Internet Protocol — the agreement that defines how these addresses work and how packets are routed using them.
From how the internet works →
IPv4
IPv4 = Internet Protocol version 4, the original dotted-decimal addresses. IPv6 = version 6, the newer, much larger scheme.
From ip dns and ports →
ISP
ISP = Internet Service Provider — the company you pay for internet. They own the wire (or fiber, or coax cable) that runs from the street to your home.
From your home network →

K

Kernel
Kernel = the core that manages hardware. Distribution / distro = the kernel bundled with all the extra software that makes a complete, usable system.
From linux from zero →
knee
The knee is the bend in the latency-vs-load curve — named because the line, flat-then-sharply-up, looks like a bent knee. It marks the capacity ceiling: the honest number for "how much can this take?"
From load and performance testing →

L

Lane
Lane = one independent send/receive path. Bus = the whole shared connection system. The notation x1, x4, x8, x16 ("by one," "by sixteen") tells you how many lanes a slot or device uses.
From how devices connect →
Latency
Latency = the time for a single operation to complete (a duration). Throughput = the number of operations completed per unit of time (a rate). When someone says "it's slow," your first job is to find out which one they mean.
From what performance means →
library
A library is reusable code someone else wrote that you include in your own program — for example, code that knows how to do date math, or compress an image. Its API is the list of functions it lets you call.
From what an api is →
Linting
Linting is static analysis: inspecting code without running it to spot likely bugs and bad patterns. Formatting is purely cosmetic — rearranging the same code for consistent looks.
From javascript from zero →
Loss
Loss is a score for badness. High loss = the guess was far off. Low loss = the guess was close. Training's entire goal, stated honestly, is to make the loss as small as possible across all the examples.
From how a model learns →

M

memory leak
A memory leak = a process that keeps allocating memory and never releases it, so its resident memory only ever grows. The tell isn't a big number at one moment — it's a number that climbs and never comes back down even when the app is idle.
From processes memory and cpu →
Mitigation
Mitigation = anything that reduces or stops the user impact, whether or not it fixes the underlying cause. Remediation (or the permanent fix) = actually fixing the root cause so it can't recur.
From when prod is down →
model
A model is the learned thing — the output of training. It's not a program someone wrote line by line; it's a set of patterns the learning procedure distilled from your data. You feed it new inputs, it returns predictions.
From ml basics for data people →
Modem
Modem is short for modulator–demodulator — it modulates (encodes) your data onto the line and demodulates (decodes) what comes back. The name is the job.
From your home network →
module
A module is one .py file; a package is a folder of modules (marked by __init__.py). "Import from the app package" means reach into that folder's files.
From python from zero →
Motherboard
Motherboard = the main circuit board that connects all the components. Bus = the wiring that data travels along between them. You rarely think about the bus directly, but it's why "everything is connected."
From how a computer works →
Mutable
Mutable means "can be changed after it's created." Immutable means "fixed once created." This distinction quietly governs how every collection behaves — keep it in mind.
From python from zero →

N

Neural network
Neural network = a model made of many small, connected math units arranged in layers, whose connection strengths are adjusted during learning. Deep learning = machine learning that uses neural networks with many layers.
From what ai and ml are →
Node
Node = one machine in the cluster (physical or virtual) that runs Pods. Cluster = all the nodes plus the control plane (the brain running the controllers and the API).
From kubernetes without the hype →
Non-functional requirements
Non-functional requirements are the qualities a system must have, separate from its features. "Let users post a photo" is a feature.
From what architecture means →
NT kernel
NT kernel = the core of Windows that manages the hardware and has full control of the machine. When people say "the Windows kernel," this is it.
From windows for power users →

O

object
An object is a collection of named fields — "name": "Ada" is a field whose key is "name" and whose value is "Ada". An array is an ordered list where position matters, not names.
From http and json api basics →
Observability
Observability = being able to understand what your running software is doing from the outside, using its logs, metrics, and traces. (It has its own depth — that's a separate guide.)
From what devops is →
Open source
Open source = the source code is published under a license that lets anyone read, modify, and redistribute it. Free here means both "no cost" and "free as in freedom to change it" — the Linux world cares about both meanings.
From linux from zero →
Orchestration
Orchestration = the automated coordination of many containers across many machines — deciding where they run, keeping the right number alive, connecting them, and updating them. An orchestrator is the software that does it.
From kubernetes without the hype →
Owned
Owned means "this value is responsible for its data and will clean it up." Borrowed (the &) means "a temporary reference to data owned elsewhere." This owned-vs-borrowed split runs through all of Rust — strings are just where you meet it first.
From rust from zero →
Owner
Owner = the user who owns the file. Group = a named collection of users who can be given shared access. Others = everyone else on the system. Each gets its own r/w/x settings.
From linux from zero →

P

package
A package is a folder of .go files that belong together and share a name (you've already used the fmt package and written package main). It's the unit of code organization — one folder, one package.
From go from zero →
Package manager
Package manager = a tool that installs, updates, and removes software for you, handling dependencies (the other software a program needs). Homebrew (brew) is the de facto package manager for macOS.
From macos under the hood →
Packet
Packet = a small chunk of data with a label on the front. The label says, among other things, where the packet is going, where it came from, and which piece of the whole it is (piece 3 of 17, say).
From how the internet works →
panic
A panic is a controlled crash: Rust detected something it refuses to continue past (here, an arithmetic overflow) and halts with a message and a line number instead of silently producing garbage.
From rust from zero →
parameter
A parameter is the name in the definition (name); an argument is the actual value you pass in when calling ("Ada"). return sends a value back out of the function.
From python from zero →
Parity
Parity is redundant information derived from your data (think of a running checksum) such that if any one piece goes missing, the missing piece can be recomputed from the rest.
From inside a server and data center →
path
A path is the address of a file or folder. Documents is a relative path (relative to where you are now); /home/ada/Documents is an absolute path (the full address from the top). . means "here," ..
From the terminal and shell →
Phishing
Phishing = a fake message (email, text, call) designed to trick someone into revealing a password, clicking a malicious link, or approving something they shouldn't. It targets people, not systems.
From what security means →
PID
PID = Process ID, a number the OS assigns when a process starts and reuses only after that process is long gone. It's the handle you grab a process by.
From processes memory and cpu →
pipeline
A pipeline is a defined sequence of steps — get the data, transform it, store or send the result — written down as code or configuration so a computer can run it automatically, the same way every time.
From spreadsheets to sql to pipelines →
platter
A platter is one of the spinning disks. A track is one of the concentric rings of data on a platter (like the grooves on a record, except they're separate circles, not a spiral).
From storage hdd ssd nvme →
Pointer
Pointer = a value whose contents are a memory address. It "points at" the data living at that address instead of holding the data directly.
From how data moves inside a machine →
port
A port is a number that identifies one program's "mailbox" on a machine. The IP address gets you to the building; the port number gets you to the right apartment.
From tcp ip model →
Postman
Postman is a graphical app (GUI) for building and sending HTTP requests. You fill in fields and click Send; it shows you the response in a nice panel. Great for exploring an API and saving requests to reuse.
From reading api docs postman →
Precision
Precision — of the cases the model flagged, how many were real? High precision means few false alarms. "When it cries fraud, it's usually right." - Recall — of all the real cases out there, how many did the model catch?
From ml basics for data people →
process
A process is a program in the act of running — its instructions loaded into RAM, its stack and heap set up, and an identity the operating system tracks.
From what happens when code runs →
profile
A profile is the report a profiler produces — the breakdown of where time (or memory) went during one run. "Profiling" is the act of collecting one.
From profiling 101 →
Program
Program = the instructions sitting in storage, not running (the recipe). A running program — loaded into RAM with the CPU working through it — is often called a process (the meal being cooked).
From how a computer works →
promise
A promise is an object representing the eventual result of an asynchronous operation. Pending = not done yet; fulfilled (or "resolved") = succeeded with a value; rejected = failed with an error.
From async await and the event loop →
property
A property is one key: value pair on an object. A method is a property whose value happens to be a function (e.g. console.log is the log method of the console object).
From javascript from zero →
Protocol
Protocol = an agreed set of rules for how two machines communicate. The internet is built from many protocols, each handling one part of the job.
From how the internet works →
provider
A provider is the plugin that teaches Terraform how to talk to one specific platform — AWS, Google Cloud, Azure, Cloudflare, and hundreds more.
From infrastructure as code terraform →
pytest
pytest is a test runner — a program that finds your test functions, runs them, and reports pass or fail. It's the most common test runner in Python and not part of the language itself, so you install it once:
From your first unit test →
Python interpreter
The Python interpreter is the program named python (or python3) that executes your code. When people say "run it in Python," they mean "hand this file to the interpreter."
From python from zero →

Q

Query
Query = a precise question (or instruction) you send to the database — "give me all customers in Ohio," "add this order," "raise every price by 10%." You'll write real queries in /guides/querying-basics-select-where.
From what a database is →

R

RAID
RAID = Redundant Array of Independent Disks. An array is the group of physical disks combined together.
From inside a server and data center →
rainbow table
A rainbow table is a precomputed map from hashes back to the passwords that produce them. If your hash is in their table, the "one-way" function might as well be a dictionary lookup.
From how passwords are stored →
RAM
RAM = Random-Access Memory. "Memory" and "RAM" mean the same thing in everyday use. It's measured in gigabytes (GB) — common laptops have 8, 16, or 32 GB.
From how a computer works →
Random access
Random access means jumping to scattered, unrelated locations — read a bit here, a bit way over there, a bit back near the start. Sequential access means reading a long stretch that's all laid out in a row.
From storage hdd ssd nvme →
Reachable
Reachable means "you can get to this commit by following labels and parent pointers." git log shows reachable commits. The reflog can reach commits that nothing else can — which is exactly why it rescues you.
From git disaster recovery →
read
A read is any query that fetches data without changing it (SELECT). A write is anything that modifies data (INSERT, UPDATE, DELETE). A read-heavy workload does far more reads than writes; a write-heavy workload is dominated by writes.
From scaling a database →
Redis
Redis is an in-memory key-value store (think: a giant, very fast hash map that lives on the network) commonly used for sessions, caching, and other small fast-access data.
From designing for scale →
Registry
Registry = the image store. pull = download an image from it. push = upload one to it.
From docker without the magic →
regression
A regression is when something that used to work stops working because of a later change. The feature didn't change; you changed something nearby, and it "regressed" back to being broken.
From why test at all →
REPL
REPL stands for Read–Eval–Print Loop: it reads your line, evaluates it, prints the result, then loops back for the next one.
From python from zero →
Reproducibility
Reproducibility = running the pipeline again on the same data gives the same result, every time.
From what is data engineering →
Rubber-duck debugging
Rubber-duck debugging is explaining your problem, out loud and in full detail, to an inanimate object (the classic is a rubber duck on your desk).
From what an error message tells you →
runner
A runner is the machine that executes a job. GitHub-hosted runners (ubuntu-latest, windows-latest, macos-latest) are free for public repos and metered for private ones. Each is spun up clean for your job and destroyed after.
From your first pipeline github actions →
runtime
A runtime is the program that actually executes your JavaScript. Same language, different runtime, different powers.
From javascript from zero →

S

salt
A salt is per-user random data combined with the password before hashing, so that the same password produces a different hash for each user.
From how passwords are stored →
scheduler
A scheduler is the piece that triggers the pipeline on a timetable — "every day at 6am," "every hour," "every Monday." It's the part that replaces you remembering.
From spreadsheets to sql to pipelines →
Schema
Schema = the shape of the data: which fields exist, what type each one is, what they're named. Schema drift = that shape changing over time, usually upstream and usually without warning.
From what is data engineering →
Scope
Scope is the region of code where a variable is valid — usually between its let and the closing } of the block it lives in. Dropped means Rust runs the value's cleanup and frees its memory.
From rust from zero →
Serializing
Serializing is turning an in-memory object (a struct, a class instance) into a stream of bytes you can send over the network. Deserializing is rebuilding the object from those bytes on the other end.
From grpc explained →
Server
Server = a computer whose job is to wait for requests and respond to them. Client = the computer making the request (yours). We'll come back to this pairing properly in Phase 3: Client, Server & Talking the Same Language.
From how the internet works →
Server software
Server software = a program whose job is to wait for a particular kind of request and respond to it. A single server (the machine) often runs several of these at once.
From what a server is →
Serverless
Serverless = a model where you provide code and the cloud provider runs it on demand, managing all the servers for you. (The name is marketing: there are still servers — you just never see or manage them.)
From what a server is →
Service
Service = a long-running background program managed by Windows' Service Control Manager, designed to run without a user interface and (often) without anyone logged in.
From windows for power users →
Service / daemon
Service / daemon = a long-running background program with no interactive screen. It's the opposite of a command you run and watch finish; a service is meant to keep running.
From linux from zero →
Sharding
Sharding is also called horizontal partitioning — "horizontal" because you're splitting the table by rows (this user's rows here, that user's rows there), not by columns.
From scaling a database →
Shell
Shell = the program that turns the text you type into actions (running programs, moving through folders, chaining commands). zsh is the shell Apple ships as the default.
From macos under the hood →
signal
A signal is a short, numbered notification the OS hands to a process. A handful matter for stopping things; the names are more useful than the numbers.
From processes memory and cpu →
SIP
SIP = a protection that puts critical system files and processes off-limits to modification, enforced by the kernel itself rather than ordinary file permissions. It's why sudo sometimes still says "Operation not permitted."
From macos under the hood →
SLA
SLA = service-level agreement, the promise you make to consumers ("fresh by 7am"). SLO = service-level objective, the internal target you actually engineer toward (often a bit tighter, e.g. "fresh by 6:30am," to leave headroom).
From data quality and observability →
socket
A socket is the slot a CPU plugs into; "a two-socket server" (or "dual-socket") means two physical processors. Don't confuse it with a network socket — same word, unrelated meaning.
From inside a server and data center →
Source code
Source code = the human-readable text you write. Machine code = the raw numeric instructions a specific CPU can execute directly. They are two completely different things; one has to become the other before anything runs.
From what happens when code runs →
SQL
SQL is usually pronounced "sequel" or spelled out "S-Q-L" — both are common and both are fine. It's the language; PostgreSQL, MySQL, and friends are the databases that speak it (each with small dialect differences).
From what a database is →
SSD
SSD = Solid-State Drive, the fast modern kind of storage with no moving parts. HDD = Hard Disk Drive, the older kind with a spinning magnetic platter — cheaper and bigger, but much slower.
From how a computer works →
SSID
SSID = Service Set Identifier. A fancy name for "the network's name."
From your home network →
stack frame
A stack frame is the chunk of stack memory belonging to one function call: its local variables and the bookkeeping needed to return to whoever called it.
From what happens when code runs →
Stateless filtering
Stateless filtering = each packet judged on its own, by fixed rules, with no memory. Stateful filtering = the firewall tracks active connections (a "state table") and judges packets in the context of the conversation they belong to.
From designing an enterprise network →
stop-the-world pause
A stop-the-world pause is a moment when the runtime suspends your application code so the garbage collector can work on a stable view of memory. Your program is frozen for the duration — usually milliseconds, but real.
From memory and garbage collection →
string
A string is a sequence of characters — text. The quotes aren't part of the value; they just tell Python "the text starts here and ends there."
From python from zero →
structured log
A structured log is one where the data is in named fields, like level=error order=4821 reason=card_declined, rather than free-form text like error charging order 4821 because the card was declined.
From reading logs without drowning →
Subnet
Subnet = a logically subdivided range of an IP network. Router = the device that forwards traffic between networks (subnets), as opposed to a switch, which forwards within one.
From designing an enterprise network →
switch
A switch is a device that connects machines on a local network and forwards traffic between them.
From inside a server and data center →
SYN
SYN = "synchronize" (let's start, here's my sequence number). ACK = "acknowledge" (I received yours). Every chunk TCP sends gets acknowledged; if an ACK doesn't come back in time, TCP assumes the chunk was lost and sends it again.
From tcp ip model →
syntax error
A syntax error means your code broke the grammar rules of the language — like a sentence with no closing quotation mark. The computer can't even run it yet, because it can't make sense of what you wrote.
From programming from zero →
System call
System call = the formal way a program asks the kernel to do something it can't do itself (open a file, use the network, start another program). It's the doorway between user space and kernel space.
From what an operating system is →

T

TCP
TCP = Transmission Control Protocol, the agreement that delivers data reliably and in order across a network, hiding the messy reality of lost and out-of-order packets.
From how the internet works →
thread
A thread is a single sequence of execution — one worker doing one thing at a time, in order. A queue here is just a waiting line: jobs join at the back and get picked up from the front.
From async await and the event loop →
Toil
Toil = manual, repetitive operational work that has to be done but doesn't get better as you do it — copying files to a server by hand, manually restarting a service, clicking through the same release checklist every week.
From what devops is →
toolchain
A toolchain is the set of tools for one Rust version (compiler, standard library, cargo, and friends). rustup installs and switches between toolchains. cargo drives your day-to-day work. rustc is the compiler underneath.
From rust from zero →
Training data
Training data = the labeled examples you feed the machine to learn from (here: thousands of emails each marked spam or not-spam).
From what ai and ml are →
transaction
A transaction is a group of changes the database treats as all-or-nothing: either every step succeeds, or none of them do.
From spreadsheets to sql to pipelines →
Trust boundary
Trust boundary = the line separating components you control and trust from those you don't. Data crossing into the trusted side must be treated as suspicious until you've checked it.
From what security means →
Tunnel
Tunnel = an encrypted connection that carries your private network's traffic inside it across a public network.
From designing an enterprise network →
type
A type is the kind of thing a value is — what it can hold and what you can do with it. These are the ones you'll use constantly:
From rust from zero →

U

unit
A unit is anything systemd manages, described by a small text file. The kind you'll touch most is a .service unit (a daemon to run).
From linux for servers →
unit test
A unit test is a small piece of code that runs one other piece of code — usually a single function — with known inputs, and checks that it produces the result you expect. The "unit" is the small thing under test, normally one function.
From your first unit test →
Upstream
Upstream = the tables your table is built from (its inputs). Downstream = the tables built from yours (what depends on you). Lineage = the full upstream-to-downstream map across the whole platform.
From data quality and observability →
URL
URL stands for Uniform Resource Locator. In everyday speech it's just "the link" or "the web address" — the thing in your browser's address bar.
From http explained →
USB-C
USB-C is a connector (a plug shape), not a speed. When someone says "it's USB-C," they've told you what the plug looks like and nothing about how fast it is or what it can do. You have to ask separately.
From how devices connect →
Use case
Use case = how a feature is meant to be used. Abuse case = how a feature could be deliberately misused by someone who wants it to break. Building is about use cases; security is about abuse cases.
From what security means →
Use-after-free
Use-after-free = using memory through a pointer after that memory has been reclaimed. Memory leak = memory that's no longer reachable or needed but never gets reclaimed, so usage grows without bound.
From memory and garbage collection →
Userland
Userland = everything that runs in user space (the programs, command-line tools, and libraries) as opposed to the kernel.
From macos under the hood →

V

Vanity metric
Vanity metric — a measurement chosen because it flatters (big, always rising, easy to grow) rather than because it informs a decision. The classic tell: you can't imagine an action you'd take if it dropped.
From bi dashboards that work →
Virtual memory
Virtual memory = the illusion the OS gives each process of its own private, contiguous memory. It's what lets the OS move the real data around (even onto disk) without the process noticing. Physical memory = the actual RAM chips.
From processes memory and cpu →
Virtualization
Virtualization is running multiple isolated virtual computers on one physical machine. The hypervisor is the software layer that creates and isolates them, dividing the real hardware among the virtual machines (VMs) running on top.
From inside a server and data center →
VLAN
VLAN = a logical LAN segment defined in switch configuration rather than by physical wiring. Tag = a small label (an 802.1Q tag) added to a frame identifying which VLAN it belongs to, so the label survives across switches.
From designing an enterprise network →
Volume
Volume — Docker-managed persistent storage you attach to a container.
From docker without the magic →
vulnerability
A vulnerability is a specific weakness in one app (a particular login form that doesn't check permissions). A category (or "risk category") is the named family that weakness belongs to (Broken Access Control).
From owasp top 10 →

W

Wear-leveling
Wear-leveling is how the controller solves this. Instead of repeatedly writing to the same physical cells, it spreads writes evenly across all the cells, so they age together rather than a few dying early.
From storage hdd ssd nvme →
webhook
A webhook is sometimes called a "reverse API," an "HTTP callback," or a "web callback." It's the same idea each time: an event happens on their side, so they make an HTTP request to an endpoint on your side.
From webhooks and message queues →
weight
A weight is one of those adjustable numbers inside a model. A real model can have anywhere from a handful of weights to billions of them. When people say a model has "7 billion parameters," they mean it has roughly that many of these knobs.
From how a model learns →

X

XNU
XNU is the macOS kernel. (The name is a self-deprecating recursive joke from its authors — "X is Not Unix.") It blends a Mach microkernel core with BSD components, which is why Darwin carries so much BSD DNA.
From macos under the hood →

Z

zero value
A zero value is the default Go gives every variable you don't initialize — 0 for numbers, "" for strings, false for bools, nil for pointers, slices, and maps.
From go from zero →