Glossary

_

slots Python

A class option that fixes the attribute names up front so instances store them without a per-instance __dict__, saving memory and blocking new attributes.

.

.gitignore Git

a file of patterns telling Git which untracked files to leave alone.

A

A* Algorithms

Dijkstra guided by a heuristic estimate of the remaining cost, so fewer nodes are expanded.

ABI Python

Application Binary Interface: the binary-level contract (calling convention, type layout, symbol names) between compiled code.

AbortController Node.js

A standard object that signals cancellation to async operations through its AbortSignal.

ACID Databases

The four guarantees of a transaction: Atomicity, Consistency, Isolation, Durability.

Acknowledgement (ack) Messaging

The consumer's reply to JetStream: ack (done), nak (retry), term (never retry).

AckWait Messaging

How long JetStream waits for an ack before it redelivers a message.

ACME Security

A protocol that lets software request and renew certificates from a CA automatically.

AddressSanitizer Security

A compiler-inserted runtime checker (ASan) that reports out-of-bounds access, use-after-free and double free.

Adjacency list Algorithms

A graph representation that stores, for every vertex, the list of its neighbours. It uses memory proportional to V + E and suits sparse graphs.

ADR Engineering

Architecture Decision Record: a short, numbered note saying what was decided, why, and with what trade-offs.

Advisory lock Databases

An application-defined lock on a number; the database enforces it but attaches no meaning to it.

AEAD Security

Authenticated encryption with associated data: one operation that gives confidentiality and tamper detection.

AES-GCM Security

An authenticated encryption mode: it hides the data and detects any change to it.

Aggregate Engineering

A cluster of objects changed as one unit, with a root that enforces its rules.

AggregateError Node.js

An error that bundles several errors, e.g. what Promise.any rejects with.

Alert fatigue Engineering

When too many false alerts make people ignore or mute the real ones.

Allow-list Security

A list of the only values accepted, with everything else rejected by default.

ALPN Networking

Application-Layer Protocol Negotiation: TLS picks the protocol, such as h2 or http/1.1.

Amortized analysis Algorithms

Cost per operation averaged over a whole sequence of operations. An append that sometimes copies everything is still O(1) amortized if the expensive copies are rare enough.

Annotated tag Git

a tag stored as its own object with a message, author and date.

Anti-corruption layer Engineering

A translation layer that keeps another system's model from leaking into yours.

Anti-entropy Distributed

A background process that compares replicas and copies the differences, whether or not anyone reads the data.

API contract Engineering

The written agreement about what an API accepts and returns, which both client and server must keep.

Arbitrary precision Python

An integer type whose size grows as needed, so results never overflow. Python's int works this way.

argon2 Security

A modern password hashing function whose cost is set by time, memory and parallelism; argon2id is the usual variant.

argparse Python

The standard-library module that parses command-line arguments, generates --help and exits with code 2 on bad usage.

async/await Node.js

Syntax that lets you write code on top of promises as if it were sequential.

At-least-once delivery Distributed

The broker delivers every message one or more times, never zero, so duplicates are possible.

Atomic commit Git

A commit that contains one complete, logical change and nothing else.

Atomic write Linux

Writing a file so readers see either the old or the new content, never a half-written one.

Audit log Security

A tamper-evident record of who did what to which object, when, from where, and with what result.

Authoritative server Networking

A DNS server that holds the real records of a zone and answers with the AA flag.

Authorization Security

Deciding what an already identified caller is allowed to do.

Authorization Code flow Security

The OAuth2 flow where the browser carries only a short-lived code and the client swaps it for tokens on a back channel.

authorized_keys Linux

The server-side file listing public keys allowed to log in, with optional restrictions per key.

Autovacuum Databases

The PostgreSQL background worker that runs VACUUM and ANALYZE automatically when a table has enough changes.

AVL tree Algorithms

A binary search tree that keeps the heights of every node's two subtrees within 1 of each other using rotations.

B

B-tree Databases

A balanced tree of fixed-size pages with sorted keys, the default index type in PostgreSQL.

Backfill Databases

Filling a new column for existing rows, in small batches so locks and transactions stay short.

Backing array Algorithms

The memory block a slice points into. Several slices can share one backing array, so a write through one can be seen through another.

Backpressure Node.js

A signal from a slow consumer telling a fast producer to pause so buffers do not grow without limit.

Backtracking Algorithms

Building a solution step by step and undoing a step when it cannot lead to an answer.

bcrypt Security

A password hashing function with a cost parameter and a built-in salt; it only uses the first 72 bytes of the password.

Bearer token Security

A token that grants access to whoever holds it, sent as `Authorization: Bearer <token>`.

Bellman-Ford Algorithms

Shortest paths that allow negative weights by relaxing every edge up to V times, at O(V·E).

Big-O Algorithms

An upper bound on how an algorithm's cost grows with input size n, ignoring constants and lower-order terms.

Binary heap Algorithms

A complete binary tree stored in a slice where every parent is not larger than its children; the minimum is always at index 0.

Binary search Algorithms

A search that discards half of the remaining range at every step, in O(log n).

Binary search tree Algorithms

A tree where every node's left subtree holds smaller keys and its right subtree larger ones.

Bipartite graph Algorithms

A graph whose vertices can be split into two groups so that every edge joins different groups. Equivalent to having no odd-length cycle.

Bitmap scan Databases

A plan that collects matching row locations from one or more indexes into a bitmap, then reads the table pages in order.

Blast radius Distributed

how many users or requests a bad change can hurt.

Blob Git

the Git object that stores the content of one file, with no name.

Bloom filter Algorithms

A bit-array structure that answers 'definitely not present' or 'maybe present', never a false negative.

Blue/green deployment Engineering

Two identical releases side by side; traffic switches from the live one to the new one only after it is healthy.

Borrowing Rust

Using a value through a reference without taking ownership of it.

Bounded context Engineering

A boundary inside which one model and one language apply consistently.

Branch Git

a movable pointer: a file holding one commit id.

Branch by abstraction Engineering

replace code in small steps by hiding old and new behind one interface.

Branch protection Engineering

Hosting-platform rules that restrict how a branch such as main can be changed.

Breadth-first search Algorithms

Visiting a tree or graph level by level, nearest nodes first, using a queue. It finds shortest paths in unweighted graphs.

Breaking change Engineering

A change to an API that makes a correctly written existing client stop working.

Brooks's law Engineering

Adding people to a late software project tends to make it later.

Buffer overflow Security

Writing (or reading) past the end of a fixed-size buffer, corrupting neighbouring memory.

Build tag Linux

A `//go:build` line at the top of a Go file that selects the OS or conditions the file compiles under.

Bulkhead Distributed

Separate resource limits per dependency so one slow dependency cannot use up everything.

Burn rate Engineering

Observed error rate divided by the error rate the SLO allows; 1 spends the whole budget exactly.

Byte order mark Python

Invisible bytes at the start of a text file; in UTF-8 they are EF BB BF and mark the file as UTF-8.

C

Cache locality Algorithms

Data that is used together and sits close together in memory is cheaper to read, because the CPU loads memory in cache lines and prefetches sequential access.

Canary release Engineering

exposing a change to a small share of traffic first.

CAP theorem Distributed

During a network partition a system must give up either linearizability or availability for the operations it cannot complete.

Capacity planning Distributed

Estimating and checking how much hardware a service needs for expected load, and repeating it as load grows.

Cascading failure Distributed

A failure that spreads: one slow or failed component exhausts its callers, which then fail their own callers.

Causal consistency Distributed

If one operation could have influenced another, everyone sees them in that order; unrelated ones may differ.

Certificate authority (CA) Networking

The party whose signature on a certificate a client chooses to trust.

Certificate chain Security

The list leaf, intermediate(s), root that links a server certificate to a trusted root CA.

Certificate pinning Security

Accepting only a server whose certificate or public key matches a hash the client already knows.

cgroup Linux

A kernel feature that groups processes and limits or accounts for their CPU, memory and process count.

Channel Go

A typed conduit that goroutines use to send and receive values safely.

Chaos engineering Distributed

Experimenting on a system by injecting failures to build confidence that it withstands them.

Characterization test Engineering

A test that records what code does today, bugs included, so you can change it safely.

CHECK constraint Databases

A rule on a table, such as balance_cents >= 0, that every written row must satisfy.

Checksum Networking

A small number computed from data to detect accidental corruption.

checksum database Security

A public append-only log of module hashes (Go uses sum.golang.org) that detects a module changing between users.

cherry-pick Git

Copies the patch of one commit onto the current branch as a new commit with a new hash.

Choreography Distributed

Services react to each other's events with no central coordinator deciding the flow.

Chunked encoding Networking

An HTTP/1.1 way to send a body in pieces without knowing its total length.

CI Git

Continuous integration: a server runs checks (build, tests, lint) on every push or pull request.

CIDR Networking

Classless Inter-Domain Routing: writing a network as address/prefix-length, e.g. 192.0.2.0/24.

Circuit breaker Distributed

A wrapper that stops calling a failing dependency for a while and fails fast instead.

Clock skew Distributed

The difference between the clocks of two machines at the same real moment.

Closure Python

A function that remembers variables from the scope where it was defined, even after that scope has returned.

Code churn Engineering

How often a file or function changes over time; a cheap signal for where the work and the bugs gather.

Code coverage Node.js

The share of lines, branches and functions that ran while the tests ran.

Code review Engineering

Another person reading a change before it is merged, to catch problems and share knowledge.

CODEOWNERS Engineering

A repository file that maps paths to the people or teams who must review changes to them.

Command injection Security

A bug where user input becomes part of a shell command line and changes what runs.

commit Git

The Git object that ties a tree to its parents, author, committer and message.

CommonJS Node.js

the original Node.js module system: `require()` loads a file synchronously and `module.exports` is what it hands back.

Compensating transaction Distributed

A new action that semantically undoes an earlier committed step, such as a refund for a charge.

Composite index Databases

An index on several columns, sorted by the first, then the second, and so on.

Composition root Node.js

The single place (usually `main`) where concrete parts are created and wired together.

Conditional exports Node.js

the `exports` field of `package.json`, which maps import paths to files and can pick a different file for `import` and `require`.

Connected component Algorithms

A maximal group of vertices in an undirected graph where every vertex can reach every other. A BFS or DFS from one vertex finds exactly its component.

Connection pool Databases

A set of open database connections that are lent out and reused.

Connection tracking Linux

The kernel table of flows that lets firewall rules match by connection state.

Consensus Distributed

Getting a group of nodes to agree on one value (or one ordered log) even when some nodes crash or messages are lost.

Consistent hashing Networking

A key-to-node mapping where removing a node moves only that node's keys.

Constant-time comparison Security

Comparing secrets in a way whose running time does not depend on where they first differ.

Consumer-driven contract Engineering

A contract written by the clients, saying which parts of an API they really use, which the server then verifies.

Container Linux

A normal Linux process (or group) started with its own namespaces and cgroup limits, usually from an image.

Content Security Policy Security

A response header that tells the browser which sources of scripts and other content a page may use.

Context Go

A value carrying cancellation, deadlines and request-scoped data across API boundaries.

Context manager Python

An object used with the with statement whose __enter__ and __exit__ methods run setup and guaranteed cleanup around a block.

Contract test Engineering

A test that checks real requests or responses against the API contract, not against hand-written expectations.

Contributing factor Engineering

One of several conditions that together allowed an incident to happen.

Conventional Commits Git

A convention for commit subjects shaped like type(scope): summary.

Conway's law Distributed

A system's design tends to mirror the communication structure of the organization that builds it.

copytruncate Linux

A logrotate option that copies the log and truncates the original in place instead of renaming it.

Coroutine Python

A function defined with async def; calling it returns a coroutine object that does nothing until it is awaited or wrapped in a task.

Correlated subquery Databases

A subquery that refers to the outer row, so it runs once per outer row.

CORS Security

Cross-Origin Resource Sharing: headers that tell a browser whether a page from another origin may read a response.

Coverage-guided fuzzing Security

Fuzzing that keeps and mutates inputs which reach new code paths.

Covering index Databases

An index that contains every column a query needs, so the table is not read.

CPU cache Algorithms

Small, fast memory next to the CPU that holds recently used data; sequential access uses it far better than random access.

CPU profile Node.js

A sampled record of which functions the CPU was running, used to find where time goes.

CPU-bound Engineering

Work whose speed is limited by the processor, such as computing primes, not by waiting for I/O.

CQRS Distributed

Command Query Responsibility Segregation: the model that handles writes is separate from the model that serves reads.

CRDT Distributed

A conflict-free replicated data type: replicas update independently and a merge function that is commutative, associative and idempotent makes them converge.

CREATE INDEX CONCURRENTLY Databases

A way to build an index without blocking writes, at the cost of more passes and a possible INVALID index on failure.

Credential stuffing Security

Trying username and password pairs leaked elsewhere against your login, many users from one source.

Critical path Algorithms

The longest chain of dependent tasks; it sets the minimum time even with unlimited workers.

cron Linux

The classic Unix scheduler that runs commands at times written in a five-field table.

Crypto-shredding Distributed

Deleting data from an immutable log by encrypting personal fields with a per-subject key and destroying the key.

CSRF Security

Cross-site request forgery: another site makes the browser send an authenticated request you did not intend.

CTE Databases

A named subquery defined with WITH, usable in the main query.

CVE Security

Common Vulnerabilities and Exposures: a public identifier for a known security flaw.

Cyclomatic complexity Engineering

A count of the independent decision paths through a function.

D

Daemon thread Python

A thread that does not keep the program alive: when only daemon threads remain, the process exits.

DAG Git

Directed acyclic graph: the shape of Git history, commits pointing to their parents.

Database index Databases

A separate sorted structure that lets the database find rows without reading the whole table.

Dataclass Python

A class decorated with @dataclass: Python generates __init__, __repr__ and __eq__ from the annotated fields, with options like frozen, order and slots.

Datagram Networking

A self-contained packet of data sent without a connection; it arrives whole or not at all.

Dead man's switch Linux

An alert that fires when an expected signal does NOT arrive.

Dead tuple Databases

A row version that no current or future transaction can see any more, but that still occupies space until VACUUM removes it.

Dead-letter queue Messaging

A place where messages that keep failing are moved so they do not block the main flow.

Deadline Networking

An absolute point in time after which a network read or write fails with a timeout.

Deadlock Databases

Two or more sessions each wait for a lock the other holds, so none can continue; the database aborts one of them.

Decorator Python

A function that takes a function and returns a wrapped version of it, applied with @name.

Default partition Databases

A partition that receives rows that match no other partition of the table.

Delta compression Git

Storing an object as a small difference against a similar base object.

Denial of service Security

An attack or accident that makes a service unavailable by exhausting a resource such as memory, connections or CPU.

Denormalization Databases

Deliberately storing a fact more than once to make reads cheaper.

Deny by default Security

A route or action is forbidden until a rule explicitly allows it.

Dependency injection Node.js

Passing dependencies (like time or a database) in from outside instead of creating them inside the function.

Depth-first search Algorithms

Visiting a graph by going as deep as possible along one path before backing up, using recursion or a stack.

Deque Algorithms

A double-ended queue: push and pop at both the front and the back, all in O(1) amortized. A ring buffer with growth implements it well.

Detached HEAD Git

The state where HEAD points straight at a commit instead of a branch name.

Deterministic simulation Distributed

Running a system in a simulated world driven by a seed so any failure can be replayed exactly.

Differential testing Security

Running two implementations on the same input and flagging any difference.

Digital signature Security

A value computed with a private key that anyone with the public key can verify, proving origin and integrity.

Dijkstra's algorithm Algorithms

Shortest paths from one source in a graph with non-negative weights, always expanding the closest unfinished vertex.

Distributed monolith Distributed

Services split over the network that still have to change, deploy and fail together.

DNS Networking

The system that maps names to records such as IP addresses.

DNS rebinding Security

A name that resolves to a harmless address for the check and to an internal one for the connection.

Domain event Engineering

A fact that happened in the domain, named in the past tense, such as OrderPlaced.

Domain-driven design Engineering

An approach that shapes the code around the business domain, using its language, boundaries and rules.

Dual write Distributed

writing the old and new form of data at once.

Duck typing Python

Using an object because it has the methods you call, not because of its declared class: if it has speak(), you can call speak().

Dunder method Python

A special method with double underscores around its name, like __repr__ or __eq__, that Python calls for you when you use syntax such as print(), == or len().

Durable consumer Messaging

A named JetStream consumer whose position survives restarts and reconnects.

Dynamic array Algorithms

A growable array: elements sit in one contiguous block, and when it is full the structure allocates a bigger block and copies everything over. Go slices and Rust Vec work this way.

Dynamic programming Algorithms

Solving a problem by combining answers to smaller subproblems, each solved once and stored.

E

ECB mode Security

A block cipher mode that encrypts every block independently, so equal plaintext blocks give equal ciphertext blocks.

Edit distance Algorithms

The minimum number of insertions, deletions and substitutions needed to turn one sequence into another (Levenshtein).

editable install Python

Installing a project so the environment points at your working copy instead of a copied snapshot, so edits apply immediately.

Encapsulation Networking

Wrapping the data of one layer inside the header of the layer below.

entry point Python

A named hook in a package's metadata; console_scripts entry points become commands on PATH when the package is installed.

Envelope encryption Security

Encrypting data with a random per-record key that is itself encrypted by a master key.

Environment variable Node.js

A named string a process inherits from its parent, used to pass configuration such as ports and keys.

epoll Linux

The Linux system call family that lets one thread wait efficiently for readiness on thousands of file descriptors.

errgroup Go

A `golang.org/x/sync` helper that runs goroutines together and cancels the rest on the first error.

errno Linux

The error code a failed system call reports, such as ENOENT or EACCES.

Error budget Engineering

The amount of failure an SLO allows in a window; spending it is how reliability is traded against change.

ESM Node.js

the standard JavaScript module system (`import`/`export`), loaded asynchronously and analysed statically before any code runs.

Event envelope Distributed

A fixed wrapper around every event with metadata (id, type, time, source, schema version, correlation id) separate from the payload.

Event loop Node.js

The loop that lets single-threaded JavaScript handle many waiting operations by running callbacks when they are ready.

Event sourcing Distributed

State is not stored; the append-only list of events that led to it is, and current state is a fold of them.

EventEmitter Node.js

Node's built-in publish/subscribe object: emit named events, listeners react.

Eventual consistency Distributed

If writes stop, all replicas end up with the same value; before that, reads may be stale or out of order.

Exception chaining Python

Linking a new exception to the one being handled: raise ... from e sets __cause__, raising inside except sets __context__.

ExceptionGroup Python

An exception that bundles several exceptions; except* handles each matching type on its own slice of the group.

Exit status Linux

The number a command returns when it ends; 0 means success and anything else means failure. The shell exposes it as `$?` and uses it in `&&`, `||` and `if`.

Expand/contract Databases

A migration recipe in small safe steps: add the new shape, copy data, switch the app, drop the old shape.

Exponential backoff Distributed

Waiting longer after each failed attempt, doubling the delay up to a cap.

Expression index Databases

An index built on the result of an expression such as lower(email) instead of a plain column.

Extended statistics Databases

Multi-column statistics created with `CREATE STATISTICS`.

F

Fail open Distributed

Letting requests through when a protective component, such as the limiter store, is unavailable.

Failover Databases

Switching to a standby as the new primary when the old one fails.

Failure detector Distributed

A component that guesses whether a remote node is down, usually from missing heartbeats within a timeout.

Fan-out Algorithms

The number of children a tree node can have; a larger fan-out makes the tree shallower.

fast-forward Git

moving a branch pointer ahead along a straight line of commits, with no new commit.

Fault injection Distributed

Deliberately causing latency, errors or crashes in a dependency to see how the system reacts.

Feature flag Engineering

a runtime switch that turns code paths on or off without a deploy.

FFI Go

Foreign Function Interface: calling code written in another language, usually through the C ABI.

File descriptor Linux

A small integer a process uses to refer to an open file, pipe or socket. 0, 1 and 2 are stdin, stdout and stderr; shell redirects rewire them.

File permissions Linux

Nine bits (read, write, execute for user, group and other) stored in the inode. Octal modes such as 755 or 640 write them compactly.

Fisher exact test Distributed

an exact significance test for a 2x2 table of counts.

Five whys Engineering

A technique of asking why repeatedly to find a cause; it follows a single chain.

Fixture Python

a function that prepares (and cleans up) what a test needs

Fixup commit Git

A commit marked to be folded into an earlier commit during an autosquash rebase.

Flaky test Engineering

A test that sometimes passes and sometimes fails with no change in the code.

Flame graph Linux

A picture of sampled stacks where box width shows how often a function was on the stack.

force push Git

overwrites a remote branch with your local one, even if that discards commits; prefer --force-with-lease.

Foreign key Databases

A column that must match a primary key value in another table.

Free-threaded Python Python

A CPython build, available since 3.13 as an option, that runs without the GIL.

Fuzzing Engineering

Feeding a program automatically mutated inputs, guided by coverage, to find crashes and bugs.

G

Game day Distributed

A planned session where a team injects failures and practises detecting and handling them.

Garbage collector Node.js

The runtime part that frees objects nothing can reach any more.

Generated column Databases

A column whose value is computed from other columns of the same row by an expression, and stored automatically.

Generator Python

A function that uses yield to produce values one at a time, pausing between them.

Generics Python

Code written once for any type, with the type as a parameter, for example def first[T](xs: list[T]) -> T. The checker keeps track of which T is used at each call.

GIL Python

A lock in standard CPython that lets only one thread run Python bytecode at a time.

GIN index Databases

An inverted index in PostgreSQL that maps each element inside a value (a JSON key, a word) to the rows that contain it.

git bisect Git

A Git command that binary-searches your history to find the first commit that introduced a bug.

Git hook Git

A script Git runs automatically at a point in its workflow, such as before a commit.

Git object Git

A blob, tree, commit or tag stored under its hash in .git/objects.

git reset Git

Moves the current branch to another commit; the mode decides what happens to the index and working tree.

git revert Git

Undoes a commit by adding a new commit with the opposite patch, leaving history intact.

Gitlink Git

A tree entry (mode 160000) that records a commit id from another repository.

Go workspace (go.work) Engineering

A go.work file that makes several local Go modules resolve to each other without published versions.

GOAWAY Networking

An HTTP/2 frame that tells the peer to stop opening new streams on this connection.

Goroutine Go

A lightweight function execution managed by the Go runtime, not the OS.

Graceful shutdown Node.js

Stopping a server by refusing new work but letting in-flight requests finish before exiting.

Graph Algorithms

A set of vertices (nodes) connected by edges. Edges can be directed or undirected. Networks, maps, dependencies and friendships are all graphs.

Gray failure Distributed

A node that is not dead but so slow or flaky that it harms the system while still looking alive.

Greedy algorithm Algorithms

Making the locally best choice at each step and never revisiting it.

gRPC Go

A binary RPC framework built on HTTP/2 and Protocol Buffers.

H

Half-close Networking

Closing only the sending direction of a TCP connection while still reading.

Happens-before Distributed

The partial order of causality: program order, send before receive, and transitivity; events with no such path are concurrent.

Hard link Linux

A second name for the same inode. Both names are equal, the link count goes up, and the data is freed only when the last name is removed.

Hash chain Security

Each record stores the hash of the previous one, so any edit, deletion or reorder breaks every later link.

Hash collision Algorithms

Two different keys that map to the same slot of a hash table.

Hash slot Distributed

One of a fixed number of logical buckets that keys hash into; whole slots, not single keys, are assigned to and moved between nodes.

Hash table Algorithms

A structure that finds a key by computing its hash, giving O(1) lookups on average. Go's map is one.

HEAD Git

the pointer to the commit (usually via a branch) that your checkout is based on.

Head-of-line blocking Networking

One slow item at the front of a queue holds up everything behind it.

Health check Networking

A probe that tells a load balancer whether a backend can take traffic.

Heap snapshot Node.js

A dump of every live object in the JavaScript heap with sizes and references, used to find what holds memory.

Heap sort Algorithms

Build a max-heap in place, then repeatedly swap the root to the end and sift down; O(n log n), no extra memory, not stable.

Heapify Algorithms

Turning an unordered slice into a heap in place in O(n), by sifting down from the last parent to the root.

Heartbeat Networking

A periodic small message (such as a ping) used to find out whether the other side is still alive.

Hedged request Distributed

Sending a second copy of a slow request to another replica and using the first reply.

Here-document Linux

Shell syntax (`<<EOT`) that feeds the following lines to a command’s stdin. A quoted marker (`<<’EOT’`) disables variable expansion inside.

highWaterMark Node.js

The buffer size at which a stream starts asking producers to slow down (16 KiB by default for a Writable).

Hinted handoff Distributed

When a replica is down, another node holds its writes with a hint and hands them over when it returns.

HMAC Security

A message authentication code built from a hash and a secret key; unlike sha256(secret||msg) it resists length extension.

Hot key Distributed

A single key that receives so much traffic that the shard owning it is overloaded no matter how evenly the other keys are spread.

HOT update Databases

Heap-Only Tuple update: a new row version stored in the same page with no new index entries, possible when no indexed column changes.

HPACK Networking

The header compression scheme of HTTP/2.

HSTS Security

HTTP Strict Transport Security: a header telling the browser to use only HTTPS for this site for a period.

HTTP Networking

A text protocol for requests and responses, usually carried over TCP.

HTTP redirect Networking

A 3xx response with a Location header telling the client to request another URL.

HTTP trailers Networking

Header fields sent after the body, once the final result is known.

HTTP Upgrade Networking

A request header that asks the server to switch the connection to another protocol (101 Switching Protocols).

HttpOnly Security

A cookie attribute that hides the cookie from JavaScript running in the page.

Huffman coding Algorithms

A greedy prefix code that gives frequent symbols shorter bit strings.

Hunk Git

one contiguous block of changes inside a diff.

Hybrid logical clock Distributed

A timestamp combining physical time with a logical counter, close to real time yet respecting causality.

Hysteresis Distributed

Requiring several consecutive probes before changing state, so a flapping instance does not flip in and out of rotation.

I

I/O-bound Engineering

Work that spends most of its time waiting for the network or disk rather than computing.

ICMP Networking

The control-message protocol of IP, used for errors such as port unreachable.

Idempotency Messaging

Processing the same operation more than once has the same effect as processing it once.

Idempotency key Distributed

A unique id the client sends with a request so the server can recognise a retry and return the first result instead of acting twice.

Idle in transaction Databases

A session that opened a transaction and is doing nothing, still holding its connection and locks.

IDOR Security

Insecure direct object reference: an endpoint returns an object by its ID without checking that the caller may see it.

In-degree Algorithms

The number of edges pointing into a vertex; in dependency graphs, how many prerequisites it still waits for.

Incident response Security

The organised process of detecting, containing, removing and learning from a security incident.

Index Only Scan Databases

A plan node that answers a query from the index alone, without visiting the table.

inline script metadata Python

PEP 723: a comment block at the top of a single-file script that lists its dependencies and Python version.

Inode Linux

The filesystem record that holds a file's metadata (owner, mode, size, link count) and where its data lives. A name in a directory just points to an inode number.

Integer overflow Algorithms

A result too large for its integer type; in Go it wraps around silently.

Integration test Engineering

A test that runs several parts together, such as a service with a repository.

Invariant Algorithms

A condition that holds before and after every loop iteration, used to prove an algorithm correct.

iproute2 Linux

The Linux network tool family driven by the ip command.

IPv6 Networking

The 128-bit successor of IPv4, with hex notation, /64 subnets and no broadcast.

Isolation level Databases

The setting that decides how much one transaction sees of others running at the same time.

Iterator Python

An object with __next__ that returns the next value and raises StopIteration when it is done.

J

JetStream Messaging

The persistence layer of NATS: streams that store messages, and consumers that read them.

Jitter Distributed

Randomness added to a retry delay so clients stop retrying in lockstep.

JOIN Databases

Combining rows of two tables by a matching condition.

journald Linux

The systemd service that collects logs from services and the kernel into a structured journal.

JSON Schema Node.js

A vocabulary for describing the shape of a JSON document so a library can validate it automatically.

JSONB Databases

A PostgreSQL column type that stores JSON in a parsed binary form that can be indexed and queried.

JWKS Security

A JSON document, usually at /jwks.json, that publishes the public keys used to verify an issuer's signed tokens.

JWT Security

A signed token (header.payload.signature, base64url) carrying claims; signed, not encrypted.

K

Keep-alive Node.js

Reusing one TCP connection for several HTTP requests instead of opening a new one each time.

Key derivation function Security

A function that turns a password or a master secret into uniformly random keys of the needed length.

Key rotation Security

Replacing a key with a new one on a schedule or after exposure, while old data stays readable.

Keyset pagination Engineering

Paging by 'rows after this key' instead of 'skip N rows'.

Kill switch Engineering

a flag whose only job is to turn a feature off at once.

KMP algorithm Algorithms

String search that precomputes a failure function so the text pointer never moves backwards.

Knapsack problem Algorithms

Choose items with weights and values to maximise value within a weight capacity.

known_hosts Linux

The client-side file of server host keys already trusted, used to detect a changed or fake server.

kqueue Linux

The BSD and macOS event notification interface, the cousin of Linux epoll.

L

Lamport clock Distributed

A single counter per process, advanced on events and merged with max on receive, so that a happens-before b implies a smaller timestamp.

Last write wins Distributed

A conflict rule that keeps the value with the highest timestamp and discards the others.

Late binding Python

A closure looks up a variable by name when it runs, so it sees the variable's latest value.

Lazy deletion Algorithms

Not removing or editing an old entry; push a new one and skip the stale one when it is popped.

Lazy evaluation Python

Computing a value only when it is actually needed, not up front.

LCS Algorithms

The longest sequence that appears in both inputs in the same order, not necessarily contiguous.

Leader election Distributed

Choosing one node to coordinate for a period; in Raft a candidate needs votes from a majority in a new term.

Lease Distributed

A grant of a resource or a quota to a holder for a limited share or time.

Least privilege Linux

Give a process or person only the permissions needed for the job and nothing more, so a mistake or compromise has a small blast radius.

Legacy code Engineering

A common working definition: code without tests, so you cannot change it with confidence.

Length extension attack Security

An attack on hashes like SHA-256 where knowing H(secret||msg) lets you compute H(secret||msg||extra) without the secret.

Level-triggered and edge-triggered Linux

Two ways a readiness API reports events: while data is still waiting (level) or only when new data arrives (edge).

libuv Node.js

The C library under Node.js that provides the event loop, async I/O and a thread pool.

Lifecycle hook Node.js

A function the framework calls at a fixed stage of a request, such as before the handler runs.

Lifetime Rust

A compile-time annotation describing how long a reference stays valid.

Linear probing Algorithms

Open addressing strategy: if the slot is taken, try the next one, and the next, until a free slot or the key is found.

Linearizability Distributed

Every operation appears to take effect at one instant between its start and end, as if there were a single copy of the data.

Linked list Algorithms

A sequence of separately allocated nodes, each holding a value and a pointer to the next one (and sometimes the previous one). Cheap to splice, slow to index.

Linux capabilities Linux

The kernel splits the powers of root into separate units such as CAP_NET_BIND_SERVICE or CAP_CHOWN, so a process can hold only the ones it needs.

List comprehension Python

A Python expression that builds a list from an iterable in one line, e.g. [x * x for x in data if x % 2 == 0].

Listen backlog Networking

The size of the kernel queue of connections waiting for accept().

Little's law Engineering

In a stable system, average WIP equals throughput times average cycle time.

Live binding Node.js

an ES module import that points at the exporting module's variable itself, not at a copy of its value.

Load average Linux

Average number of runnable jobs (on Linux also those waiting for disk) over the last 1, 5 and 15 minutes.

Load balancer Networking

A component that spreads incoming traffic across several backend servers.

Load factor Algorithms

How full a hash table is: stored entries divided by slots. Past a threshold the table is rehashed into a bigger one.

Load shedding Distributed

Rejecting some requests early so the rest can still be served in time.

Lock Databases

A mechanism that makes a session wait before touching data another session is using; PostgreSQL has table-level and row-level locks.

lock_timeout Databases

A setting that makes a statement give up with an error if it waits too long for a lock.

lockfile Node.js

A file that records the exact versions, download URLs and hashes of every installed dependency.

Log injection Security

User input containing a newline or control character that forges extra log lines.

Log rotation Linux

Renaming, compressing and deleting old log files so a log never grows without bound.

Logical backup Databases

A backup made of SQL or row data (pg_dump, COPY) instead of copies of the data files.

Loopback Networking

The virtual interface that sends traffic back to the same machine: 127.0.0.0/8 and ::1.

Lost update Databases

Two transactions read the same value, both write a result computed from it, and one write silently overwrites the other.

Lower bound (search) Algorithms

The first index in a sorted array whose element is not less than the target.

LRU cache Algorithms

A cache with a fixed size that, when full, evicts the least recently used entry. Usually a map plus a doubly linked list.

LSN Databases

Log sequence number: a position in the WAL, shown like 0/1830840.

M

Mass assignment Security

A bug where the server copies every field of a client request into an internal object, so the client can set fields it should never control (price, status, role).

Memoization Python

Caching a function's result per argument so repeated calls skip the work.

Memory leak Node.js

Memory that is no longer needed but is still reachable, so the garbage collector cannot free it.

Memory safety Security

A language or tool guarantee that a program cannot read or write memory it does not own.

merge Git

joins two lines of history; if they diverged, Git creates a merge commit with two parents.

merge commit Git

a commit with two parents that records the joining of two histories.

Merge conflict Git

Git could not combine two changes to the same lines automatically and asks you to choose.

Merge sort Algorithms

Split in half, sort each half, merge the two sorted halves; always O(n log n), stable, but needs O(n) extra memory.

Merkle tree Distributed

A tree of hashes where each parent hashes its children, so equal root hashes mean equal data.

Message framing Networking

Rules that mark where one message ends in a byte stream such as TCP.

Microservices Distributed

Independently deployed services that each own their data and talk over the network.

Microtask Node.js

A small job (promise callback, queueMicrotask) that runs right after the current code, before the event loop continues.

Migration Databases

A versioned change to the database schema, applied in order by a script or a tool.

Minimum spanning tree Algorithms

The cheapest set of edges that connects every node of a weighted graph without forming a cycle.

Modular monolith Distributed

One deployable whose modules talk only through narrow interfaces.

monkeypatch Python

temporarily replacing an attribute, env var or dict item during a test

Monorepo Engineering

One repository that holds the code of several services or libraries, built and versioned together.

Monotonic clock Distributed

A clock that only moves forward and is meant for measuring durations, not for telling the date.

Monotonic reads Distributed

A client's successive reads never go back to an older value.

Monte Carlo simulation Engineering

Estimating a result by running a random model many times and reading percentiles.

MRO (method resolution order) Python

The order in which Python searches a class and its parents for an attribute; super() follows this order, and you can print it with Class.__mro__.

MSS Networking

Maximum Segment Size: the most TCP payload bytes per segment.

MTU Networking

Maximum Transmission Unit: the largest packet a link carries in one frame.

Multiplexing Networking

Sending many independent requests and responses at once over a single connection.

Mutation testing Engineering

Judging a test suite by whether it fails when the code is deliberately broken.

Mutex Go

A lock that lets only one goroutine at a time touch a piece of shared state.

Mutual TLS (mTLS) Networking

TLS where the client also presents a certificate and the server verifies it.

MVCC Databases

Multi-version concurrency control: the database keeps several versions of a row so readers and writers do not block each other.

N

N+1 queries Databases

One query to fetch a list, then one more query per item in the list.

Namespace Linux

A kernel feature that gives a process its own view of a resource such as PIDs, mounts, network or hostname.

Negative cycle Algorithms

A cycle whose edge weights sum to less than zero, so going around it forever keeps lowering the cost.

netfilter Linux

The kernel hooks in the network stack where packets can be filtered or changed.

Netmask Networking

A 32-bit mask whose leading ones mark the network part of an IPv4 address.

Network partition Distributed

A failure where nodes are alive but groups of them cannot reach each other.

nftables Linux

The Linux packet-filtering framework configured with nft.

no_new_privs Linux

A per-thread flag, set with prctl, that stops execve from granting more privilege through setuid bits or file capabilities. Once set it cannot be unset.

Node cluster Node.js

The `cluster` module: several Node processes sharing one listening port.

Non-blocking I/O Linux

A mode where read, write and accept return immediately with an error such as EAGAIN instead of making the thread wait.

Non-repeatable read Databases

Reading the same row twice in one transaction and getting different values.

Nonce Security

A value that must be used only once per key, such as the per-message input of AES-GCM.

Normalization Databases

Split tables so each fact is stored exactly once.

npm Node.js

The package manager that ships with Node.js and the default public registry of JavaScript packages.

NULL Databases

The SQL marker for an unknown or missing value.

NXDOMAIN Networking

The DNS response code meaning that the name does not exist.

O

OAuth 2.0 Security

A framework that lets an app get limited access to an API on a user's behalf through tokens, without seeing the user's password.

Object mode Node.js

A stream option where each chunk is any JavaScript value instead of bytes or a string.

OCSP Security

A way to ask a CA whether a specific certificate has been revoked.

OOM killer Linux

The kernel mechanism that kills a process when memory runs out, system-wide or inside a cgroup that hit memory.max.

OpenAPI Engineering

A standard YAML/JSON format for describing an HTTP API: paths, parameters, request and response schemas.

OpenID Connect (OIDC) Security

A thin identity layer on top of OAuth 2.0 that adds an ID token and a userinfo endpoint to tell the client who logged in.

Operational error Node.js

An expected runtime failure (bad input, missing record, timeout), as opposed to a bug.

Optimal substructure Algorithms

An optimal answer to the whole problem is built from optimal answers to its subproblems.

Optimistic concurrency Distributed

Do not lock; write with the version you read and fail if someone else wrote first, then reload and retry.

Orchestration Distributed

One coordinator sends commands to services in order and decides what happens on each reply or failure.

ORM Python

Object-relational mapper: a library that maps tables to classes and rows to objects.

Outbox pattern Messaging

Writing an event to a database table in the same transaction as the data change, then publishing it afterwards.

Output encoding Security

Escaping data for the exact context (HTML body, attribute, JavaScript, URL) it is written into.

Overcommit Linux

Letting processes reserve more virtual memory than physical RAM plus swap, because most of it is never touched.

Overlapping subproblems Algorithms

The same smaller problem is needed again and again by different branches of the recursion.

overlayfs Linux

A Linux filesystem that stacks a writable layer over read-only layers; container images use it for their layers.

OWASP Top 10 Security

A periodically updated list of the ten most critical web application security risk categories, published by OWASP.

Ownership Rust

Rust's rule that every value has exactly one owner, and is dropped when the owner goes out of scope.

P

PACELC Distributed

If there is a Partition choose Availability or Consistency, Else choose Latency or Consistency.

Packfile Git

A single Git file that stores many objects compactly, usually with delta compression.

Page cache Linux

The kernel's in-memory cache of file contents, which makes repeated reads of a file avoid the disk and is reclaimed when memory is needed.

Pagination Engineering

Returning a large list in pages instead of all at once.

Parameterized query Security

A SQL statement with placeholders (`$1`) whose values are sent separately from the SQL text.

Partial clone Git

A clone that skips some objects (e.g. file contents) and fetches them on demand.

Partial failure Distributed

One part of a system fails while the rest keeps running, so the caller cannot tell what happened.

Partial index Databases

An index that covers only the rows matching a WHERE condition.

Partition pruning Databases

The planner skipping partitions that cannot contain matching rows because the query filters on the partition key.

Password hashing Security

A deliberately slow, salted one-way function used to store passwords so a database leak does not reveal them.

Path compression Algorithms

During Find, point every node on the path straight at the root so later Finds are shorter.

Path traversal Security

A bug where `../` in user input makes a file handler read outside its intended directory.

Pepper Security

A secret value kept outside the database and mixed into password hashing, so a stolen database alone is not enough.

Percentile Engineering

The value below which a given share of observations fall; p99 is the latency 99% of requests beat.

perf Linux

Linux performance tool that counts hardware events and samples where CPU time goes.

PgBouncer Databases

A separate connection pooler placed between applications and PostgreSQL.

Phantom read Databases

Running the same query twice in one transaction and getting a different set of rows.

pickle Python

Python's built-in serialization of objects to bytes, used to send data between processes.

pip Python

Python's standard package installer, which downloads packages from PyPI.

Pipe Linux

Connects one command’s stdout to the next command’s stdin (`a | b`), so small tools chain into a pipeline.

PITR Databases

Point-in-time recovery: restore a base backup and replay archived WAL up to a chosen moment.

PKCE Security

Proof Key for Code Exchange: the client proves at the token request that it is the one that started the authorization request.

Planner statistics Databases

Per-column summaries that `ANALYZE` stores for the planner.

plumbing Git

Git's low-level commands (hash-object, write-tree, commit-tree...) that porcelain commands are built on.

Poison message Distributed

A message that makes its consumer fail every time, so redelivery never succeeds.

Polyrepo Engineering

Each service or library lives in its own repository and is released and versioned on its own.

Postmortem Engineering

A written review of an incident: what happened, its impact, why, and what to change.

Power of two choices Distributed

Load balancing rule: pick two random instances and send the request to the one with the shorter queue.

pprof Security

Go's profiling tool and the `net/http/pprof` handlers that expose profiles over HTTP.

Preflight request Security

An OPTIONS request a browser sends first to ask whether a cross-origin request with a custom method or header is allowed.

Prepared transaction Distributed

In PostgreSQL, a transaction detached from its session by PREPARE TRANSACTION, stored on disk and finished later by COMMIT PREPARED or ROLLBACK PREPARED.

Primary key Databases

The column(s) that identify each row uniquely.

Priority lane Distributed

A separate queue or consumer per priority, served in strict order so urgent messages never wait behind a backlog.

Priority queue Algorithms

An abstract container where you always remove the item with the highest priority first, not the oldest.

Process Linux

A running instance of a program, with its own pid, memory and a parent process.

Process group Linux

A set of related processes (for example a pipeline) that can receive a signal together.

Process substitution Linux

A bash/zsh feature, `<(cmd)`, that presents a command’s output as a file name, so tools that want files can read it (`diff <(a) <(b)`). Not POSIX.

procfs Linux

Linux's virtual /proc filesystem, where the kernel exposes process and system state as files.

Projection Distributed

A read model built by consuming events and maintaining a table shaped for queries; it can be dropped and rebuilt by replay.

Promise Node.js

A value that stands for a result that is not ready yet: pending, then fulfilled or rejected.

Property-based testing Engineering

Testing a rule that must hold for all inputs, with inputs generated automatically.

Protocol Buffers Networking

A compact binary format for structured messages, described in .proto files.

Prototype pollution Node.js

A JavaScript bug where attacker-controlled keys like __proto__ change the prototype of objects, so unrelated objects suddenly get extra properties.

ptrace Linux

The system call that lets one process observe and control another; strace and debuggers use it.

Pull consumer Messaging

A JetStream consumer where the client asks for messages instead of the server pushing them.

Pydantic Python

A Python library that validates and converts data using type hints.

PyO3 Python

A Rust library for writing Python extension modules (and calling Python from Rust).

PyPI Python

The Python Package Index, the default public registry that pip and uv download from.

pyproject.toml Python

The standard Python project file with metadata, the required Python version and direct dependencies.

Q

Query plan Databases

The tree of steps the database chooses to run a query, shown by EXPLAIN.

Query planner Databases

The part of the database that chooses how to run a query.

Queue Algorithms

A first-in, first-out collection: add at the back, remove from the front. Usually built on a ring buffer.

Queue group Distributed

Subscribers that share a name so each message goes to only one member of the group.

Quicksort Algorithms

Pick a pivot, partition the slice around it, then sort both sides recursively; O(n log n) on average, in place.

Quorum Distributed

A group of replicas whose agreement is required, usually a strict majority, so that any two quorums overlap.

R

Rabin–Karp Algorithms

String search that compares hashes of windows first and verifies real text only when hashes are equal.

Race condition Go

A bug where the result depends on the unsynchronized timing of concurrent accesses.

Raft Distributed

A consensus algorithm built from leader election, log replication and safety rules, designed to be easier to understand than Paxos.

Rate limiting Distributed

Capping how many requests a client may make in a time span.

RBAC Security

Role-based access control: users get roles, roles map to permissions.

RCE Security

Remote Code Execution: an attacker runs their own code on your server.

Read model Distributed

A copy of the data shaped for queries, built by applying the events of the write side; it may lag behind but must converge.

Read repair Distributed

When a read finds a replica holding an older version, the reader writes the newest version back to it.

Read-your-writes Distributed

After a client writes a value, its own later reads see that value or a newer one.

rebase Git

replays your commits on top of another base, producing new commits with new hashes.

Recursive resolver Networking

A DNS server that does the whole lookup for a client and caches the result.

Ref Git

a human-readable name that points to a Git object.

Refactoring Engineering

Changing the structure of code without changing its observable behavior.

Reference-class forecasting Engineering

Forecasting by looking at the outcomes of similar past projects, not at the details of this one.

reflog Git

A local log of where HEAD and branch tips have pointed, used to recover commits after a reset or deleted branch.

Refresh token Security

A long-lived credential that the client exchanges for a new short-lived access token.

Regression Engineering

A bug that breaks something which used to work.

Relational model Databases

A model where data lives in tables of rows and columns linked by keys.

Relaxation Algorithms

Updating a vertex's distance when a route through an edge is shorter than the best known.

Remote-tracking branch Git

a local, read-only record of a branch on a remote, like origin/main.

Rendezvous hashing Algorithms

Each key goes to the node with the highest hash(node, key) score (also called HRW).

Replicated log Distributed

An ordered list of commands copied to several nodes; if every node applies the same log in order, their state machines end up identical.

Replication Databases

Keeping a second, continuously updated copy of a database on another server.

Reproducible build Engineering

Building the same source twice gives byte-identical output, so a checksum can prove what was built.

Request ID Node.js

A unique identifier attached to one request and to every log line it produces.

Request smuggling Networking

An attack that exploits two HTTP parsers disagreeing about where a request ends.

rerere Git

Git feature (reuse recorded resolution) that replays a conflict resolution you made before.

Retry budget Distributed

A cap on retries as a fraction of normal requests, often kept in a token bucket.

Retry storm Distributed

Overload made worse by clients that retry failed requests all at once.

Reverse proxy Networking

A server that receives client requests and forwards them to backends on the client's behalf.

RFC Engineering

Request for Comments: a proposal document circulated for discussion before a decision is made.

A fixed array with a head index and a count where positions wrap around with modulo, so removing from the front never shifts elements. When full it can double (copying once) to keep amortized O(1) pushes.

Roll forward Distributed

fixing a bad release with a new release instead of reverting.

Rollback Engineering

Returning production to the previous known-good release, as opposed to rolling forward with a new fix.

Rolling hash Algorithms

A hash of a sliding window that is updated in O(1) by removing the old character and adding the new one.

Rolling update Distributed

a deploy that replaces instances one by one.

RSS Linux

Resident set size: the part of a process's memory currently held in physical RAM, not its whole virtual size.

RST Networking

A TCP segment that aborts a connection immediately, without the orderly FIN exchange.

Runbook Engineering

Step-by-step instructions for operating a system and handling a known failure.

Rune Algorithms

In Go, an int32 holding one Unicode code point; a string is bytes, and one character can be several bytes.

S

Saga Distributed

A long business transaction split into local transactions, each with a compensating action that undoes it if a later step fails.

Salt Security

A random value stored next to a password hash so equal passwords give different hashes.

SameSite Security

A cookie attribute that limits when the browser sends the cookie on cross-site requests.

Sargable Databases

A condition written so an index can be used for it.

Savepoint Databases

A named point inside a transaction that you can roll back to without abandoning the whole transaction.

SBOM Security

Software Bill of Materials: a machine-readable list of the components inside a build.

Scatter-gather Distributed

Sending a query to every shard and merging the partial answers, needed when the query does not contain the shard key.

Schema validation Node.js

Checking untrusted data against a declared shape (types, ranges, required fields) at the boundary, before the rest of the code uses it.

sdist Python

The source distribution of a Python package: an archive of the sources plus metadata, built into a wheel at install time if needed.

Seam Engineering

A place where you can change behavior without editing the code around it.

Secret scanning Security

Searching code and git history for credentials by pattern and entropy.

Seed corpus Security

The starting inputs given to a fuzzer, ideally real samples.

Selectivity Databases

The fraction of rows a condition keeps.

Semaphore Python

A counter-based primitive that lets at most N holders in at once; the rest wait.

Semver Node.js

A versioning scheme MAJOR.MINOR.PATCH, plus the range syntax (`^`, `~`) npm uses to pick versions.

Sequential consistency Distributed

All clients see one order of operations that keeps each client's own order, but it need not match real time.

Server-Sent Events Networking

A one-way, text-based stream of events from server to browser over a normal HTTP response.

Service discovery Distributed

Finding the current network addresses of the instances of a service while they come and go.

Service mesh Distributed

A layer of sidecar proxies next to each service that handles discovery, load balancing, retries and TLS outside the application code.

Service registry Distributed

A small service that stores which instances are alive; instances register with a TTL and keep renewing it.

Session Security

Server-side state that is looked up by a random id stored in a cookie.

setuid and setgid Linux

Mode bits that make an executable run with its owner's (or group's) identity instead of the caller's; on a directory, setgid makes new files inherit its group. They show as s in ls -l.

SHA-1 Git

Hash function Git uses by default to name objects (40 hex characters).

Shadow mode Engineering

Running the new implementation next to the old one on real inputs, serving only the old answer and counting differences.

Shallow clone Git

A clone with truncated history, e.g. git clone --depth 1.

Shallow copy Python

A copy that duplicates only the outer container; the elements inside are still the same objects. A deep copy duplicates them too.

Shannon entropy Security

A measure of how random a string looks, in bits per character.

Sharding Distributed

Splitting one dataset across several nodes by a shard key, so each node owns only part of the data.

shared memory Python

A block of memory that several processes map at once, so they can read and write the same bytes without copying.

SharedArrayBuffer Node.js

A memory block visible to several threads at once, used with Atomics.

Shrinking Engineering

Reducing a failing random input to the smallest one that still fails.

SIGKILL Linux

The forced kill (signal 9); it cannot be caught or ignored, so no cleanup code runs.

Signal Linux

A small asynchronous message the kernel or another process sends to a process, such as SIGTERM or SIGINT.

SIGPIPE Linux

The signal a process gets when it writes to a pipe whose reader has closed (signal 13).

SIGTERM Node.js

The polite signal that asks a process to stop, which it may catch to clean up first.

site-packages Python

The folder inside an environment where installed third-party packages are placed.

Size class Algorithms

The Go allocator rounds each request up to one of a fixed set of block sizes. That is why a slice's capacity can be larger than the growth formula alone predicts.

SKIP LOCKED Databases

A `SELECT ... FOR UPDATE` option that skips rows other sessions have locked instead of waiting, used to build job queues.

SLI Engineering

Service level indicator: a measured ratio of good events to total events, such as non-5xx requests.

Slice (Go) Algorithms

A Go slice is a three-word header: a pointer to a backing array, a length and a capacity. Copying the header does not copy the elements.

Sliding window counter Distributed

An approximate limiter that weights the previous fixed window by how much of it still overlaps the last interval.

SLO Engineering

A target for a service level indicator over a window, for example 99.5% of requests succeed in 30 days.

Slowloris Node.js

A denial-of-service pattern where a client sends a request extremely slowly to hold server connections open.

Smoke test Engineering

A very small check that the built artifact starts and answers at all, before deeper checks or deploy.

Snapshot (event sourcing) Distributed

A saved copy of folded state at some version, so loading replays only the events after it.

Snapshot isolation Databases

Each transaction reads from a consistent snapshot of the data taken when it started.

SNI Networking

Server Name Indication: the client names the host it wants inside the TLS handshake.

Socket Networking

The operating system handle an application uses to send and receive over the network.

software supply chain Security

Everything your software is built from and delivered by: dependencies, registries, build tools and CI.

Sparse checkout Git

Checking out only chosen directories into the working tree.

Split-brain Databases

Two nodes both believe they are the primary and accept different writes.

SQL injection Security

An attack where user input becomes part of the SQL text and changes its meaning.

SQLSTATE Databases

A five-character standard error code, e.g. 23505 for a unique violation.

squash merge Git

collapses all commits of a branch into one new commit on the target branch.

SSH certificate Linux

A public key signed by a CA key, with principals and a validity period, instead of a list of raw keys.

SSH key pair Linux

A private key you keep plus a public key you share, used to log in without a password.

ssh-agent Linux

A process that keeps decrypted private keys in memory and signs on behalf of ssh.

SSRF Security

Server-side request forgery: making the server fetch a URL chosen by the user, so it reaches places the user cannot.

Stable sort Algorithms

A sort that keeps equal elements in their original relative order.

Stack Algorithms

A last-in, first-out collection: you only push and pop at one end. Typical uses are undo history, bracket matching and the call stack.

Staging area (index) Git

the snapshot of what the next commit will contain, stored in .git/index.

start method Python

How multiprocessing creates a child process: spawn (fresh interpreter), fork (copy of the parent) or forkserver.

Stash Git

a stack of shelved changes you can put back later.

statement_timeout Databases

A PostgreSQL setting that cancels any single statement running longer than the given time.

Static analysis Engineering

Checking source code for likely bugs without running it.

Statistical power Distributed

the chance a test detects a real effect.

Steady state Distributed

A measurable description of normal behaviour, such as an SLO, that an experiment must not violate.

Stemming Databases

Reducing a word to its stem so that different forms match, for example running, runs and run all become run.

Sticky bit Linux

A directory mode bit (t in ls -l) that lets only a file's owner or the directory's owner delete or rename entries, as in /tmp.

Stop-and-wait Networking

A reliability scheme: send one packet, wait for its acknowledgement, resend on timeout.

strace Linux

Linux tool that prints the system calls and signals of a process.

Strangler fig Engineering

Replacing a system piece by piece behind a router, so old and new run side by side.

Stream Node.js

An object that moves data in chunks, so a program never needs the whole thing in memory.

STRIDE Security

A checklist of six threat categories: Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege.

Structural pattern matching Python

Python's match statement, which destructures a value by shape (literals, sequences, mappings, classes) and can add guards.

Structural typing (Protocol) Python

A type is satisfied by any object that has the right methods, with no explicit inheritance. In Python, typing.Protocol describes this shape for type checkers.

Structured concurrency Python

A style where concurrent tasks live inside a scope that waits for all of them and cancels the rest if one fails.

Structured logging Node.js

Writing each log line as a JSON object with named fields instead of free text.

SubjectAltName (SAN) Networking

The certificate extension that lists the DNS names and IPs it is valid for.

Submodule Git

A repository nested inside another one and pinned to one exact commit.

Subnet Networking

A contiguous block of IP addresses sharing one prefix.

Subpath imports Node.js

The `imports` field of package.json: private aliases that start with `#` and map to files.

Subtree Git

A way to copy another repository's files into a subdirectory of yours, keeping their history mergeable.

sudo Linux

A program that runs one command as another user (usually root) if the sudoers policy allows it, and logs the attempt.

sudoers Linux

The policy file that says which users may run which commands as which target users via sudo; edit it only with visudo, which checks the syntax.

Surrogate key Databases

An artificial row identifier with no business meaning, such as an identity number.

Swap Linux

Disk (or compressed memory) space the kernel uses to move rarely used anonymous memory pages out of RAM.

Symbolic link Linux

A small file whose content is a path to another file. It has its own inode and dangles if the target is removed.

synchronous_commit Databases

The PostgreSQL setting that decides whether COMMIT waits until its WAL is flushed to disk.

Syslog severity Linux

The eight standard log levels from 0 (emerg) to 7 (debug), defined by syslog(3).

System call Linux

A request from a program to the kernel, such as open or read; tools like strace list them.

systemd Linux

The init system and service manager on most Linux distributions, running as PID 1.

T

Table bloat Databases

Wasted space in a table or index left by dead row versions that were never reused.

Table partitioning Databases

Splitting one big logical table into smaller physical tables (partitions) by a key such as a date range, a list of values or a hash.

Table rewrite Databases

An ALTER that copies the whole table into a new file while holding a strong lock.

Tail latency Distributed

The slowest few percent of requests (p99, p999), which dominate what users feel in fan-out systems.

TCP Networking

A reliable, ordered byte-stream protocol on top of IP.

TCP keepalive Networking

Probe packets the kernel sends on an idle connection to detect a dead peer.

TCP/IP model Networking

The 4-layer model of the internet: link, internet, transport, application.

TDD Engineering

Test-driven development: write a failing test, make it pass, then clean up (red, green, refactor).

Technical debt Engineering

Shortcuts or aging choices in code that make future change slower, like a loan that charges interest.

Test double Node.js

A fake object (mock, stub, fake) that replaces a real dependency in a test.

Test pyramid Engineering

A model: many fast unit tests, fewer integration tests, very few end-to-end tests.

Test runner Node.js

The tool that finds and runs test files and reports the results.

Thread Python

An independent flow of execution inside a process that shares its memory with other threads.

Thread pool Node.js

A fixed set of worker threads that run blocking work (files, crypto, DNS) for Node.js; default size 4.

Threat modeling Security

A structured way to ask what you are building, what can go wrong and what you will do about it, before attackers ask the same questions.

Three-way handshake Networking

SYN, SYN-ACK, ACK: how TCP opens a connection.

Three-way merge Git

Merge that compares two branch tips against their common ancestor.

Thundering herd Linux

Many waiting processes or threads are all woken by one event, but only one can use it, wasting work.

TIME_WAIT Networking

The state of the side that closed first, kept for a while after the connection ends.

TLS Networking

Transport Layer Security: encrypts and authenticates a connection on top of TCP.

TOCTOU Security

Time-of-check to time-of-use: the state changes between the check and the action that relied on it.

Token bucket Distributed

A limiter that refills tokens at a fixed rate and spends one per request, allowing bursts up to its capacity.

Tolerant reader Engineering

A client that ignores fields it does not know, so additive API changes do not break it.

Tombstone Algorithms

A marker left in an open-addressing table when an entry is deleted, so lookups keep probing past it.

Top-level await Node.js

using `await` directly at the top of an ES module, outside any async function.

Topological sort Algorithms

An ordering of a DAG's vertices in which every edge goes from earlier to later.

traceroute Networking

Lists the routers on the path to a host by sending packets with a growing TTL.

Trait Rust

A set of methods a type can implement, Rust's way of sharing behavior.

Transaction Databases

A group of statements that the database treats as one unit: all of them take effect, or none do.

transitive dependency Node.js

A package you did not ask for directly but that one of your dependencies needs.

tree Git

The Git object that represents a directory: names, modes and hashes of blobs and subtrees.

Tree rotation Algorithms

A local rewiring of two or three nodes that changes the shape of a search tree but keeps its in-order sequence.

Tree traversal Algorithms

A systematic order for visiting every node: pre-order, in-order, post-order or level-order.

Trie Algorithms

A tree where each edge is one character, so words that share a prefix share a path. Lookup cost depends on the word length, not on the number of words.

Trigger Databases

A function the database runs automatically before or after an INSERT, UPDATE or DELETE on a table.

Trigram Databases

A group of three consecutive characters; comparing the trigram sets of two strings gives a similarity score used for fuzzy matching.

Trunk-based development Git

everyone integrates small changes into the main branch at least daily.

Trust boundary Security

A line in a diagram where data passes between parts that trust each other differently, for example from the internet into your API.

Truthiness Python

How an object behaves in a boolean context. In Python zero, None and empty containers are false; most other values are true.

tsvector Databases

A PostgreSQL type holding a document as a sorted list of normalized words (lexemes) with their positions, used for full-text search.

TTFB Networking

Time to first byte: how long until the first byte of the response arrives.

TTL Networking

How many seconds a cached record may be reused before asking again.

Two-phase commit (2PC) Distributed

A protocol where a coordinator asks all participants to prepare, then tells them all to commit or all to abort.

Type affinity Databases

SQLite's rule that a column prefers a type and converts values when it can, but does not strictly enforce it.

Type checker Python

A tool such as mypy that reads type hints and reports type errors without running the program.

Type hint Python

An optional annotation such as x: int or -> str that states the expected type. The interpreter stores it but does not enforce it; type checkers read it.

typosquatting Security

Publishing a malicious package whose name is a near-miss of a popular one, hoping for a typo.

U

Ubiquitous language Engineering

The shared vocabulary used by developers and domain experts, and used literally in the code.

UDP Networking

A connectionless datagram protocol on top of IP, with no delivery guarantee.

umask Linux

A per-process mask of permission bits that are removed from the mode of newly created files and directories. With 022, a new file gets 644 and a directory 755.

Unhandled rejection Node.js

A rejected promise that nobody handled with catch or try/catch.

Union by size Algorithms

When merging two trees, attach the smaller under the larger root so trees stay shallow.

Union-find Algorithms

A structure that tracks which elements belong to the same group, with Find (which group?) and Union (merge two groups).

Unit file Linux

A small INI-like text file that tells systemd how to run or schedule one thing.

Unit of work Python

A pattern where an object tracks changes and writes them together in one transaction.

Unsafe deserialization Security

Rebuilding objects from untrusted bytes with a format that can run code while decoding, such as Python pickle.

Upcasting Distributed

Converting an old stored event shape to the current one while reading, instead of editing stored events.

Use-after-free Security

Using a pointer after the memory it points to has been freed.

Utilization Distributed

The fraction of time a server is busy: arrival rate divided by service rate.

uv Python

A fast tool that manages Python versions, virtual environments, dependencies and lock files.

V

VACUUM Databases

The PostgreSQL maintenance command that removes dead row versions and updates the visibility map.

Value object Engineering

An immutable object with no identity, compared by its values, such as money or an email address.

Vector clock Distributed

One counter per process; comparing two vectors tells before, after or concurrent exactly.

Version vector Distributed

A vector clock attached to a stored value so replicas can tell an update from a conflicting one.

veth Linux

A pair of virtual Ethernet interfaces: what goes in one end comes out the other.

virtual environment Python

An isolated folder with its own interpreter link and site-packages, so each project has its own dependencies.

Visibility map Databases

A per-table bitmap that marks heap pages where all rows are visible to every transaction.

W

WAL Databases

Write-ahead log: PostgreSQL records every change in a sequential log before it touches the data files.

Walrus operator Python

The := operator in Python, which assigns a value to a name inside an expression, e.g. if (n := len(x)) > 5.

WebSocket Networking

A protocol for a persistent two-way message channel, started by an HTTP upgrade.

wheel Python

A built Python package: a zip file ending in .whl that can be installed without running any build step.

WIP limit Engineering

A cap on how many items may be in progress at once.

Word splitting Linux

The shell step that splits an unquoted expansion into separate words.

Worker pool Go

A fixed number of goroutines consuming jobs from a shared queue.

Worker threads Node.js

Threads inside one Node process, each with its own event loop and heap, for CPU-bound work.

Working tree Git

the files on disk that you edit, as opposed to what Git has staged or committed.

Worktree Git

An extra working directory attached to the same repository, with its own checked-out branch.

Write skew Databases

Two transactions read overlapping data, each updates a different row, and together they break a rule neither broke alone.

X

X.509 certificate Networking

A signed document binding a public key to a name, with a validity period.

xargs Linux

Reads items from stdin and runs a command with them as arguments. Use `-0` with `find -print0` so file names containing spaces survive.

XSS Security

Cross-site scripting: attacker-controlled text is rendered as HTML or JavaScript in another user's browser.

Z

Zipf distribution Distributed

A skewed access pattern where a few keys get most requests and a long tail gets few.

Zombie process Linux

A child that has exited but whose parent has not yet called `wait`, so its table entry remains.

_

__slots__ Python

.