Reference

A–Z

Glossary

Every line has the same three parts: the term, the plain meaning, then the technical meaning. Where a word means two different things in two fields, both senses are given as separate lines.

Filter terms

A

A record — the DNS entry holding an IPv4 address — a resource record of type A mapping a name to a 32-bit address; AAAA does the same for IPv6.

ABI — the binary rulebook two compiled parts must share — application binary interface: calling convention, register use, struct layout, symbol naming.

Abstraction — hiding detail behind a simpler idea — a layer offering a stable interface while the implementation beneath is free to change.

Activation — a number flowing through a network as it runs — a layer’s output for one input, alive only during the pass and not part of the model.

Activation function — the bend that stops a network being one straight line — an elementwise nonlinearity such as ReLU, GELU or SwiGLU.

ADC — turns a real signal into numbers — analogue-to-digital converter, sampling a voltage at a fixed rate and quantizing to a fixed bit depth.

Address space — every address a program is allowed to name — the range of addresses a process can generate, commonly 2^48 bytes of user space on 64-bit systems.

AES — the normal way to scramble bulk data — Advanced Encryption Standard, 128-bit block cipher with 128, 192 or 256-bit keys, FIPS 197, 2001.

Agent — a model that acts instead of only answering — a loop where a model picks a tool call, the tool runs, the result returns, until a stop condition.

Aliasing — false patterns from sampling too slowly — signal components above half the sample rate folding back as lower, wrong frequencies.

Alignment (memory) — putting data at tidy addresses — placing an object at an address that is a multiple of its size, required or faster on most architectures.

Alignment (AI) — making a model behave as intended — the work of getting model behaviour to match stated human intent, values and constraints.

Allocator — the code that hands out memory — the runtime or kernel component that finds, records and returns memory blocks to callers.

Alpha channel — how see-through a pixel is — a per-pixel opacity value, usually 8 bits, used when compositing layers.

ALU — the part that does the sums — arithmetic logic unit, a combinational block performing add, subtract, bitwise and shift operations and setting flags.

Amdahl’s law — the slow part limits your speedup — speedup is bounded by 1/(s + p/N) for serial fraction s over N processors.

Ampere — how much electricity flows per second — the SI unit of current, one coulomb of charge per second.

Amplitude — how big a wave is — the peak deviation of a signal from its resting value; in audio it maps to loudness.

Analogue — smoothly varying, not stepped — a signal that may take any value in a continuous range, unlike a digital signal with discrete levels.

Anti-aliasing — smoothing jagged edges — MSAA, FXAA, TAA and similar methods that add or reuse samples to reduce sampling artefacts.

Anti-cheat — software that catches players who cheat — combined client integrity checks, server-authoritative rules and statistical detection.

Anycast — one address, many machines — announcing the same prefix from several sites so each client reaches the topologically nearest one.

Apex domain — the bare name with no www — the zone’s own name, such as example.com, which cannot hold a CNAME under standard DNS rules.

API — an agreed way for programs to ask each other for things — the endpoints, functions, arguments and guarantees one piece of software offers another.

Argon2 — a password hash built to be slow and greedy for memory — winner of the 2015 Password Hashing Competition, with time, memory and parallelism costs.

ARM — the processor family in nearly every phone — a RISC architecture licensed as designs by Arm Ltd, first silicon working in 1985.

ARP — finding a neighbour’s hardware address — Address Resolution Protocol, RFC 826, broadcasting for the MAC address owning an IPv4 address on the link.

ARPANET — the network the internet grew out of — the ARPA-funded packet network, first message 29 October 1969, retired 1990.

Artifact — a file a build makes and keeps — a stored pipeline output such as a binary, image or test report, retained for later jobs or download.

ASCII — numbers for English letters — a 7-bit character set from 1963 with 128 code points, 95 printable and 33 control codes.

ASLR — moving things so attackers cannot guess addresses — address space layout randomization of stack, heap and library bases at load time.

Assembler — turns readable instructions into machine code — a translator producing one machine instruction per mnemonic and resolving labels and directives.

Assembly language — machine code you can read — a notation with one mnemonic per instruction, plus labels, macros and assembler directives.

AST — a program drawn as a tree — abstract syntax tree, the parser’s output, with nodes for expressions and statements and no punctuation.

Asynchronous — start now, collect the answer later — an operation returning before completion, signalling later by callback, event, future or poll.

Atomic — all at once or not at all — an operation no observer can see half-finished, enforced by hardware instructions, locks or transactions.

Attention — letting each word look at the others — a weighted sum of value vectors, weighted by the scaled dot product of one query with every key.

Attenuation — a signal weakening with distance — loss of power along a path, measured in decibels, from resistance, absorption or spreading.

Authoritative server — the machine holding the real answer for a name — a DNS server answering from its own zone data rather than from cache.

Autonegotiation — two ports agreeing a speed by themselves — Ethernet link partners exchanging capability pulses and choosing the best shared speed and duplex.

Autonomous system — one network under one routing policy — an AS with a 16 or 32-bit number that announces its prefixes to neighbours using BGP.

Availability — how much of the time it works — uptime as a fraction; 99.9 percent permits about 43 minutes of downtime per month.

Availability zone — one isolated site inside a cloud region — a data centre with independent power and cooling, linked to its region at low latency.

AVX — wide maths instructions on x86 chips — Advanced Vector Extensions, SIMD sets using 256-bit registers, or 512-bit in AVX-512.

B

Backpressure — telling the sender to slow down — a flow-control signal propagated upstream when a consumer cannot keep up.

Backpropagation — working out which weight caused which mistake — reverse-mode automatic differentiation applying the chain rule from the loss back to every parameter.

Bandwidth — how much can flow per second — the data rate of a link in bits per second, distinct from latency, which is delay.

Bandwidth throttling — deliberately slowing traffic — rate limiting applied by policy at a network device, service or account level.

Bandwidth-delay product — how much data fits inside the wire — bandwidth multiplied by round-trip time, the amount that must be in flight to keep a link full.

Bank (memory) — one independently addressed section of a chip — a DRAM subdivision with its own row buffer, allowing one row open per bank.

Bare repository — a git repository with no working files — a repository containing only the object database and refs, normally used as a push target.

Base model — the raw model before it is taught manners — a network trained only on next-token prediction, not yet instruction-tuned or preference-tuned.

Base station — the mast your phone talks to — the mobile network’s radio equipment serving one or more cells, called an eNodeB in LTE and gNodeB in 5G.

Batch — a handful of examples processed together — the group of samples whose gradients are averaged before one parameter update.

bcrypt — an old but sound password hash — a 1999 adaptive hash based on Blowfish, with a cost factor that raises work as hardware improves.

Beamforming — aiming a radio signal instead of shouting everywhere — controlling phase across several antennas so signals add in one direction and cancel elsewhere.

Benchmark — a test everyone runs so results can be compared — a fixed task and scoring rule; it measures the benchmark first and the world second.

BGP — how networks tell each other which routes they have — Border Gateway Protocol, RFC 4271, a path-vector protocol carrying prefixes and AS paths between autonomous systems.

Bias (AI) — the number added after the multiply — a per-unit learned constant added to the weighted sum before the activation function.

Big-endian — the biggest byte first — a byte order storing the most significant byte at the lowest address; network byte order is big-endian.

Binary — counting with only 0 and 1 — base-2 positional notation, where each place is worth twice the one to its right.

Binary search — halving the haystack each time — locating a value in sorted data in O(log n) comparisons by discarding half the range each step.

Binning — sorting finished chips by how good they turned out — testing dies and selling them at the highest speed and core count they pass.

BIOS — the old start-up firmware on PCs — the 16-bit firmware that initializes hardware and loads a 512-byte boot sector, superseded by UEFI.

Bisect — a binary search through history for the bad commit — git bisect, halving the commit range each test to find the first bad commit in log2(n) steps.

Bit — one on-or-off — a binary digit, the smallest unit of information, value 0 or 1.

Bit depth — how many steps a sample can take — the number of bits per sample; 16-bit audio gives 65,536 levels and about 96 dB of dynamic range.

Bit rot — data quietly going bad — undetected corruption of stored bits from charge leakage, media decay or cosmic rays, caught only by checksums.

BLE — the low-power half of Bluetooth — Bluetooth Low Energy, introduced in version 4.0 in 2010, using 40 channels and short connection events.

BLE GATT — the rules for reading a small value over Bluetooth — Generic Attribute Profile, a table of services and characteristics addressed by handle and UUID.

Blob — git’s word for a file’s contents — a git object holding raw bytes, named by the SHA-1 or SHA-256 of a header plus the content.

Block (storage) — the smallest lump a drive reads or writes — a fixed-size unit, 512 bytes or 4096 bytes on disks, and typically 128 KiB to 4 MiB in NAND erase blocks.

Blocking — waiting instead of doing something else — a call that does not return until its work completes, holding the calling thread.

Boolean algebra — the maths of true and false — an algebra over {0,1} with AND, OR and NOT, shown by Shannon in 1937 to describe switching circuits.

Boot sector — the very first block a machine reads from a disk — the first 512-byte sector, holding MBR partition entries and a small loader on legacy systems.

Bootloader — the small program that starts the real one — code that loads and hands control to a kernel, such as GRUB, systemd-boot or U-Boot.

Bootstrapping — a compiler built with itself — writing a compiler for a language in that same language, after first compiling it with another one.

Boule — the big silicon crystal a wafer is sliced from — a single-crystal ingot, typically 300 mm across, pulled from a melt by the Czochralski process.

BPE — cutting text into common chunks — byte-pair encoding, repeatedly merging the most frequent adjacent pair to build a fixed-size subword vocabulary.

Branch (CPU) — an instruction that may jump — a control-flow instruction whose target or direction may depend on a condition.

Branch (git) — a moving name for a line of work — a ref under refs/heads that points at one commit and moves forward as you commit.

Branch prediction — guessing which way a jump goes before knowing — hardware predicting direction and target so the pipeline keeps fetching; a wrong guess costs the pipeline depth.

Bridge — a device joining two network segments — a layer 2 device forwarding frames by learned MAC address; a switch is a multi-port bridge.

BSSID — the identity of one specific access point — the 48-bit MAC address of an access point’s radio, unlike an SSID, which is a network name.

Buffer — a waiting area for data — memory holding data between a producer and a consumer running at different speeds.

Buffer overflow — writing past the end of a box — writing beyond an allocation’s bounds, corrupting adjacent memory and often control data such as return addresses.

Bufferbloat — too much queueing makes everything feel slow — excessive buffering in network devices that inflates latency under load without preventing loss.

Bus — a shared set of wires — a set of conductors and rules carrying address, data and control signals between components.

Byte — eight bits, the usual unit of size — an octet, 8 bits, able to hold 256 distinct values.

Bytecode — halfway between source and machine code — a compact instruction set for a virtual machine, such as JVM bytecode or Python’s .pyc format.

C

Cache — a small fast copy of things you keep needing — memory holding recently or likely used data closer to the consumer than the original.

Cache coherence — keeping every core’s copy honest — a protocol such as MESI ensuring all cores see one consistent value for each cache line.

Cache hit — the copy was already there — a request satisfied from the cache without going to the slower backing store.

Cache line — the block a cache moves as one unit — the unit of transfer between cache levels, 64 bytes on most current x86 and ARM designs.

Cache miss — the copy was not there — a request that must be served from the next level, costing that level’s latency.

Callback — code you hand over to be run later — a function passed to another routine to be invoked when an event or completion occurs.

Canary release — trying a change on a few users first — routing a small share of traffic to a new version and watching error rates before wider rollout.

Capability — permission attached to a token, not a person — a transferable right to do a specific operation, held as an unforgeable reference.

Capacitor — a component that stores a little charge — two conductors separated by a dielectric, storing charge Q equal to capacitance C times voltage V.

CDN — copies of a site kept near users — content delivery network: caches in many locations, steered by DNS or anycast to reduce distance and origin load.

Certificate — a signed statement that a key belongs to a name — an X.509 document binding a public key to identifiers, signed by an issuer and valid between two dates.

Certificate authority — an organization browsers already trust — a CA whose root certificate ships in trust stores and which signs certificates after validating control of a name.

Certificate pinning — accepting only one specific certificate — a client refusing certificates other than pinned keys, ignoring the wider CA set.

CGNAT — your provider sharing one public address between many homes — carrier-grade NAT, usually using 100.64.0.0/10 from RFC 6598.

cgroup — a fence around how much a process may use — a Linux control group limiting and accounting CPU, memory, I/O and process counts for a set of tasks.

Chain of trust — a signed line from a root to your site — the verification path from a trusted root through intermediates to the leaf certificate.

Check run — one automated test result on a commit — a status object on a forge, attached to a specific commit SHA, with a conclusion such as success or failure.

Checkout — putting a commit’s files into your folder — updating the working tree and HEAD to match a specified commit, branch or path.

Checksum — a small number that proves nothing got mangled — a value computed over data and compared after transfer or storage to detect accidental change.

Cherry-pick — copying one commit onto another branch — applying a single commit’s diff elsewhere, creating a new commit with a new hash.

Chinchilla — the finding that models were trained on too little data — the 2022 DeepMind result giving compute-optimal token and parameter ratios.

Chiplet — a big chip built from several smaller ones — separate dies packaged together and joined by a high-speed interconnect, improving yield and mixing process nodes.

Chunk — a piece of a bigger thing sent on its own — a bounded portion of data transferred or processed separately, as in chunked transfer encoding.

CIDR — writing an address range as a prefix — Classless Inter-Domain Routing, RFC 1519, notation such as 192.168.0.0/24 giving address and prefix length.

Cipher suite — the exact set of algorithms a connection uses — the negotiated combination of key exchange, authentication, bulk cipher and MAC or AEAD mode.

Circuit switching — a dedicated path reserved for one call — reserving capacity end to end for the call’s duration, unlike packet switching, which shares links.

Client prediction — the game moving you before the server replies — applying local input immediately and reconciling later against authoritative server state.

Clock — the machine’s heartbeat — a periodic square wave defining the instants at which state elements sample their inputs.

Clock domain — a region sharing one clock — part of a chip driven by one clock, with synchronizers needed for signals crossing to another domain.

Closure — a function that remembers where it came from — a function value together with captured bindings from its defining scope.

Cloud region — a geographic cluster of data centres — a named location such as ap-south-1, containing several availability zones with independent failure domains.

CMOS — the way nearly all logic is built — complementary metal-oxide-semiconductor, pairing n-channel and p-channel FETs so steady states draw almost no current.

CNAME — a name that points to another name — a DNS record aliasing one name to another, after which resolution restarts at the target.

Coalescing — joining small pieces into one bigger one — combining adjacent free blocks, memory accesses or writes to reduce overhead.

Codec — the thing that squeezes and unsqueezes media — coder-decoder: the algorithm pair compressing and decompressing audio or video, such as AAC, H.264 or AV1.

Codepoint — the number that identifies a character — a Unicode scalar value from U+0000 to U+10FFFF, excluding the surrogate range.

Cold start — the first call being slow — the delay while a serverless platform allocates and initializes an execution environment before running your code.

Cold storage — cheap storage you rarely read — archival tiers with low cost per gigabyte and retrieval delays measured in minutes to hours.

Colour space — the agreed meaning of a colour number — a defined set of primaries, white point and transfer function, such as sRGB, Display P3 or Rec. 2020.

Commit — a saved snapshot with a message — a git object naming a tree, zero or more parents, author, committer, timestamps and a message, identified by its hash.

Compaction — tidying storage by rewriting it — merging and rewriting data to reclaim space, as in log-structured stores and SSD garbage collection.

Compiler — turns source code into machine code — a program translating a whole source program into another language, usually machine code, before it runs.

Compression — making data smaller — encoding that reduces size, lossless if the original returns exactly, lossy if some information is discarded.

Concurrency — several things in progress at once — structuring work so tasks overlap in time; parallelism means they literally run at the same instant.

Conflict (git) — two edits to the same lines — a merge where the same region changed on both sides, leaving markers for a human to resolve.

Constant folding — doing the maths at compile time — a compiler optimization evaluating constant expressions during compilation.

Container — an isolated box for one program and its files — a process group isolated by kernel namespaces and limited by cgroups, sharing the host kernel.

Container (media) — the wrapper holding audio and video together — a file format such as MP4, MKV or WebM carrying encoded streams, timing and metadata.

Contamination — a model already saw the exam — benchmark test data appearing in training data, inflating scores without matching ability.

Context switch — the CPU swapping one task for another — saving one thread’s registers and state, then loading another’s, costing roughly one to a few microseconds.

Context window — how much a model can read at once — the maximum number of tokens a model may attend over in one request, including its own output.

Continuous delivery — every good build is ready to ship — an automated pipeline that keeps the main branch in a deployable state, with release as a decision.

Continuous integration — merging often, tested every time — the practice of integrating work frequently, with an automated build and test on every change.

Control plane — the part that decides — the systems computing routes, policy and configuration, as opposed to the data plane that moves packets.

Cookie — a small note a site asks your browser to keep — a name-value pair stored by the browser and returned on matching requests, defined by RFC 6265.

Copy-on-write — share until someone writes — mapping the same pages into several users and duplicating a page only when one of them modifies it.

Core — one complete processor inside a chip — an independent set of execution units, registers and L1 caches able to run its own instruction stream.

Coroutine — a function that can pause and resume — a routine with suspendable execution state, allowing cooperative multitasking without OS threads.

CORS — a site giving permission for another site to read it — Cross-Origin Resource Sharing: response headers letting a browser relax the same-origin policy.

CPU — the part that follows the instructions — central processing unit, the general-purpose processor fetching, decoding and executing instructions.

CPU-bound — limited by thinking, not waiting — a workload whose completion time is set by processor throughput rather than I/O.

CRC — a strong checksum for detecting damage — cyclic redundancy check, polynomial division over GF(2); CRC-32 protects Ethernet frames.

Cross-compilation — building on one machine for another — producing binaries for a target architecture or OS different from the build host.

Cryptographic hash — a fingerprint of any data — a one-way function producing a fixed-size digest, where finding collisions is computationally infeasible.

CSMA/CA — listen before you transmit, and back off — Carrier Sense Multiple Access with Collision Avoidance, the Wi-Fi access method with random backoff.

CSRF — a site tricking your browser into using your login — cross-site request forgery, defeated by anti-forgery tokens and SameSite cookies.

CSS — the rules that decide how a page looks — Cascading Style Sheets: selectors and declarations applied by cascade, specificity and inheritance.

Culling — not drawing what nobody can see — discarding geometry outside the view frustum, facing away, or hidden behind other objects.

Current — the flow of electricity — the rate of charge flow, measured in amperes; one ampere is one coulomb per second.

Czochralski — the way a silicon crystal is grown — dipping a seed crystal into molten silicon and slowly pulling and rotating it to form a single-crystal boule.

D

DAC — turns numbers back into a real signal — digital-to-analogue converter, reconstructing a voltage from samples at a fixed rate.

Daemon — a program that runs quietly in the background — a long-lived process with no controlling terminal, usually started at boot.

Datagram — a message sent with no promises — a self-contained packet delivered without connection setup, ordering or retransmission.

dBm — signal strength on a logarithmic scale — power relative to one milliwatt; -50 dBm is strong Wi-Fi and -85 dBm is marginal.

DDR — memory that moves data on both clock edges — double data rate SDRAM; DDR5, standardized 2020, starts at 4800 MT/s.

Dead code — code that can never run — instructions unreachable on any path, normally removed by the compiler.

Deadlock — two tasks each waiting for the other — a cycle of hold-and-wait dependencies where no participant can proceed.

Debouncing — ignoring a switch’s noisy chatter — filtering multiple contact transitions into one clean event, typically over 5 to 50 ms.

Decibel — a way to write huge ratios in small numbers — ten times the base-10 logarithm of a power ratio; 3 dB is roughly double.

Decode (AI) — writing the answer one token at a time — the autoregressive generation phase, one token per forward pass, memory-bandwidth bound.

Decoder-only — the transformer shape used by chat models — a stack of masked self-attention blocks with no separate encoder.

Deep learning — networks with many stacked layers — machine learning using multi-layer neural networks trained by gradient descent.

Default route — where to send anything you have no rule for — the 0.0.0.0/0 entry, or ::/0 for IPv6, in a routing table.

Defragmentation — putting a file’s pieces back together — rearranging blocks so files occupy contiguous space, useful on disks and pointless on SSDs.

Delta compression — storing only what changed — encoding an object as a difference against a similar one, as git does inside packfiles.

Demand paging — loading pages only when touched — bringing a page into memory on its first access, signalled by a page fault.

Dependency — something your code needs to work — an external library, service or tool required to build or run software.

Dependency injection — passing in what a thing needs — supplying collaborators from outside rather than constructing them internally.

Detached HEAD — you are on a commit, not on a branch — HEAD holding a commit hash directly, so new commits belong to no branch.

Deterministic lockstep — every machine simulates the same thing — sending only inputs and relying on identical simulation on all clients.

DHCP — the network hands you an address automatically — Dynamic Host Configuration Protocol, RFC 2131, using the DORA exchange to lease settings.

Die — one chip cut from a wafer — a single rectangle of processed silicon containing a complete circuit.

Dielectric — the insulating filling in a capacitor — a non-conducting material that polarizes in a field and raises capacitance.

Diffie-Hellman — agreeing a secret over an open line — key exchange where each side combines its private value with the other’s public value.

Diode — a one-way valve for electricity — a PN junction conducting when forward biased above about 0.7 V in silicon.

Directory — a folder holding names — a filesystem object mapping names to inode numbers or file records.

Dirty bit — a mark saying this copy changed — a flag showing a page or cache line differs from the backing store and must be written back.

Disk image — a file holding a whole drive’s contents — a byte-for-byte copy of a block device, including partition table and filesystems.

Distributed system — several machines pretending to be one — a system whose components run on networked machines and coordinate by message passing.

Distro — one packaged version of Linux — a distribution bundling a kernel, libraries, package manager and defaults, such as Debian or Fedora.

DMA — devices moving data without bothering the CPU — direct memory access, where a controller transfers to or from memory and interrupts on completion.

DNS — the phone book turning names into addresses — a distributed hierarchical database of resource records, RFC 1034 and 1035.

DNS resolver — the helper that does the lookups for you — a recursive server that queries root, TLD and authoritative servers and caches results.

Docker — the tool that made containers easy — a container engine with an image format, build file and registry workflow, released 2013.

Docker image — a frozen filesystem plus start instructions — a layered, content-addressed bundle of filesystem layers and configuration metadata.

DOM — the page as a tree the code can change — Document Object Model, the browser’s live object tree built from parsed HTML.

Doping — adding impurities to make silicon useful — introducing donors such as phosphorus or acceptors such as boron to make n-type or p-type material.

DPI — dots per inch on paper — printer resolution; PPI is the screen equivalent, pixels per inch.

DPO — training from preferences without a reward model — direct preference optimization, fitting the policy directly to pairs of preferred and rejected answers.

DRAM — the main memory that needs constant refreshing — dynamic RAM storing a bit as charge on a capacitor, refreshed roughly every 32 or 64 ms.

Draw call — one order sent to the graphics card — a command to render a batch of geometry with one state and shader set.

Driver — the code that speaks a device’s language — kernel or user-space software translating generic requests into device-specific commands.

DROP — silently binning a packet — a firewall action discarding a packet with no reply, so the sender only sees a timeout.

Duplex — whether both ends can talk at once — full duplex allows simultaneous send and receive; half duplex allows only one direction at a time.

Dynamic linking — libraries joined at start-up, not build time — resolving symbols at load or first use, sharing one library copy across processes.

E

eBPF — running safe little programs inside the kernel — an in-kernel virtual machine with a verifier, used for tracing, networking and security.

ECC (memory) — memory that corrects its own small errors — error-correcting code memory, typically SECDED, fixing single-bit and detecting double-bit errors.

ECC (crypto) — strong keys that are short — elliptic curve cryptography; a 256-bit curve key is roughly as strong as a 3072-bit RSA key.

ECMP — spreading traffic over several equally good paths — equal-cost multipath, hashing a flow’s five-tuple to pick one of several next hops.

Edge case — the odd input that breaks things — a condition at the boundary of valid input, often untested.

Edge computing — doing work near the user instead of far away — running compute at points of presence close to clients to cut latency.

Elasticity — capacity that grows and shrinks with demand — automatic scaling of resources in response to load, with matching cost changes.

ELF — the executable format on Linux — Executable and Linkable Format, with a header, program headers for loading and section headers for linking.

Embedding — a meaning turned into a list of numbers — a learned dense vector whose geometry places related items close together.

Emulation — one machine pretending to be another — software reproducing another system’s instruction set and devices closely enough to run its software.

Encapsulation (networks) — wrapping one message inside another — placing a higher-layer unit into a lower-layer payload with its own header.

Encoder — the half that reads rather than writes — a transformer stack producing representations of an input without generating tokens.

Endianness — which end of a number comes first — byte order in memory; little-endian stores the least significant byte at the lowest address.

Endpoint — one address a service answers on — a specific URL and method combination, or a network address plus port.

Entropy — how surprising the data is — the average information per symbol in bits, the floor for lossless compression.

Environment variable — a setting passed to a program at start — a name-value pair inherited through the process environment, such as PATH or HOME.

Ephemeral port — the temporary port your side uses — a short-lived source port, usually from 32768 to 60999 on Linux, chosen per connection.

Epoch (training) — one full pass through the data — one complete presentation of the training set to the learner.

Epoch (time) — the moment counting starts — the Unix epoch, 00:00:00 UTC on 1 January 1970, the zero point for time_t.

Error budget — the amount of failure you are allowed — the difference between 100 percent and an SLO, spendable on risky changes.

Etching — cutting the pattern into the wafer — removing material chemically or with plasma where photoresist does not protect it.

Ethernet — the wired local network everyone uses — IEEE 802.3 framing and access rules, from 10 Mbit/s in 1983 to 800 Gbit/s today.

EUV — the light used to print the smallest features — extreme ultraviolet lithography at 13.5 nm wavelength, in production since 2019.

Eventual consistency — everyone agrees, given a moment — a model where replicas converge if updates stop, without guaranteeing immediate agreement.

Exception — an error that jumps out of normal flow — a signalled condition transferring control to a handler and unwinding the stack.

Exit code — the number a program leaves behind — a process’s status, 0 for success by convention and 1 to 255 for failure.

Exponent — the part of a float that sets the scale — the biased power-of-two field in IEEE 754, 8 bits in binary32 and 11 in binary64.

Extension — the bit after the dot in a filename — a naming convention, not a guarantee; the real type comes from content or magic numbers.

F

Fan-out — how many things one thing drives — the number of inputs a single output feeds, limiting speed in logic and load in messaging.

Fast-forward — the branch just slides forward — a merge where the target is an ancestor of the source, so the ref simply moves, creating no commit.

Fault tolerance — carrying on despite broken parts — designing so component failure degrades service instead of stopping it.

Feature flag — a switch that turns a feature on or off — configuration allowing behaviour to change at runtime without redeploying.

Fetch (git) — download new objects but change nothing — updating remote-tracking refs and objects without touching your branches or working tree.

FIFO — first in, first out — a queue discipline, or a named pipe file created with mkfifo.

File descriptor — the small number a program uses to name an open file — a per-process index into the kernel’s open file table; 0, 1 and 2 are stdin, stdout, stderr.

File handle — the object behind an open file — the kernel structure holding the file’s position, mode and reference count.

Filesystem — the way files are laid out on a device — the on-disk structures and rules holding names, metadata and data blocks, such as ext4, APFS or NTFS.

Fine-tuning — extra training on your own examples — continued training of a pretrained model on a smaller task-specific dataset.

FinFET — a transistor with a fin sticking up — a 3D transistor whose gate wraps a thin silicon fin, in production from 2011 to about the 3 nm class.

Firewall — a guard deciding which packets may pass — a device or kernel subsystem filtering traffic by rules over addresses, ports, state and content.

Firmware — software living in the device itself — code stored in non-volatile memory on a device, run before or beneath the operating system.

Firmware update — replacing the software inside a device — writing new code to a device’s flash, usually with A/B slots and a signature check.

Fixed timestep — the game’s physics ticks at one steady rate — advancing simulation in constant increments regardless of frame time, with interpolation for display.

Flash memory — storage that keeps data with no power — floating-gate or charge-trap cells holding charge, erased in blocks and written in pages.

Flip-flop — a circuit that remembers one bit — an edge-triggered storage element capturing its input at a clock edge.

Floating point — a number with a moving decimal point — a sign, exponent and fraction encoding under IEEE 754, trading precision for range.

Flow control — stopping a fast sender flooding a slow receiver — TCP’s advertised receive window, or the equivalent at other layers.

Flush — pushing buffered data out now — forcing pending writes from a buffer to the next level, such as fsync to storage.

Fork (process) — making a copy of the running program — the Unix call creating a child process with a copied address space, usually copy-on-write.

Fork (repository) — your own copy of someone’s project — a server-side clone under your account, with its own refs and pull-request relationship.

Forward proxy — a middleman your client chooses — a server making requests on a client’s behalf, often for policy or caching.

Forward secrecy — yesterday’s traffic stays safe if today’s key leaks — using ephemeral key exchange so long-term key compromise cannot decrypt past sessions.

Fragment (IP) — a packet cut up to fit — an IP packet split to fit a link’s MTU, reassembled at the destination.

Frame (network) — the layer 2 envelope — the Ethernet or Wi-Fi unit with MAC addresses, payload and a frame check sequence.

Frame (graphics) — one complete picture — one full rendered image; at 60 Hz the frame budget is 16.67 ms.

Frame budget — the time you have for one picture — the per-frame time allowance, 16.67 ms at 60 Hz and 6.94 ms at 144 Hz.

Frame rate — pictures per second — displayed frames per second; smoothness also depends on frame time consistency, not the average alone.

Framebuffer — the memory holding the picture to be shown — a region of memory holding pixel values scanned out to a display.

Free software — software you may run, study, change and share — software distributed with the four freedoms, usually under a copyleft licence such as the GPL.

Frequency — how many cycles per second — cycles per second in hertz; a 4 GHz clock has a period of 250 picoseconds.

FTL — the SSD’s private map of where data really is — flash translation layer, mapping logical block addresses to physical pages and handling wear and garbage collection.

Full-duplex — talking and listening at the same time — simultaneous bidirectional transmission on separate paths or with echo cancellation.

Function call — jumping into a named block and coming back — transferring control with arguments and a return address, following the ABI’s calling convention.

Fuzzing — throwing random rubbish at a program to break it — automated testing with mutated or generated inputs, watching for crashes and assertion failures.

G

Game loop — read input, update, draw, repeat — the cycle sampling input, advancing simulation and rendering, once per frame.

Gamma — the curve between number and brightness — a nonlinear transfer function matching encoding to perception, roughly 2.2 for sRGB.

Garbage collection — memory tidied up automatically — a runtime reclaiming unreachable objects, by tracing or reference counting.

Gate (logic) — a tiny circuit applying one logical rule — a circuit implementing AND, OR, NOT, NAND, NOR or XOR over binary inputs.

Gate (transistor) — the leg that switches the flow — the control terminal whose voltage forms or removes the channel between source and drain.

Gateway — the way out of your local network — the router a host sends to when the destination is not on its own subnet.

GATT — how Bluetooth devices expose small values — Generic Attribute Profile, a hierarchy of services, characteristics and descriptors addressed by handle.

GDDR — memory built for graphics cards — graphics DDR SDRAM tuned for very high bandwidth with wide buses and high clock rates.

Gigabit — a thousand million bits — 10^9 bits; note that 1 Gbit/s is 125 MB/s before protocol overhead.

GIL — only one thread runs Python bytecode at a time — CPython’s global interpreter lock, serializing bytecode execution across threads.

Git — the version control system almost everyone uses — a content-addressed distributed VCS created by Linus Torvalds in April 2005.

Golden image — the trusted base copy you build from — a validated machine or container image used as the starting point for deployments.

Goodput — the useful data rate, not the raw one — application-level throughput after headers, retransmissions and protocol overhead.

Goroutine — a very cheap thread in Go — a lightweight task multiplexed onto OS threads by the Go runtime scheduler.

GPIO — a pin you can set high or low yourself — general-purpose input/output, a configurable digital pin on a microcontroller or board.

GPT (partition) — the modern partition table — GUID Partition Table, part of UEFI, supporting large disks and 128 partitions by default.

GPT (model) — a generative pretrained transformer — a decoder-only transformer trained to predict the next token.

GPU — the chip built for many small sums at once — a processor with thousands of simple lanes, built for throughput on parallel work.

Graceful degradation — losing features instead of falling over — designing so partial failure reduces function rather than causing an outage.

Gradient clipping — stopping an update from being too big — rescaling gradients whose norm exceeds a threshold, to keep training stable.

Gradient descent — walking downhill on the error — updating parameters against the gradient of the loss, scaled by the learning rate.

GraphQL — the client asks for exactly the fields it wants — a query language and runtime with one endpoint, a typed schema and client-shaped responses.

Ground — the reference point voltages are measured from — the common return path defined as zero volts in a circuit.

gRPC — fast structured calls between services — a remote procedure call framework using Protocol Buffers over HTTP/2, with streaming support.

Guard clause — checking the bad case first and leaving — an early return that removes nesting from the main path.

GUI — pointing at pictures instead of typing commands — a graphical user interface with windows, icons, menus and a pointer.

H

Hallucination — a model stating something untrue with confidence — fluent output not grounded in training data or provided context.

Handover — your phone moving to the next mast without dropping — transferring an active connection between cells while keeping the session alive.

Handshake — the greeting that sets up a connection — the exchange establishing parameters, such as TCP’s SYN, SYN-ACK, ACK.

Hard link — two names for the same file — a second directory entry pointing at the same inode, with a shared link count.

Hash table — a lookup that is fast because it computes where to look — a map using a hash of the key to index buckets, average O(1) lookup.

HBM — memory stacked right next to the processor — high bandwidth memory, stacked DRAM dies on an interposer, giving terabytes per second.

HDD — a drive with spinning magnetic platters — a hard disk with rotating platters and moving heads, giving milliseconds of seek latency.

HDR — brighter brights and darker darks — high dynamic range imaging with wider luminance range, usually with a PQ or HLG transfer function.

HEAD — where you are in the repository right now — a ref pointing to the current branch, or directly to a commit when detached.

Header — the label on the front of a message — the fixed or structured prefix carrying addressing and control information before the payload.

Heap — memory you ask for and give back yourself — the region for dynamic allocation, managed by the allocator rather than by scope.

Heat sink — metal that carries heat away — a finned metal block spreading and radiating heat from a package to moving air or liquid.

Hertz — cycles per second — the SI unit of frequency, one cycle per second.

Hexadecimal — counting in sixteens — base-16 notation using 0 to 9 and A to F, where one digit encodes exactly four bits.

Hit rate — how often the cache had it — the fraction of requests served from cache, the main determinant of average latency.

Hop — one router along the way — a single forwarding step; traceroute reveals hops by increasing the TTL.

Hotfix — an urgent small change — a minimal patch shipped outside the normal release cycle to fix a live problem.

HTML — the markup that says what parts a page has — HyperText Markup Language, a tree of elements the browser parses into the DOM.

HTTP — the rules browsers and servers use to talk — a request-response protocol with methods, status codes and headers, now RFC 9110.

HTTPS — HTTP inside an encrypted tunnel — HTTP carried over TLS, normally on port 443, giving confidentiality, integrity and server authentication.

Huffman coding — short codes for common symbols — an optimal prefix-free code built from symbol frequencies, used inside DEFLATE and JPEG.

Hyperparameter — a setting you choose before training — a value not learned by gradient descent, such as learning rate, batch size or layer count.

Hyper-threading — one core pretending to be two — simultaneous multithreading, running two instruction streams over one core’s execution resources.

Hypervisor — software that runs whole machines inside one machine — a layer creating and scheduling virtual machines, type 1 on bare metal or type 2 on a host OS.

I

IaaS — renting raw machines and networks — infrastructure as a service, where you manage the OS and everything above it.

IAM — who is allowed to do what — identity and access management: principals, policies, roles and permission evaluation.

ICMP — the network’s error and echo messages — the control protocol carrying unreachable, time exceeded and echo, RFC 792.

Idempotent — doing it twice changes nothing more — an operation whose repeated application has the same effect as one application.

Idle — doing nothing on purpose — a scheduler state with no runnable task, usually entering a low-power CPU state.

IEEE 754 — the rule that makes floating point the same everywhere — the 1985 standard defining binary32, binary64, rounding modes, infinities and NaN.

Image (container) — a frozen filesystem plus start-up settings — a layered, content-addressed bundle of layers and configuration.

IMEI — the serial number identifying a phone itself — a 15-digit equipment identity, distinct from the SIM’s subscriber identity.

Immutable — it cannot be changed after it is made — a value or object whose state is fixed at creation, simplifying sharing and caching.

Impedance — how much a component resists an alternating signal — the complex ratio of voltage to current; speakers are commonly 4 or 8 ohms.

Index (git) — the staging area between edits and a commit — a binary file listing paths, modes and blob hashes for the next commit.

Inductor — a coil that resists sudden changes in current — a component storing energy in a magnetic field, with voltage proportional to di/dt.

Inference — using a trained model to get an answer — the forward pass only, with no gradients and no parameter updates.

Infrastructure as code — servers described in files, not clicked into existence — declarative resource definitions kept in version control and applied by a tool.

init — the first process the kernel starts — PID 1, which starts services and adopts orphaned processes.

Inode — the record holding a file’s facts — a filesystem structure with mode, owner, times, size and block pointers, but not the name.

Instruction pipeline — several instructions in progress at once — overlapping fetch, decode, execute and write-back stages to raise throughput.

Instruction set — the list of operations a CPU understands — the ISA: opcodes, registers, addressing modes and the binary encoding.

Instruction tuning — teaching a model to follow requests — supervised fine-tuning on instruction-and-response pairs.

Integer overflow — a number too big for its box — a result exceeding the type’s range, wrapping in unsigned types and undefined for signed C.

Integration test — checking that the parts work together — a test exercising several components and their real interfaces.

Interface (network) — one connection point on a machine — a NIC or virtual device with its own MAC address, addresses and statistics.

Intermediate representation — the compiler’s private middle language — an IR such as LLVM IR, easier to optimize than source or machine code.

Interpreter — runs source code directly, line by line — a program executing a source or bytecode representation without producing a native binary.

Interrupt — a device tapping the CPU on the shoulder — an asynchronous signal causing the CPU to jump to a handler and return.

Interrupt latency — how long before the handler starts — the delay from signal assertion to the first handler instruction.

IOMMU — an address translator for devices — hardware mapping and restricting device DMA addresses, essential for safe passthrough.

IP address — the number that identifies a machine on a network — a 32-bit IPv4 or 128-bit IPv6 address, assigned to an interface, not a device.

IPC (CPU) — instructions finished per clock tick — instructions per cycle, the other half of performance beside frequency.

IPC (software) — how two programs talk — inter-process communication by pipes, sockets, shared memory or message queues.

IPv4 — the old 32-bit address scheme — RFC 791 addressing, about 4.3 billion addresses, exhausted at IANA in 2011.

IPv6 — the 128-bit replacement — RFC 8200 addressing with 2^128 addresses, no header checksum and no router fragmentation.

IXP — a building where networks meet and swap traffic — an internet exchange point with a shared switch fabric for peering.

J

JavaScript — the language that runs inside web pages — a dynamically typed, event-driven language standardized as ECMAScript.

JIT — compiling while the program runs — just-in-time compilation of hot paths to native code, guided by runtime profiles.

Jitter — how much the delay wobbles — variation in packet delay, more damaging than average latency for voice and games.

Job (CI) — one unit of work in a pipeline — a set of steps run on one runner, with its own environment and result.

Job control — putting a command in the background — shell management of process groups with foreground, background and stopped states.

Journaling — writing down the plan before doing it — a filesystem log of intended metadata changes, replayed after a crash.

JSON — a simple text format for structured data — JavaScript Object Notation: objects, arrays, strings, numbers, booleans and null.

JWT — a signed token you can read yourself — JSON Web Token, RFC 7519, a base64url header, payload and signature joined by dots.

K

Kernel (OS) — the part of the system with full power over the machine — the code running in privileged mode, owning scheduling, memory and devices.

Kernel (maths) — the small window slid over data — a filter matrix applied by convolution across an image or signal.

Kernel mode — the privileged half of the processor — the state allowing all instructions and address ranges, entered by trap or interrupt.

Kernel panic — the system giving up — an unrecoverable kernel error that halts the machine rather than risk corruption.

Key (attention) — what each token offers to be matched against — a projected vector compared with queries to produce attention weights.

Key derivation — turning a password into a proper key — a KDF such as PBKDF2, scrypt or Argon2 stretching a secret into key material.

Key exchange — agreeing a secret without posting it — a protocol such as Diffie-Hellman letting both sides derive a shared key.

Keyframe — a video frame that stands alone — an intra-coded frame decodable without reference to others, the seek point in a stream.

Kill — telling a process to stop — sending a signal such as SIGTERM to request exit or SIGKILL to force it.

Kilobyte — a thousand bytes — 1000 bytes in SI usage; 1024 bytes is a kibibyte, KiB.

Knowledge cutoff — the date a model’s reading stops — the point beyond which pretraining data was not collected.

Kubernetes — the system that keeps containers running — a container orchestrator with a declarative API and reconciling controllers.

KV cache — remembering earlier keys and values so they are not redone — stored per-layer key and value tensors for tokens already processed.

L

Lag compensation — the server rewinding time to judge your shot — re-evaluating a hit against the world state the shooter actually saw.

Latch — a memory circuit that follows while enabled — a level-sensitive storage element, unlike an edge-triggered flip-flop.

Latency — the waiting time before something starts — the delay between cause and effect, measured end to end and reported as percentiles.

LBA — numbering blocks straight through — logical block addressing, a linear block number replacing cylinder, head and sector.

LCD — a screen where a backlight shines through gates — liquid crystal display, twisting crystals to control light per subpixel.

Learning rate — how big a step training takes — the scale factor on the gradient, the most sensitive hyperparameter.

Least privilege — give only the rights actually needed — restricting each principal to the minimum permissions for its task.

Lexer — the part that cuts source code into words — the tokenizer producing a stream of tokens from characters.

LFS — keeping big files out of git’s history — Large File Storage, replacing large files with pointers and storing content separately.

Library — reusable code you call — a packaged collection of functions linked statically or loaded dynamically.

Linked list — items each pointing at the next — a sequence of nodes with pointers, cheap to insert and slow to index.

Linker — joins compiled pieces into one program — the tool resolving symbols, laying out sections and producing an executable or shared object.

Little-endian — the smallest byte first — byte order storing the least significant byte at the lowest address, as x86 and ARM do.

Load balancer — spreading requests across servers — a device or service distributing connections by round robin, least connections or hashing.

Loader — the code that puts a program into memory — the kernel or dynamic loader mapping segments, resolving symbols and jumping to the entry point.

localhost — the name a machine uses for itself — the hostname resolving to 127.0.0.1 and ::1, never leaving the machine.

Locality — recently or nearby data is likely used again — temporal and spatial locality, the reason caches work.

Lock — one at a time, please — a synchronization primitive giving exclusive access to shared state.

LOD — simpler models for distant objects — level of detail, swapping meshes or textures by screen size to save work.

Log — the running record of what happened — an append-only stream of events used for debugging, audit and recovery.

Logic gate — a tiny circuit applying one rule — a combinational circuit implementing a Boolean function of its inputs.

Logit — the raw score before it becomes a probability — the unnormalized output per vocabulary entry, fed to softmax.

Loopback — the machine talking to itself — the virtual interface for 127.0.0.0/8 and ::1, never leaving the host.

LoRA — training a small add-on instead of the whole model — low-rank adaptation, learning two small matrices whose product updates a frozen weight.

Loss function — the score that says how wrong the model is — the objective minimized in training, typically cross-entropy for language models.

Lossless — nothing is thrown away — compression from which the exact original bytes can be restored, as in FLAC, PNG and gzip.

Lossy — some detail is thrown away for size — compression discarding information judged imperceptible, as in JPEG, MP3 and H.264.

LRU — throw out what was used longest ago — least recently used, a common cache replacement policy.

LTE — the fourth generation mobile standard — 3GPP Long Term Evolution, an all-IP radio network using OFDMA downlink.

M

MAC (crypto) — a tag proving a message was not altered — message authentication code, such as HMAC, computed with a shared secret key.

MAC address — the hardware name of a network port — a 48-bit link-layer address, the first 24 bits identifying the manufacturer.

Mach-O — the executable format on macOS — Apple’s binary format, with load commands and support for fat binaries holding several architectures.

Magic number — the few bytes at the start that say what a file is — a fixed signature such as 0x7F ELF or PK for zip, used by the file command.

Malloc — asking for memory while running — the C library call returning a pointer to an uninitialized block of the requested size.

MBR — the old partition table in the first sector — master boot record, four primary partitions and a 2 TiB limit.

Memory leak — memory taken and never given back — allocated memory that stays reachable but unused, growing the process footprint.

Merge — joining two lines of work — a commit with two or more parents, combining changes since the merge base.

Merge base — the last commit both branches share — the best common ancestor used as the reference point in a three-way merge.

Merge queue — testing changes in the order they will land — a forge feature building each pull request against the real future main branch.

mergeStateStatus — a forge’s summary of whether a merge is possible — GitHub’s field with values such as CLEAN, BLOCKED, BEHIND, DIRTY or UNKNOWN.

MESI — the four states a cache line can be in — modified, exclusive, shared, invalid: the coherence protocol keeping cores consistent.

Metadata — data about the data — attributes such as size, times, type and permissions, held separately from content.

Microkernel — a tiny kernel with drivers outside it — a design keeping only scheduling, memory and IPC privileged, with services in user space.

Microservice — a small service that does one job — an independently deployable service with its own data and interface.

Middleware — code sitting between request and handler — a chain of components processing requests before or after the application.

Migration (data) — changing the shape of stored data — a versioned script altering schema or contents, applied in order and recorded.

MIMO — several antennas sending several streams — multiple input multiple output, using spatial paths to multiply capacity.

Mipmap — smaller pre-made copies of a texture — a chain of half-size texture levels selected by screen footprint to avoid shimmering.

Mixture of experts — only part of the model runs per token — a layer routing each token to a few expert subnetworks, so active parameters are fewer than total.

MMU — the hardware that translates addresses — memory management unit, walking page tables to map virtual to physical addresses.

Mode (file) — the permission bits on a file — the 12-bit field holding owner, group and other permissions plus setuid, setgid and sticky.

Model card — the label describing what a model is and is not — a document stating intended use, training data summary, evaluations and limitations.

Modulation — changing a wave so it carries data — varying amplitude, frequency or phase to encode symbols on a carrier.

Monolithic kernel — one big kernel with drivers inside — a design running services and drivers in kernel mode, as Linux does.

Monorepo — everything in one repository — a single repository holding many projects, with shared tooling and atomic cross-project changes.

Moore’s law — transistors per chip keep doubling — Gordon Moore’s 1965 observation, revised in 1975 to a doubling roughly every two years.

MOSFET — the switch nearly all chips are made from — metal-oxide-semiconductor field-effect transistor, whose gate voltage forms a channel.

Mount — attaching a filesystem into the tree — making a device or remote share visible at a directory path.

Mount point — the directory where a filesystem appears — the path at which a filesystem’s root is grafted into the namespace.

MTU — the biggest packet a link will carry — maximum transmission unit, 1500 bytes on standard Ethernet.

Multicast — one send, many listeners — delivery to a group address, where the network duplicates packets only where paths diverge.

Multi-head attention — several attention views at once — running attention in parallel subspaces and concatenating the results.

Multiplexing — many conversations over one link — interleaving several logical streams on one physical or transport channel.

Mutation testing — checking that tests would notice a bug — deliberately altering code to see whether the test suite fails.

Mutex — a lock only one holder may take — mutual exclusion primitive with owner tracking, blocking other threads until released.

N

Namespace (Linux) — a private view of a system resource — a kernel feature isolating mounts, PIDs, network stacks, users or hostnames per process group.

NaN — the float that means “not a number” — an IEEE 754 value produced by invalid operations, unequal even to itself.

NAND flash — the storage in phones and SSDs — non-volatile memory of series-connected cells, written per page and erased per block.

NAT — many private machines behind one public address — network address translation, rewriting addresses and ports and tracking the mapping.

Netcode — the part of a game that handles the network — the synchronization design: tick rate, prediction, interpolation and reconciliation.

Netmask — which part of an address is the network — a bit mask marking the prefix, written as 255.255.255.0 or as /24.

Network interface — the port a machine uses to reach a network — a physical or virtual device with a MAC address and its own addresses.

Neural network — layers of weighted sums with bends between them — a differentiable function of stacked linear maps and nonlinearities, fitted by gradient descent.

Next hop — the router to hand this packet to — the neighbouring address a routing table entry sends matching traffic to.

Nginx — a common web server and reverse proxy — an event-driven server handling many connections with few processes.

Nibble — half a byte — four bits, exactly one hexadecimal digit.

NIC — the network card — network interface controller, handling framing, checksums and often offloads.

Node (compute) — one machine in a cluster — a host contributing CPU, memory and storage, managed by the cluster’s scheduler.

Node (process) — the transistor generation name — a marketing label such as 5 nm or 3 nm, no longer matching any physical dimension.

Nonce — a number used exactly once — a value ensuring freshness or uniqueness, never repeated under one key.

Non-volatile — it remembers with the power off — storage retaining state without power, unlike DRAM and SRAM.

Normalization (AI) — keeping numbers in a sensible range — layer or RMS normalization rescaling activations to stabilize training.

Notification (interrupt) — see interrupt — an asynchronous event delivered to software rather than polled for.

NTP — how machines agree what time it is — Network Time Protocol, disciplining clocks to within milliseconds over the internet.

Null pointer — a pointer deliberately pointing at nothing — the reserved address zero, whose dereference traps on most systems.

NUMA — memory that is closer to some cores than others — non-uniform memory access, where latency depends on which node owns the memory.

NVMe — the protocol built for flash, not for disks — a command set over PCIe with deep parallel queues and very low overhead.

NVRAM — small memory that survives a reboot — non-volatile RAM used for firmware settings and boot variables.

Nyquist — sample at least twice the highest frequency — the sampling theorem requiring a rate above twice the signal bandwidth to avoid aliasing.

O

OAuth — letting an app act for you without your password — a delegation framework issuing scoped access tokens, RFC 6749.

Object file — compiled code not yet joined up — a relocatable binary with sections, symbols and relocation entries.

Observability — being able to tell what a system is doing — the ability to answer new questions from existing logs, metrics and traces.

OFDM — splitting a channel into many narrow lanes — orthogonal frequency division multiplexing, used by Wi-Fi, LTE, 5G and DSL.

Ohm’s law — push equals flow times resistance — V = IR, relating voltage, current and resistance in a linear element.

OLED — a screen where each dot makes its own light — organic light-emitting diode panels with no backlight, giving true black.

Opcode — the number that says which operation — the field of an instruction encoding selecting the operation to perform.

Opcode fusion — merging two instructions into one operation — a CPU front-end optimization combining common instruction pairs.

Open weights — the trained numbers are published — a model whose parameters are downloadable, which is not the same as open training data.

Orchestration — deciding what runs where — automated placement, scaling and recovery of workloads across a cluster.

Origin — the default name for where you cloned from — the conventional remote name git creates for the source repository.

Origin server — the machine holding the real content — the source a CDN fetches from when it has no valid cached copy.

Orphan (git) — an object nothing points to — an unreachable object, removable by garbage collection after its grace period.

Oscillator — the circuit that makes the ticking — a crystal or ring circuit producing a periodic reference signal.

OSI model — seven named layers for teaching — ISO 7498, from physical up to application, useful as vocabulary, not as an implementation.

Out-of-order — doing ready work first, then tidying up — executing instructions as operands become available, retiring them in program order.

Overclocking — running a chip faster than rated — raising frequency and often voltage beyond specification, at the cost of heat and stability.

Overfitting — memorizing the answers instead of learning — fitting noise in training data, shown by training loss falling while validation loss rises.

Overlay network — a network built on top of another — virtual links tunnelled over an existing network, as with VXLAN or WireGuard.

Overprovisioning — spare flash the drive keeps hidden — reserved capacity that improves garbage collection and endurance.

P

PaaS — you bring the code, they run everything else — platform as a service, managing runtime, scaling and patching for you.

Packaging (chips) — putting the die in something you can solder — attaching a die to a substrate with bumps or wires and encapsulating it.

Packet — one labelled chunk of data — a network-layer unit of header plus payload, routed independently.

Packet loss — a packet that never arrives — discard caused by congestion, errors or policy, inferred from missing acknowledgements.

Packfile — many git objects compressed into one file — a container storing objects with delta compression, plus an index for lookup.

Page — the unit memory is managed in — a fixed-size block of virtual memory, usually 4 KiB, mapped to a physical frame.

Page fault — the page was not in memory — a trap when a virtual page has no valid mapping, handled by loading or allocating.

Page table — the map from virtual to physical pages — a multi-level structure walked by the MMU, cached in the TLB.

Parameter (AI) — one learned number in the model — a single weight or bias updated by training and stored in the model file.

Parity — one extra bit to spot an odd error — a bit making the count of ones even or odd, detecting single-bit errors.

Parser — the part that works out the structure — the component turning tokens into a syntax tree by grammar rules.

Partition — one labelled region of a drive — a contiguous block range described by an MBR or GPT entry.

Pass@k — did any of k attempts pass — a benchmark metric giving credit if at least one of k samples is correct.

Passphrase — a long password made of words — a secret chosen for entropy through length rather than symbol variety.

Patch — a file describing a change — a unified diff with context lines, applicable to matching source.

PATH — the list of folders the shell searches — an environment variable of directories scanned in order for a command name.

Payload — the actual content, minus the wrapping — the data a protocol carries, excluding headers and trailers.

PCIe — the fast lanes connecting chips inside a computer — PCI Express, point-to-point serial lanes; gen 5 runs 32 GT/s per lane.

PCM — sound stored as plain numbers — pulse-code modulation, uncompressed samples at a fixed rate and bit depth.

PE — the executable format on Windows — Portable Executable, with a DOS stub, COFF header and sections such as .text and .rdata.

Peering — two networks exchanging traffic directly — a bilateral agreement to swap customer routes, often settlement-free.

Permission — what you are allowed to do to a file — access bits or ACL entries checked by the kernel on open.

Persistent storage — data that outlives the process — storage surviving restarts, unlike memory or a container’s writable layer.

Phase — where a wave is in its cycle — angular offset in degrees or radians, the basis of phase-shift keying.

Photolithography — printing the circuit pattern with light — projecting a mask image onto photoresist to define features on a wafer.

Photoresist — the light-sensitive coating on a wafer — a polymer whose solubility changes on exposure, defining where etching happens.

Piconet — a small group of Bluetooth devices working together — one primary device and up to seven active secondaries sharing a hopping pattern.

Ping — asking a host whether it is there — sending ICMP echo requests and timing the replies.

Pipe — the output of one command becoming the input of the next — a kernel buffer joining one process’s stdout to another’s stdin.

Pipeline (CPU) — instructions in a production line — overlapping instruction stages so one finishes per cycle in the ideal case.

Pixel — one dot of the picture — the smallest addressable element of a raster image or display.

Plist — the settings file format on Apple systems — a property list, in XML or binary form, holding key-value configuration.

PN junction — where p-type meets n-type silicon — the boundary forming a depletion region and conducting in only one direction.

Pod — the smallest deployable unit in Kubernetes — one or more containers sharing a network namespace, address and storage volumes.

Pointer — a value that holds an address — a variable containing the memory address of another object.

Polling — asking repeatedly instead of being told — checking a status in a loop rather than waiting for an interrupt or event.

Port — the number identifying which program on a machine — a 16-bit endpoint identifier in TCP and UDP headers.

Positional encoding — telling the model where each word sits — added or rotated information giving order to otherwise position-blind attention.

POSIX — the portable Unix rulebook — IEEE 1003 standards defining system calls, shell and utilities.

PPI — how tightly packed the dots are — pixels per inch of a display, about 460 on current high-end phones.

Precision — how finely a number can be written — the count of significant bits or digits a format can represent.

Prefetch — fetching before it is asked for — hardware or software loading data into cache ahead of predicted use.

Prefill — reading the whole prompt in one go — the parallel forward pass over input tokens that fills the KV cache, compute bound.

Pretraining — the long first training on huge text — self-supervised next-token training that produces a base model.

Primary key — the column that identifies a row — a unique, non-null identifier for a table’s rows.

Privilege escalation — getting more power than you were given — an exploit raising a principal’s permissions beyond its intended level.

Process — one running program with its own memory — an address space, one or more threads, and a table of open file descriptors.

Profiling — measuring where the time actually goes — sampling or instrumenting a program to attribute cost to code paths.

Prompt injection — hidden text telling a model to misbehave — untrusted content in a model’s context that overrides intended instructions.

Propagation delay — the time a gate takes to change its output — the interval from input transition to a valid output, tens of picoseconds today.

Protocol — the agreed rules for a conversation — the message formats, ordering and state machine two parties follow.

Proxy — a middleman making requests for you — a server that terminates one connection and opens another on the client’s behalf.

PTY — a fake terminal for a program that expects one — pseudo-terminal, a master and slave pair providing terminal semantics without hardware.

Pull request — asking for your branch to be merged — a forge object linking a source branch, target branch, review and checks.

Push — sending your commits to a remote — uploading objects and asking the remote to update refs, refused if it is not a fast-forward.

PWM — a switch flicked fast to fake a level — pulse-width modulation, varying duty cycle to control average power.

Q

QAM — packing more bits into each radio symbol — quadrature amplitude modulation; 1024-QAM carries 10 bits per symbol.

Quantization — using coarser numbers to save space — reducing weight precision, for example FP16 to INT8 or 4-bit, with a small accuracy cost.

Query (attention) — what one token is looking for — a projected vector compared against every key to produce attention weights.

Queue — a line of waiting work — a FIFO structure decoupling producers from consumers.

QUIC — a fast transport built on UDP — RFC 9000, giving streams, encryption and connection migration without head-of-line blocking.

Quorum — enough members agreeing to decide — a majority of replicas required for a consistent read or write.

Quota — a cap on how much you may use — an enforced limit on storage, requests or resources per account or user.

R

Race condition — the answer depends on who gets there first — a bug where behaviour depends on the unsynchronized timing of concurrent access.

RAG — letting a model read documents before answering — retrieval-augmented generation, injecting retrieved passages into the prompt.

RAID — several drives acting as one, for speed or safety — striping, mirroring or parity across disks; RAID is not a backup.

RAM — the fast memory that forgets when power stops — volatile random-access memory holding running code and data.

Rebase — replaying your commits on a new base — creating new commits with the same changes but new parents and new hashes.

Refactoring — tidying code without changing behaviour — a behaviour-preserving transformation improving structure or clarity.

Reflog — git’s private diary of where refs pointed — a local log of ref updates, letting you recover from a bad reset.

Refresh rate — how often the screen redraws — display updates per second in hertz, commonly 60, 120 or 144.

Register — the CPU’s own handful of tiny stores — a named storage location inside the core, accessed in a fraction of a cycle.

Registry (containers) — the shop images are pulled from — a service storing and serving container images by name and digest.

Registry (Windows) — the central settings database — a hierarchical store of keys and values used by Windows and its applications.

Regularization — stopping the model memorizing — techniques such as weight decay, dropout or early stopping that limit overfitting.

REJECT — refusing a packet and saying so — a firewall action sending an ICMP unreachable or TCP RST, so the sender fails fast.

Remote — a named repository somewhere else — a stored URL plus fetch and push refspecs, such as origin.

Remote-tracking ref — your last known idea of a remote branch — a local ref under refs/remotes updated only by fetch or push.

Replication — keeping copies on more than one machine — maintaining synchronized data on several nodes for durability or read scaling.

Repository — the whole project with all its history — a directory containing the object database, refs and configuration.

Resistance — how much a material fights the flow — the ratio of voltage to current, in ohms, dissipating power as heat.

Resolution — how many dots the picture has — the pixel count of an image or display, such as 1920 by 1080.

Resolver — the helper that does DNS lookups for you — a recursive server querying the hierarchy and caching results by TTL.

REST — using plain HTTP methods on named resources — an architectural style with stateless requests and uniform verbs over URLs.

Reverse proxy — a middleman in front of the servers — a server accepting client requests and forwarding them to backends.

RFC 1918 — the address ranges reserved for private use — 10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16, never routed on the internet.

Ring buffer — a fixed queue that wraps around — a circular array with head and tail indices, overwriting or blocking when full.

RLHF — training a model on what people preferred — reinforcement learning from human feedback, optimizing against a learned reward model.

Root server — the servers at the top of DNS — the 13 named root identities serving the root zone, reached by anycast.

Rootkit — malware that hides itself in the system — code subverting the kernel or firmware to conceal its own presence.

RoPE — encoding position by rotating the vectors — rotary position embedding, applying a position-dependent rotation to queries and keys.

Round-trip time — how long there and back takes — the delay from sending to receiving the acknowledgement, driving TCP behaviour.

Router — the box that forwards between networks — a device choosing an outgoing interface by longest-prefix match on the destination.

Routing table — the list of where to send what — the forwarding entries of prefix, next hop, interface and metric.

RSA — an old public-key algorithm based on big numbers — a scheme whose security rests on the difficulty of factoring; keys are 2048 bits or larger.

RST — a rude end to a TCP connection — a reset flag telling the peer to abandon the connection immediately.

Runner — the machine that executes a CI job — an agent that claims jobs from a queue and reports results back.

S

SaaS — you just use the website — software as a service, run entirely by the provider with no infrastructure for you.

Salt — a random extra ingredient in a password hash — a unique per-password value stored alongside it, defeating precomputed tables.

Same-origin policy — one site cannot read another’s data — the browser rule isolating documents by scheme, host and port.

Sampling (AI) — choosing the next word from the odds — drawing from the model’s output distribution, shaped by temperature and top-p.

Sampling rate — how many measurements per second — samples per second; CD audio uses 44,100 Hz.

Sandbox — a restricted area a program cannot escape — an isolation mechanism limiting a process’s syscalls and resources.

SATA — the older cable standard for drives — Serial ATA, 6 Gbit/s in revision 3, with one command queue.

Scaling laws — bigger models and more data give predictable gains — empirical power-law relations between compute, data, parameters and loss.

Scheduler — decides which task runs next — the kernel component choosing runnable threads by policy and priority.

Scope (OAuth) — the exact list of things a token may do — a string set attached to a token limiting the operations it authorizes.

SDK — the tools you need to build for a platform — a software development kit of libraries, headers, tools and samples.

Sector — the smallest addressable piece of a disk — 512 bytes traditionally, 4096 bytes on Advanced Format drives.

Segment — TCP’s unit of data — the transport-layer unit with sequence numbers, flags and payload.

Semantic versioning — the version number tells you what changed — MAJOR.MINOR.PATCH, where a major bump means a breaking change.

Semaphore — a counter that limits how many may proceed — a synchronization primitive with wait and signal operations.

Semiconductor — a material between a conductor and an insulator — a solid such as silicon whose conductivity is controlled by doping, field or light.

Serialization — turning objects into bytes to send or store — encoding structures into a byte stream, reversed by deserialization.

Serverless — you write the function, not the server — a model where the platform runs code on demand and bills by invocation and duration.

Session — the memory of who you are between requests — server or token state associating requests with an authenticated user.

SHA-256 — a common cryptographic fingerprint — a hash producing a 256-bit digest, used in TLS, git and signing.

Shader — a small program the GPU runs per vertex or pixel — GPU code for stages such as vertex, fragment or compute.

Sharding — splitting data across several databases — partitioning by key so each shard holds a subset of the rows.

Shebang — the first line saying which interpreter to use — the two bytes #! plus a path, read by the kernel when running a script.

Shell — the program that reads your commands — a command interpreter handling expansion, redirection, pipelines and job control.

Signal (Unix) — a short message telling a process something happened — an asynchronous notification such as SIGINT, SIGTERM or SIGSEGV.

Signal-to-noise ratio — how loud the message is compared with the hiss — the power ratio of signal to noise, usually in decibels.

SIM — the card that identifies you to the mobile network — a smart card holding the IMSI and authentication key, or an eSIM profile.

SIMD — one instruction working on many numbers — single instruction multiple data, as in SSE, AVX and NEON.

Single point of failure — the one part whose loss stops everything — a component with no redundancy on the critical path.

SLC to QLC — how many bits are squeezed into one flash cell — single, multi, triple and quad-level cells, trading endurance and speed for density.

Slice — a view into part of an array — a reference with pointer, length and sometimes capacity, without copying.

SLO — the promise you hold yourself to — a service level objective, a target for a measured indicator over a window.

SMTP — how mail servers hand messages to each other — Simple Mail Transfer Protocol, RFC 5321, on ports 25, 465 or 587.

Snapshot — a frozen picture of data at one moment — a point-in-time copy, often made cheaply by copy-on-write.

Socket — the endpoint a program reads and writes a connection through — an OS object identified by address, port and protocol.

Softmax — turning scores into probabilities — exponentiating logits and dividing by their sum so the values total one.

Spinlock — waiting by looping instead of sleeping — a lock that busy-waits, correct only for very short critical sections.

Spread spectrum — deliberately smearing a signal over more bandwidth — modulating over a wide band to resist interference and interception.

Sprite — a small image drawn over the scene — a 2D bitmap composited into a frame, historically with dedicated hardware.

SQL injection — smuggling commands inside data — an attack where unescaped input becomes part of a database query.

SRAM — fast memory built from logic, used in caches — static RAM using six transistors per bit, needing no refresh.

SSD — storage with no moving parts — a solid-state drive of NAND flash plus a controller, with microsecond latency.

SSH — a secure way to log in to another machine — the Secure Shell protocol on port 22, with host keys and public-key user authentication.

SSID — the name of a wireless network — the human-readable network identifier broadcast in beacons.

SSRF — tricking a server into fetching an internal URL — server-side request forgery, reaching private services from a trusted position.

Stack — the memory used for calls and locals — a LIFO region holding frames with return addresses, arguments and locals.

Staging area — what will go into the next commit — git’s index, holding the exact content to be committed.

Stateful firewall — it remembers connections, not just packets — a filter tracking flow state so replies are allowed automatically.

Static linking — the library is baked into the binary — copying library code into the executable at build time.

Streaming — playing while it is still arriving — delivering media progressively rather than downloading it whole.

Subnet — a slice of an address range — a network defined by a prefix, sharing one broadcast domain in IPv4.

Sub-pixel — the red, green or blue part of a dot — one colour element of a pixel, exploitable for text rendering.

Superscalar — issuing several instructions each cycle — a core with multiple parallel execution ports and wide issue.

Swap — using disk when memory runs out — backing anonymous pages with storage so more can be committed than exists.

Symbolic link — a file that points at another path — a special file holding a path string, resolved at open time.

System call — a program asking the kernel to do something — the trap instruction and ABI by which user code enters the kernel.

systemd — the thing that starts everything on modern Linux — an init system and service manager with units, sockets and journal.

T

Tag — a fixed name for one commit — a ref under refs/tags, lightweight or an annotated object with message and signature.

TCP — the protocol that makes sure everything arrives in order — a connection-oriented transport with sequence numbers, acknowledgements and retransmission.

Tearing — the picture split across two frames — a display artefact when the buffer swaps mid-scanout, fixed by vsync.

Temperature — how adventurous the model’s word choice is — a divisor on logits before softmax; lower is more deterministic.

Thread — one line of execution inside a program — a schedulable flow with its own stack and registers, sharing the process address space.

Threat model — deciding who you are defending against — an explicit statement of assets, adversaries, capabilities and out-of-scope risks.

Three-way handshake — the greeting that opens a TCP connection — the SYN, SYN-ACK, ACK exchange establishing sequence numbers.

Throughput — how much work gets done per second — completed operations or bits per unit time, distinct from latency.

Tick rate — how often the game server updates the world — server simulation steps per second, often 20 to 128 in shooters.

TLB — a small cache of address translations — translation lookaside buffer, holding recent virtual-to-physical page mappings.

TLD — the last label of a domain name — the top-level domain such as com, org or in, delegated from the root zone.

TLS — the encryption under HTTPS — Transport Layer Security; version 1.3, RFC 8446, needs one round trip and requires forward secrecy.

Token — the small piece of text a model actually sees — a subword unit from the tokenizer’s vocabulary, roughly 0.75 English words each.

Tokenizer — the tool that cuts text into tokens — the encoder mapping text to integer IDs, usually by byte-pair encoding.

Top-p — keep only the most likely words that add up to p — nucleus sampling, restricting choice to the smallest set whose probability exceeds p.

Trace (observability) — the story of one request across services — a tree of timed spans sharing one trace identifier.

Traceroute — showing the routers along the way — sending packets with increasing TTL and reading the ICMP time-exceeded replies.

Trailing whitespace — invisible spaces at the end of a line — characters that break diffs and comparisons without being visible.

Transaction — all of it or none of it — a group of operations with atomicity, consistency, isolation and durability.

Transformer — the design behind modern language models — a stack of self-attention and feed-forward blocks, from the 2017 paper Attention Is All You Need.

Transistor — an electrical tap — a semiconductor switch or amplifier; in CMOS logic, a field-effect transistor.

Transpiler — a compiler from one language to another readable one — a source-to-source translator, as TypeScript to JavaScript.

Trap — a deliberate jump into the kernel — a synchronous exception raised by an instruction, such as a system call.

Trilateration — finding a position from several distances — computing a location from ranges to known points, as GPS does.

TRIM — telling the drive which blocks are now rubbish — a command letting the filesystem mark blocks free so the SSD can erase them early.

Truncation — cutting data that does not fit — discarding bits, characters or tokens beyond a limit, often silently.

Truth table — every input combination and its output — an exhaustive listing of a Boolean function’s behaviour.

TTL (IP) — a hop counter that stops loops — a header field decremented per router, triggering ICMP time exceeded at zero.

TTL (DNS) — how long an answer may be cached — the seconds a resolver may reuse a record before asking again.

TTY — the terminal a program is attached to — a kernel device providing line discipline, echo and job control.

Tunnel — one network carried inside another — encapsulating packets inside another protocol, as with VPNs and GRE.

Two-factor authentication — a password plus something else — requiring a second independent factor such as a code or hardware key.

Two’s complement — how computers store negative numbers — inverting all bits and adding one, giving one zero and a range from -2^(n-1) to 2^(n-1)-1.

Type system — rules about what values may be combined — a static or dynamic discipline classifying values and rejecting invalid operations.

U

UDP — send it and hope — a connectionless transport with no ordering, no retransmission and very little overhead.

UEFI — the modern replacement for the BIOS — firmware with its own boot manager, GPT support, drivers and optional Secure Boot.

Unicode — one number for every character in every script — a character set of code points from U+0000 to U+10FFFF, with 154,998 assigned in version 16.0.

Unit test — checking one small piece on its own — a fast, isolated test of a single function or class.

Unreachable — nothing can get there from here — an object with no path from a root, or a network with no route.

Upstream — the branch or project yours follows — the configured remote branch a local branch compares and pushes to.

Uptime — how long since the last restart — elapsed time since boot, not the same as availability.

USB — the connector that replaced all the others — Universal Serial Bus, from 12 Mbit/s in 1996 to 80 Gbit/s in USB4 Version 2.0.

User mode — the restricted half of the processor — the unprivileged state where a program cannot touch devices or kernel memory directly.

User space — everything outside the kernel — processes running unprivileged, reaching the kernel only by system calls.

UTF-8 — Unicode written as bytes, ASCII still working — a variable-length encoding using one to four bytes per code point.

UUID — a name unique without asking anyone — a 128-bit identifier, usually version 4 random or version 7 time-ordered.

V

Value (attention) — the content a token contributes when attended to — a projected vector summed with attention weights to form the output.

Vector database — storage that finds things by meaning — an index over embeddings supporting approximate nearest-neighbour search.

Version control — keeping every version and who changed what — a system recording snapshots, authorship and lineage of files.

Vertex — one corner of a shape — a point with position and attributes, processed by the vertex stage.

Virtual machine — a whole fake computer inside a real one — an isolated guest with its own kernel, scheduled by a hypervisor.

Virtual memory — every program thinks it owns the whole address space — per-process address translation through page tables, with protection and paging.

Virtualization — one machine pretending to be several — hardware-assisted isolation of guests, using extensions such as VT-x or AMD-V.

VLAN — several separate networks over one set of wires — IEEE 802.1Q tagging, giving separate broadcast domains on shared links.

Voice coil — the coil that moves a speaker cone — a wire coil in a magnetic gap, driven by current to move the diaphragm.

Volatile (memory) — it forgets when power stops — storage requiring power to retain state, as DRAM and SRAM do.

Voltage — electrical push — potential difference in volts, the work per unit charge between two points.

Volume — storage attached to a container or machine — a named block or filesystem mount whose lifetime is separate from the workload.

VPN — a private tunnel across a public network — an encrypted tunnel giving remote hosts an address inside a protected network.

Vsync — waiting for the screen before swapping the picture — synchronizing buffer swaps to the display refresh to avoid tearing.

Vulnerability — a weakness someone can exploit — a flaw allowing an attacker to violate a security property, often tracked by CVE number.

W

Wafer — the thin silicon disc chips are made on — a 300 mm polished slice cut from a boule, carrying hundreds of dies.

Watchdog — a timer that reboots a stuck system — hardware or software resetting the system if not periodically reset by software.

Wear levelling — spreading writes so no cell dies early — an SSD controller policy distributing program and erase cycles across blocks.

Webhook — the server calls you when something happens — an HTTP POST sent by a service to a URL you registered.

WebSocket — a two-way channel over one web connection — RFC 6455, upgrading an HTTP connection to a persistent frame-based channel.

Weight — one number that scales an input — a learned multiplier in a layer’s matrix, the bulk of a model’s parameters.

Wi-Fi — wireless local networking — IEEE 802.11 standards, branded by generation, currently up to Wi-Fi 7 from 802.11be.

Word (CPU) — the natural size the machine works in — the register and native operand width, 64 bits on current mainstream CPUs.

Workflow — the file describing an automated pipeline — a declarative definition of triggers, jobs and steps for a CI system.

Working set — the pages a program actually needs right now — the memory touched over a recent interval, the amount that must stay resident.

Working tree — the actual files you can see and edit — the checked-out files in your directory, separate from the index and object store.

WPA2 — the Wi-Fi encryption most networks still use — 802.11i security with AES-CCMP and a four-way handshake.

WPA3 — the newer Wi-Fi encryption — security using SAE key exchange, resisting offline dictionary attacks on the passphrase.

Write amplification — the drive writing more than you asked — the ratio of physical NAND writes to host writes, driven by garbage collection.

X

x86 — the instruction set in most PCs — Intel’s CISC architecture from the 1978 8086, extended to 64 bits as x86-64 in 2003.

XDR — the widest brightness range a display claims — extreme dynamic range, a marketing name for HDR panels with high peak luminance.

XML — structured text with tags — a markup language for machine-readable data, standardized in 1998.

XOR — true when the inputs differ — the exclusive-or Boolean function, the core of parity, adders and simple ciphers.

XSS — injecting script into someone else’s page — cross-site scripting, where untrusted input is rendered as executable script.

Y

Y2K — the year 2000 date problem — the failure risk from two-digit year fields, largely averted by remediation before 2000.

YAML — an indentation-based configuration format — a superset of JSON where structure comes from indentation, common in CI and Kubernetes.

Yield — the share of chips that come out working — the fraction of dies on a wafer passing test, the main driver of chip cost.

Z

Zero trust — trust nothing just because it is inside the network — an architecture authenticating and authorizing every request regardless of network position.

Zero-day — an attack for which no fix exists yet — a vulnerability exploited before the vendor has released a patch.

Zombie process — a finished process nobody has collected — a terminated child whose exit status has not yet been reaped by its parent.

Zone (DNS) — one slice of the name tree under one authority — a portion of the namespace served by one set of authoritative servers.