Master Timeline and Glossary

53.0 How to use this chapter#

1. This is the last chapter, and it is the only one built for looking things up rather than reading straight through.
2. Every other chapter in this book teaches one topic twice: once in plain words, once in the engineer’s words. This chapter holds the index to all of them.
3. Because it is a reference, it does not use the six-block shape that the rest of the book uses. It is a timeline, three smaller timelines, a long glossary, and two closing pages.
4. Section 53.1 is the master timeline of computing, from clay tokens around 3000 BCE to the state of things in 2026. Three columns: the year, what happened, and why it mattered.
5. Section 53.2 is a timeline of programming languages, with who made each one and what problem it was built for.
6. Section 53.3 is a timeline of standards and protocols: the written-down agreements that let machines from different makers work together.
7. Section 53.4 is the glossary. It is the main body of this chapter. It is alphabetical, one letter per heading, and it is meant to cover every term used anywhere in the 53 chapters.
8. Every glossary line has exactly three parts, separated by dashes: the term, then the plain meaning in one short sentence, then the technical meaning with the precise definition.
9. Read the plain meaning if you just want to follow a conversation. Read the technical meaning if you have to write it down, argue about it, or build it.
10. Section 53.5 is honest advice on what to do next. Section 53.6 compresses the whole book into exactly 100 numbered lines.
11. A word about dates. Where a thing has several defensible dates, we pick one and say which event it is: invented, first working, published, standardized or shipped. Those can be years apart.
12. Where experts genuinely disagree about a date, we say “about” and give the range. The Antikythera mechanism is the clearest case: published estimates cluster between 150 and 100 BCE.
13. Anything in this chapter dated 2025 or 2026 is recent enough that you should check it again before quoting it. Everything before about 2020 is settled history.
14. Two small conventions used throughout. BCE means before the common era, so the numbers count down. “c.” is short for the Latin circa and means “about”.

53.1 The master timeline of computing#

The table below has one row per event. It is one continuous list in year order. Ancient dates are approximate by nature; modern ones are exact.

53.2 Timeline of programming languages#

The year given is the year the language first worked or was first released, not the year it was designed or the year it became popular. Those can differ by a decade.

53.3 Timeline of standards and protocols#

A standard is a document. It says what a thing must do so that two products made by strangers will work together. The number after the name is the document you can look up.

53.4 The 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.

53.4.1 A#

1. 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.
2. ABI — the binary rulebook two compiled parts must share — application binary interface: calling convention, register use, struct layout, symbol naming.
3. Abstraction — hiding detail behind a simpler idea — a layer offering a stable interface while the implementation beneath is free to change.
4. 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.
5. Activation function — the bend that stops a network being one straight line — an elementwise nonlinearity such as ReLU, GELU or SwiGLU.
6. 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.
7. 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.
8. 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.
9. 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.
10. Aliasing — false patterns from sampling too slowly — signal components above half the sample rate folding back as lower, wrong frequencies.
11. 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.
12. Alignment (AI) — making a model behave as intended — the work of getting model behaviour to match stated human intent, values and constraints.
13. Allocator — the code that hands out memory — the runtime or kernel component that finds, records and returns memory blocks to callers.
14. Alpha channel — how see-through a pixel is — a per-pixel opacity value, usually 8 bits, used when compositing layers.
15. ALU — the part that does the sums — arithmetic logic unit, a combinational block performing add, subtract, bitwise and shift operations and setting flags.
16. Amdahl’s law — the slow part limits your speedup — speedup is bounded by 1/(s + p/N) for serial fraction s over N processors.
17. Ampere — how much electricity flows per second — the SI unit of current, one coulomb of charge per second.
18. Amplitude — how big a wave is — the peak deviation of a signal from its resting value; in audio it maps to loudness.
19. Analogue — smoothly varying, not stepped — a signal that may take any value in a continuous range, unlike a digital signal with discrete levels.
20. Anti-aliasing — smoothing jagged edges — MSAA, FXAA, TAA and similar methods that add or reuse samples to reduce sampling artefacts.
21. Anti-cheat — software that catches players who cheat — combined client integrity checks, server-authoritative rules and statistical detection.
22. Anycast — one address, many machines — announcing the same prefix from several sites so each client reaches the topologically nearest one.
23. 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.
24. API — an agreed way for programs to ask each other for things — the endpoints, functions, arguments and guarantees one piece of software offers another.
25. 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.
26. ARM — the processor family in nearly every phone — a RISC architecture licensed as designs by Arm Ltd, first silicon working in 1985.
27. ARP — finding a neighbour’s hardware address — Address Resolution Protocol, RFC 826, broadcasting for the MAC address owning an IPv4 address on the link.
28. ARPANET — the network the internet grew out of — the ARPA-funded packet network, first message 29 October 1969, retired 1990.
29. 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.
30. ASCII — numbers for English letters — a 7-bit character set from 1963 with 128 code points, 95 printable and 33 control codes.
31. ASLR — moving things so attackers cannot guess addresses — address space layout randomization of stack, heap and library bases at load time.
32. Assembler — turns readable instructions into machine code — a translator producing one machine instruction per mnemonic and resolving labels and directives.
33. Assembly language — machine code you can read — a notation with one mnemonic per instruction, plus labels, macros and assembler directives.
34. AST — a program drawn as a tree — abstract syntax tree, the parser’s output, with nodes for expressions and statements and no punctuation.
35. Asynchronous — start now, collect the answer later — an operation returning before completion, signalling later by callback, event, future or poll.
36. Atomic — all at once or not at all — an operation no observer can see half-finished, enforced by hardware instructions, locks or transactions.
37. 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.
38. Attenuation — a signal weakening with distance — loss of power along a path, measured in decibels, from resistance, absorption or spreading.
39. Authoritative server — the machine holding the real answer for a name — a DNS server answering from its own zone data rather than from cache.
40. Autonegotiation — two ports agreeing a speed by themselves — Ethernet link partners exchanging capability pulses and choosing the best shared speed and duplex.
41. 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.
42. Availability — how much of the time it works — uptime as a fraction; 99.9 percent permits about 43 minutes of downtime per month.
43. Availability zone — one isolated site inside a cloud region — a data centre with independent power and cooling, linked to its region at low latency.
44. AVX — wide maths instructions on x86 chips — Advanced Vector Extensions, SIMD sets using 256-bit registers, or 512-bit in AVX-512.

53.4.2 B#

1. Backpressure — telling the sender to slow down — a flow-control signal propagated upstream when a consumer cannot keep up.
2. Backpropagation — working out which weight caused which mistake — reverse-mode automatic differentiation applying the chain rule from the loss back to every parameter.
3. Bandwidth — how much can flow per second — the data rate of a link in bits per second, distinct from latency, which is delay.
4. Bandwidth throttling — deliberately slowing traffic — rate limiting applied by policy at a network device, service or account level.
5. 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.
6. Bank (memory) — one independently addressed section of a chip — a DRAM subdivision with its own row buffer, allowing one row open per bank.
7. Bare repository — a git repository with no working files — a repository containing only the object database and refs, normally used as a push target.
8. 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.
9. 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.
10. Batch — a handful of examples processed together — the group of samples whose gradients are averaged before one parameter update.
11. bcrypt — an old but sound password hash — a 1999 adaptive hash based on Blowfish, with a cost factor that raises work as hardware improves.
12. Beamforming — aiming a radio signal instead of shouting everywhere — controlling phase across several antennas so signals add in one direction and cancel elsewhere.
13. 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.
14. 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.
15. Bias (AI) — the number added after the multiply — a per-unit learned constant added to the weighted sum before the activation function.
16. Big-endian — the biggest byte first — a byte order storing the most significant byte at the lowest address; network byte order is big-endian.
17. Binary — counting with only 0 and 1 — base-2 positional notation, where each place is worth twice the one to its right.
18. 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.
19. Binning — sorting finished chips by how good they turned out — testing dies and selling them at the highest speed and core count they pass.
20. 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.
21. 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.
22. Bit — one on-or-off — a binary digit, the smallest unit of information, value 0 or 1.
23. 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.
24. Bit rot — data quietly going bad — undetected corruption of stored bits from charge leakage, media decay or cosmic rays, caught only by checksums.
25. BLE — the low-power half of Bluetooth — Bluetooth Low Energy, introduced in version 4.0 in 2010, using 40 channels and short connection events.
26. 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.
27. 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.
28. 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.
29. Blocking — waiting instead of doing something else — a call that does not return until its work completes, holding the calling thread.
30. 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.
31. 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.
32. 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.
33. Bootstrapping — a compiler built with itself — writing a compiler for a language in that same language, after first compiling it with another one.
34. 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.
35. BPE — cutting text into common chunks — byte-pair encoding, repeatedly merging the most frequent adjacent pair to build a fixed-size subword vocabulary.
36. Branch (CPU) — an instruction that may jump — a control-flow instruction whose target or direction may depend on a condition.
37. 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.
38. 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.
39. Bridge — a device joining two network segments — a layer 2 device forwarding frames by learned MAC address; a switch is a multi-port bridge.
40. 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.
41. Buffer — a waiting area for data — memory holding data between a producer and a consumer running at different speeds.
42. 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.
43. Bufferbloat — too much queueing makes everything feel slow — excessive buffering in network devices that inflates latency under load without preventing loss.
44. Bus — a shared set of wires — a set of conductors and rules carrying address, data and control signals between components.
45. Byte — eight bits, the usual unit of size — an octet, 8 bits, able to hold 256 distinct values.
46. Bytecode — halfway between source and machine code — a compact instruction set for a virtual machine, such as JVM bytecode or Python’s .pyc format.

53.4.3 C#

1. Cache — a small fast copy of things you keep needing — memory holding recently or likely used data closer to the consumer than the original.
2. Cache coherence — keeping every core’s copy honest — a protocol such as MESI ensuring all cores see one consistent value for each cache line.
3. Cache hit — the copy was already there — a request satisfied from the cache without going to the slower backing store.
4. 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.
5. Cache miss — the copy was not there — a request that must be served from the next level, costing that level’s latency.
6. Callback — code you hand over to be run later — a function passed to another routine to be invoked when an event or completion occurs.
7. 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.
8. Capability — permission attached to a token, not a person — a transferable right to do a specific operation, held as an unforgeable reference.
9. Capacitor — a component that stores a little charge — two conductors separated by a dielectric, storing charge Q equal to capacitance C times voltage V.
10. 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.
11. 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.
12. 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.
13. Certificate pinning — accepting only one specific certificate — a client refusing certificates other than pinned keys, ignoring the wider CA set.
14. CGNAT — your provider sharing one public address between many homes — carrier-grade NAT, usually using 100.64.0.0/10 from RFC 6598.
15. 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.
16. 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.
17. 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.
18. Checkout — putting a commit’s files into your folder — updating the working tree and HEAD to match a specified commit, branch or path.
19. Checksum — a small number that proves nothing got mangled — a value computed over data and compared after transfer or storage to detect accidental change.
20. Cherry-pick — copying one commit onto another branch — applying a single commit’s diff elsewhere, creating a new commit with a new hash.
21. Chinchilla — the finding that models were trained on too little data — the 2022 DeepMind result giving compute-optimal token and parameter ratios.
22. 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.
23. 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.
24. 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.
25. Cipher suite — the exact set of algorithms a connection uses — the negotiated combination of key exchange, authentication, bulk cipher and MAC or AEAD mode.
26. 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.
27. Client prediction — the game moving you before the server replies — applying local input immediately and reconciling later against authoritative server state.
28. Clock — the machine’s heartbeat — a periodic square wave defining the instants at which state elements sample their inputs.
29. Clock domain — a region sharing one clock — part of a chip driven by one clock, with synchronizers needed for signals crossing to another domain.
30. Closure — a function that remembers where it came from — a function value together with captured bindings from its defining scope.
31. Cloud region — a geographic cluster of data centres — a named location such as ap-south-1, containing several availability zones with independent failure domains.
32. 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.
33. CNAME — a name that points to another name — a DNS record aliasing one name to another, after which resolution restarts at the target.
34. Coalescing — joining small pieces into one bigger one — combining adjacent free blocks, memory accesses or writes to reduce overhead.
35. 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.
36. Codepoint — the number that identifies a character — a Unicode scalar value from U+0000 to U+10FFFF, excluding the surrogate range.
37. Cold start — the first call being slow — the delay while a serverless platform allocates and initializes an execution environment before running your code.
38. Cold storage — cheap storage you rarely read — archival tiers with low cost per gigabyte and retrieval delays measured in minutes to hours.
39. 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.
40. 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.
41. Compaction — tidying storage by rewriting it — merging and rewriting data to reclaim space, as in log-structured stores and SSD garbage collection.
42. Compiler — turns source code into machine code — a program translating a whole source program into another language, usually machine code, before it runs.
43. Compression — making data smaller — encoding that reduces size, lossless if the original returns exactly, lossy if some information is discarded.
44. Concurrency — several things in progress at once — structuring work so tasks overlap in time; parallelism means they literally run at the same instant.
45. 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.
46. Constant folding — doing the maths at compile time — a compiler optimization evaluating constant expressions during compilation.
47. 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.
48. Container (media) — the wrapper holding audio and video together — a file format such as MP4, MKV or WebM carrying encoded streams, timing and metadata.
49. Contamination — a model already saw the exam — benchmark test data appearing in training data, inflating scores without matching ability.
50. 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.
51. 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.
52. 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.
53. Continuous integration — merging often, tested every time — the practice of integrating work frequently, with an automated build and test on every change.
54. Control plane — the part that decides — the systems computing routes, policy and configuration, as opposed to the data plane that moves packets.
55. 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
56. 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.
57. Core — one complete processor inside a chip — an independent set of execution units, registers and L1 caches able to run its own instruction stream.
58. Coroutine — a function that can pause and resume — a routine with suspendable execution state, allowing cooperative multitasking without OS threads.
59. 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.
60. CPU — the part that follows the instructions — central processing unit, the general-purpose processor fetching, decoding and executing instructions.
61. CPU-bound — limited by thinking, not waiting — a workload whose completion time is set by processor throughput rather than I/O.
62. CRC — a strong checksum for detecting damage — cyclic redundancy check, polynomial division over GF(2); CRC-32 protects Ethernet frames.
63. Cross-compilation — building on one machine for another — producing binaries for a target architecture or OS different from the build host.
64. Cryptographic hash — a fingerprint of any data — a one-way function producing a fixed-size digest, where finding collisions is computationally infeasible.
65. CSMA/CA — listen before you transmit, and back off — Carrier Sense Multiple Access with Collision Avoidance, the Wi-Fi access method with random backoff.
66. CSRF — a site tricking your browser into using your login — cross-site request forgery, defeated by anti-forgery tokens and SameSite cookies.
67. CSS — the rules that decide how a page looks — Cascading Style Sheets: selectors and declarations applied by cascade, specificity and inheritance.
68. Culling — not drawing what nobody can see — discarding geometry outside the view frustum, facing away, or hidden behind other objects.
69. Current — the flow of electricity — the rate of charge flow, measured in amperes; one ampere is one coulomb per second.
70. 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.

53.4.4 D#

1. DAC — turns numbers back into a real signal — digital-to-analogue converter, reconstructing a voltage from samples at a fixed rate.
2. Daemon — a program that runs quietly in the background — a long-lived process with no controlling terminal, usually started at boot.
3. Datagram — a message sent with no promises — a self-contained packet delivered without connection setup, ordering or retransmission.
4. dBm — signal strength on a logarithmic scale — power relative to one milliwatt; -50 dBm is strong Wi-Fi and -85 dBm is marginal.
5. DDR — memory that moves data on both clock edges — double data rate SDRAM; DDR5, standardized 2020, starts at 4800 MT/s.
6. Dead code — code that can never run — instructions unreachable on any path, normally removed by the compiler.
7. Deadlock — two tasks each waiting for the other — a cycle of hold-and-wait dependencies where no participant can proceed.
8. Debouncing — ignoring a switch’s noisy chatter — filtering multiple contact transitions into one clean event, typically over 5 to 50 ms.
9. 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.
10. Decode (AI) — writing the answer one token at a time — the autoregressive generation phase, one token per forward pass, memory-bandwidth bound.
11. Decoder-only — the transformer shape used by chat models — a stack of masked self-attention blocks with no separate encoder.
12. Deep learning — networks with many stacked layers — machine learning using multi-layer neural networks trained by gradient descent.
13. 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.
14. Defragmentation — putting a file’s pieces back together — rearranging blocks so files occupy contiguous space, useful on disks and pointless on SSDs.
15. Delta compression — storing only what changed — encoding an object as a difference against a similar one, as git does inside packfiles.
16. Demand paging — loading pages only when touched — bringing a page into memory on its first access, signalled by a page fault.
17. Dependency — something your code needs to work — an external library, service or tool required to build or run software.
18. Dependency injection — passing in what a thing needs — supplying collaborators from outside rather than constructing them internally.
19. Detached HEAD — you are on a commit, not on a branch — HEAD holding a commit hash directly, so new commits belong to no branch.
20. Deterministic lockstep — every machine simulates the same thing — sending only inputs and relying on identical simulation on all clients.
21. DHCP — the network hands you an address automatically — Dynamic Host Configuration Protocol, RFC 2131, using the DORA exchange to lease settings.
22. Die — one chip cut from a wafer — a single rectangle of processed silicon containing a complete circuit.
23. Dielectric — the insulating filling in a capacitor — a non-conducting material that polarizes in a field and raises capacitance.
24. Diffie-Hellman — agreeing a secret over an open line — key exchange where each side combines its private value with the other’s public value.
25. Diode — a one-way valve for electricity — a PN junction conducting when forward biased above about 0.7 V in silicon.
26. Directory — a folder holding names — a filesystem object mapping names to inode numbers or file records.
27. 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.
28. Disk image — a file holding a whole drive’s contents — a byte-for-byte copy of a block device, including partition table and filesystems.
29. Distributed system — several machines pretending to be one — a system whose components run on networked machines and coordinate by message passing.
30. Distro — one packaged version of Linux — a distribution bundling a kernel, libraries, package manager and defaults, such as Debian or Fedora.
31. DMA — devices moving data without bothering the CPU — direct memory access, where a controller transfers to or from memory and interrupts on completion.
32. DNS — the phone book turning names into addresses — a distributed hierarchical database of resource records, RFC 1034 and 1035.
33. DNS resolver — the helper that does the lookups for you — a recursive server that queries root, TLD and authoritative servers and caches results.
34. Docker — the tool that made containers easy — a container engine with an image format, build file and registry workflow, released 2013.
35. Docker image — a frozen filesystem plus start instructions — a layered, content-addressed bundle of filesystem layers and configuration metadata.
36. DOM — the page as a tree the code can change — Document Object Model, the browser’s live object tree built from parsed HTML.
37. 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.
38. DPI — dots per inch on paper — printer resolution; PPI is the screen equivalent, pixels per inch.
39. DPO — training from preferences without a reward model — direct preference optimization, fitting the policy directly to pairs of preferred and rejected answers.
40. 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.
41. Draw call — one order sent to the graphics card — a command to render a batch of geometry with one state and shader set.
42. Driver — the code that speaks a device’s language — kernel or user-space software translating generic requests into device-specific commands.
43. DROP — silently binning a packet — a firewall action discarding a packet with no reply, so the sender only sees a timeout.
44. Duplex — whether both ends can talk at once — full duplex allows simultaneous send and receive; half duplex allows only one direction at a time.
45. Dynamic linking — libraries joined at start-up, not build time — resolving symbols at load or first use, sharing one library copy across processes.

53.4.5 E#

1. eBPF — running safe little programs inside the kernel — an in-kernel virtual machine with a verifier, used for tracing, networking and security.
2. ECC (memory) — memory that corrects its own small errors — error-correcting code memory, typically SECDED, fixing single-bit and detecting double-bit errors.
3. 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.
4. ECMP — spreading traffic over several equally good paths — equal-cost multipath, hashing a flow’s five-tuple to pick one of several next hops.
5. Edge case — the odd input that breaks things — a condition at the boundary of valid input, often untested.
6. Edge computing — doing work near the user instead of far away — running compute at points of presence close to clients to cut latency.
7. Elasticity — capacity that grows and shrinks with demand — automatic scaling of resources in response to load, with matching cost changes.
8. ELF — the executable format on Linux — Executable and Linkable Format, with a header, program headers for loading and section headers for linking.
9. Embedding — a meaning turned into a list of numbers — a learned dense vector whose geometry places related items close together.
10. Emulation — one machine pretending to be another — software reproducing another system’s instruction set and devices closely enough to run its software.
11. Encapsulation (networks) — wrapping one message inside another — placing a higher-layer unit into a lower-layer payload with its own header.
12. Encoder — the half that reads rather than writes — a transformer stack producing representations of an input without generating tokens.
13. Endianness — which end of a number comes first — byte order in memory; little-endian stores the least significant byte at the lowest address.
14. Endpoint — one address a service answers on — a specific URL and method combination, or a network address plus port.
15. Entropy — how surprising the data is — the average information per symbol in bits, the floor for lossless compression.
16. Environment variable — a setting passed to a program at start — a name-value pair inherited through the process environment, such as PATH or HOME.
17. Ephemeral port — the temporary port your side uses — a short-lived source port, usually from 32768 to 60999 on Linux, chosen per connection.
18. Epoch (training) — one full pass through the data — one complete presentation of the training set to the learner.
19. Epoch (time) — the moment counting starts — the Unix epoch, 00:00:00 UTC on 1 January 1970, the zero point for time_t.
20. Error budget — the amount of failure you are allowed — the difference between 100 percent and an SLO, spendable on risky changes.
21. Etching — cutting the pattern into the wafer — removing material chemically or with plasma where photoresist does not protect it.
22. 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.
23. EUV — the light used to print the smallest features — extreme ultraviolet lithography at 13.5 nm wavelength, in production since 2019.
24. Eventual consistency — everyone agrees, given a moment — a model where replicas converge if updates stop, without guaranteeing immediate agreement.
25. Exception — an error that jumps out of normal flow — a signalled condition transferring control to a handler and unwinding the stack.
26. Exit code — the number a program leaves behind — a process’s status, 0 for success by convention and 1 to 255 for failure.
27. 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.
28. Extension — the bit after the dot in a filename — a naming convention, not a guarantee; the real type comes from content or magic numbers.

53.4.6 F#

1. Fan-out — how many things one thing drives — the number of inputs a single output feeds, limiting speed in logic and load in messaging.
2. 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.
3. Fault tolerance — carrying on despite broken parts — designing so component failure degrades service instead of stopping it.
4. Feature flag — a switch that turns a feature on or off — configuration allowing behaviour to change at runtime without redeploying.
5. Fetch (git) — download new objects but change nothing — updating remote-tracking refs and objects without touching your branches or working tree.
6. FIFO — first in, first out — a queue discipline, or a named pipe file created with mkfifo.
7. 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.
8. File handle — the object behind an open file — the kernel structure holding the file’s position, mode and reference count.
9. 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.
10. Fine-tuning — extra training on your own examples — continued training of a pretrained model on a smaller task-specific dataset.
11. 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.
12. Firewall — a guard deciding which packets may pass — a device or kernel subsystem filtering traffic by rules over addresses, ports, state and content.
13. Firmware — software living in the device itself — code stored in non-volatile memory on a device, run before or beneath the operating system.
14. 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.
15. Fixed timestep — the game’s physics ticks at one steady rate — advancing simulation in constant increments regardless of frame time, with interpolation for display.
16. Flash memory — storage that keeps data with no power — floating-gate or charge-trap cells holding charge, erased in blocks and written in pages.
17. Flip-flop — a circuit that remembers one bit — an edge-triggered storage element capturing its input at a clock edge.
18. Floating point — a number with a moving decimal point — a sign, exponent and fraction encoding under IEEE 754, trading precision for range.
19. Flow control — stopping a fast sender flooding a slow receiver — TCP’s advertised receive window, or the equivalent at other layers.
20. Flush — pushing buffered data out now — forcing pending writes from a buffer to the next level, such as fsync to storage.
21. 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.
22. Fork (repository) — your own copy of someone’s project — a server-side clone under your account, with its own refs and pull-request relationship.
23. Forward proxy — a middleman your client chooses — a server making requests on a client’s behalf, often for policy or caching.
24. 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.
25. Fragment (IP) — a packet cut up to fit — an IP packet split to fit a link’s MTU, reassembled at the destination.
26. Frame (network) — the layer 2 envelope — the Ethernet or Wi-Fi unit with MAC addresses, payload and a frame check sequence.
27. Frame (graphics) — one complete picture — one full rendered image; at 60 Hz the frame budget is 16.67 ms.
28. 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.
29. Frame rate — pictures per second — displayed frames per second; smoothness also depends on frame time consistency, not the average alone.
30. Framebuffer — the memory holding the picture to be shown — a region of memory holding pixel values scanned out to a display.
31. 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.
32. Frequency — how many cycles per second — cycles per second in hertz; a 4 GHz clock has a period of 250 picoseconds.
33. 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.
34. Full-duplex — talking and listening at the same time — simultaneous bidirectional transmission on separate paths or with echo cancellation.
35. Function call — jumping into a named block and coming back — transferring control with arguments and a return address, following the ABI’s calling convention.
36. Fuzzing — throwing random rubbish at a program to break it — automated testing with mutated or generated inputs, watching for crashes and assertion failures.

53.4.7 G#

1. Game loop — read input, update, draw, repeat — the cycle sampling input, advancing simulation and rendering, once per frame.
2. Gamma — the curve between number and brightness — a nonlinear transfer function matching encoding to perception, roughly 2.2 for sRGB.
3. Garbage collection — memory tidied up automatically — a runtime reclaiming unreachable objects, by tracing or reference counting.
4. Gate (logic) — a tiny circuit applying one logical rule — a circuit implementing AND, OR, NOT, NAND, NOR or XOR over binary inputs.
5. Gate (transistor) — the leg that switches the flow — the control terminal whose voltage forms or removes the channel between source and drain.
6. Gateway — the way out of your local network — the router a host sends to when the destination is not on its own subnet.
7. GATT — how Bluetooth devices expose small values — Generic Attribute Profile, a hierarchy of services, characteristics and descriptors addressed by handle.
8. GDDR — memory built for graphics cards — graphics DDR SDRAM tuned for very high bandwidth with wide buses and high clock rates.
9. Gigabit — a thousand million bits — 10^9 bits; note that 1 Gbit/s is 125 MB/s before protocol overhead.
10. GIL — only one thread runs Python bytecode at a time — CPython’s global interpreter lock, serializing bytecode execution across threads.
11. Git — the version control system almost everyone uses — a content-addressed distributed VCS created by Linus Torvalds in April 2005.
12. Golden image — the trusted base copy you build from — a validated machine or container image used as the starting point for deployments.
13. Goodput — the useful data rate, not the raw one — application-level throughput after headers, retransmissions and protocol overhead.
14. Goroutine — a very cheap thread in Go — a lightweight task multiplexed onto OS threads by the Go runtime scheduler.
15. GPIO — a pin you can set high or low yourself — general-purpose input/output, a configurable digital pin on a microcontroller or board.
16. GPT (partition) — the modern partition table — GUID Partition Table, part of UEFI, supporting large disks and 128 partitions by default.
17. GPT (model) — a generative pretrained transformer — a decoder-only transformer trained to predict the next token.
18. GPU — the chip built for many small sums at once — a processor with thousands of simple lanes, built for throughput on parallel work.
19. Graceful degradation — losing features instead of falling over — designing so partial failure reduces function rather than causing an outage.
20. Gradient clipping — stopping an update from being too big — rescaling gradients whose norm exceeds a threshold, to keep training stable.
21. Gradient descent — walking downhill on the error — updating parameters against the gradient of the loss, scaled by the learning rate.
22. 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.
23. Ground — the reference point voltages are measured from — the common return path defined as zero volts in a circuit.
24. gRPC — fast structured calls between services — a remote procedure call framework using Protocol Buffers over HTTP/2, with streaming support.
25. Guard clause — checking the bad case first and leaving — an early return that removes nesting from the main path.
26. GUI — pointing at pictures instead of typing commands — a graphical user interface with windows, icons, menus and a pointer.

53.4.8 H#

1. Hallucination — a model stating something untrue with confidence — fluent output not grounded in training data or provided context.
2. Handover — your phone moving to the next mast without dropping — transferring an active connection between cells while keeping the session alive.
3. Handshake — the greeting that sets up a connection — the exchange establishing parameters, such as TCP’s SYN, SYN-ACK, ACK.
4. Hard link — two names for the same file — a second directory entry pointing at the same inode, with a shared link count.
5. 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.
6. HBM — memory stacked right next to the processor — high bandwidth memory, stacked DRAM dies on an interposer, giving terabytes per second.
7. HDD — a drive with spinning magnetic platters — a hard disk with rotating platters and moving heads, giving milliseconds of seek latency.
8. HDR — brighter brights and darker darks — high dynamic range imaging with wider luminance range, usually with a PQ or HLG transfer function.
9. HEAD — where you are in the repository right now — a ref pointing to the current branch, or directly to a commit when detached.
10. Header — the label on the front of a message — the fixed or structured prefix carrying addressing and control information before the payload.
11. Heap — memory you ask for and give back yourself — the region for dynamic allocation, managed by the allocator rather than by scope.
12. Heat sink — metal that carries heat away — a finned metal block spreading and radiating heat from a package to moving air or liquid.
13. Hertz — cycles per second — the SI unit of frequency, one cycle per second.
14. Hexadecimal — counting in sixteens — base-16 notation using 0 to 9 and A to F, where one digit encodes exactly four bits.
15. Hit rate — how often the cache had it — the fraction of requests served from cache, the main determinant of average latency.
16. Hop — one router along the way — a single forwarding step; traceroute reveals hops by increasing the TTL.
17. Hotfix — an urgent small change — a minimal patch shipped outside the normal release cycle to fix a live problem.
18. HTML — the markup that says what parts a page has — HyperText Markup Language, a tree of elements the browser parses into the DOM.
19. HTTP — the rules browsers and servers use to talk — a request-response protocol with methods, status codes and headers, now RFC 9110.
20. HTTPS — HTTP inside an encrypted tunnel — HTTP carried over TLS, normally on port 443, giving confidentiality, integrity and server authentication.
21. Huffman coding — short codes for common symbols — an optimal prefix-free code built from symbol frequencies, used inside DEFLATE and JPEG.
22. Hyperparameter — a setting you choose before training — a value not learned by gradient descent, such as learning rate, batch size or layer count.
23. Hyper-threading — one core pretending to be two — simultaneous multithreading, running two instruction streams over one core’s execution resources.
24. 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.

53.4.9 I#

1. IaaS — renting raw machines and networks — infrastructure as a service, where you manage the OS and everything above it.
2. IAM — who is allowed to do what — identity and access management: principals, policies, roles and permission evaluation.
3. ICMP — the network’s error and echo messages — the control protocol carrying unreachable, time exceeded and echo, RFC 792.
4. Idempotent — doing it twice changes nothing more — an operation whose repeated application has the same effect as one application.
5. Idle — doing nothing on purpose — a scheduler state with no runnable task, usually entering a low-power CPU state.
6. IEEE 754 — the rule that makes floating point the same everywhere — the 1985 standard defining binary32, binary64, rounding modes, infinities and NaN.
7. Image (container) — a frozen filesystem plus start-up settings — a layered, content-addressed bundle of layers and configuration.
8. IMEI — the serial number identifying a phone itself — a 15-digit equipment identity, distinct from the SIM’s subscriber identity.
9. Immutable — it cannot be changed after it is made — a value or object whose state is fixed at creation, simplifying sharing and caching.
10. Impedance — how much a component resists an alternating signal — the complex ratio of voltage to current; speakers are commonly 4 or 8 ohms.
11. Index (git) — the staging area between edits and a commit — a binary file listing paths, modes and blob hashes for the next commit.
12. Inductor — a coil that resists sudden changes in current — a component storing energy in a magnetic field, with voltage proportional to di/dt.
13. Inference — using a trained model to get an answer — the forward pass only, with no gradients and no parameter updates.
14. Infrastructure as code — servers described in files, not clicked into existence — declarative resource definitions kept in version control and applied by a tool.
15. init — the first process the kernel starts — PID 1, which starts services and adopts orphaned processes.
16. Inode — the record holding a file’s facts — a filesystem structure with mode, owner, times, size and block pointers, but not the name.
17. Instruction pipeline — several instructions in progress at once — overlapping fetch, decode, execute and write-back stages to raise throughput.
18. Instruction set — the list of operations a CPU understands — the ISA: opcodes, registers, addressing modes and the binary encoding.
19. Instruction tuning — teaching a model to follow requests — supervised fine-tuning on instruction-and-response pairs.
20. 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.
21. Integration test — checking that the parts work together — a test exercising several components and their real interfaces.
22. Interface (network) — one connection point on a machine — a NIC or virtual device with its own MAC address, addresses and statistics.
23. Intermediate representation — the compiler’s private middle language — an IR such as LLVM IR, easier to optimize than source or machine code.
24. Interpreter — runs source code directly, line by line — a program executing a source or bytecode representation without producing a native binary.
25. Interrupt — a device tapping the CPU on the shoulder — an asynchronous signal causing the CPU to jump to a handler and return.
26. Interrupt latency — how long before the handler starts — the delay from signal assertion to the first handler instruction.
27. IOMMU — an address translator for devices — hardware mapping and restricting device DMA addresses, essential for safe passthrough.
28. 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.
29. IPC (CPU) — instructions finished per clock tick — instructions per cycle, the other half of performance beside frequency.
30. IPC (software) — how two programs talk — inter-process communication by pipes, sockets, shared memory or message queues.
31. IPv4 — the old 32-bit address scheme — RFC 791 addressing, about 4.3 billion addresses, exhausted at IANA in 2011.
32. IPv6 — the 128-bit replacement — RFC 8200 addressing with 2^128 addresses, no header checksum and no router fragmentation.
33. IXP — a building where networks meet and swap traffic — an internet exchange point with a shared switch fabric for peering.

53.4.10 J#

1. JavaScript — the language that runs inside web pages — a dynamically typed, event-driven language standardized as ECMAScript.
2. JIT — compiling while the program runs — just-in-time compilation of hot paths to native code, guided by runtime profiles.
3. Jitter — how much the delay wobbles — variation in packet delay, more damaging than average latency for voice and games.
4. Job (CI) — one unit of work in a pipeline — a set of steps run on one runner, with its own environment and result.
5. Job control — putting a command in the background — shell management of process groups with foreground, background and stopped states.
6. Journaling — writing down the plan before doing it — a filesystem log of intended metadata changes, replayed after a crash.
7. JSON — a simple text format for structured data — JavaScript Object Notation: objects, arrays, strings, numbers, booleans and null.
8. JWT — a signed token you can read yourself — JSON Web Token, RFC 7519, a base64url header, payload and signature joined by dots.

53.4.11 K#

1. Kernel (OS) — the part of the system with full power over the machine — the code running in privileged mode, owning scheduling, memory and devices.
2. Kernel (maths) — the small window slid over data — a filter matrix applied by convolution across an image or signal.
3. Kernel mode — the privileged half of the processor — the state allowing all instructions and address ranges, entered by trap or interrupt.
4. Kernel panic — the system giving up — an unrecoverable kernel error that halts the machine rather than risk corruption.
5. Key (attention) — what each token offers to be matched against — a projected vector compared with queries to produce attention weights.
6. Key derivation — turning a password into a proper key — a KDF such as PBKDF2, scrypt or Argon2 stretching a secret into key material.
7. Key exchange — agreeing a secret without posting it — a protocol such as Diffie-Hellman letting both sides derive a shared key.
8. Keyframe — a video frame that stands alone — an intra-coded frame decodable without reference to others, the seek point in a stream.
9. Kill — telling a process to stop — sending a signal such as SIGTERM to request exit or SIGKILL to force it.
10. Kilobyte — a thousand bytes — 1000 bytes in SI usage; 1024 bytes is a kibibyte, KiB.
11. Knowledge cutoff — the date a model’s reading stops — the point beyond which pretraining data was not collected.
12. Kubernetes — the system that keeps containers running — a container orchestrator with a declarative API and reconciling controllers.
13. KV cache — remembering earlier keys and values so they are not redone — stored per-layer key and value tensors for tokens already processed.

53.4.12 L#

1. Lag compensation — the server rewinding time to judge your shot — re-evaluating a hit against the world state the shooter actually saw.
2. Latch — a memory circuit that follows while enabled — a level-sensitive storage element, unlike an edge-triggered flip-flop.
3. Latency — the waiting time before something starts — the delay between cause and effect, measured end to end and reported as percentiles.
4. LBA — numbering blocks straight through — logical block addressing, a linear block number replacing cylinder, head and sector.
5. LCD — a screen where a backlight shines through gates — liquid crystal display, twisting crystals to control light per subpixel.
6. Learning rate — how big a step training takes — the scale factor on the gradient, the most sensitive hyperparameter.
7. Least privilege — give only the rights actually needed — restricting each principal to the minimum permissions for its task.
8. Lexer — the part that cuts source code into words — the tokenizer producing a stream of tokens from characters.
9. LFS — keeping big files out of git’s history — Large File Storage, replacing large files with pointers and storing content separately.
10. Library — reusable code you call — a packaged collection of functions linked statically or loaded dynamically.
11. Linked list — items each pointing at the next — a sequence of nodes with pointers, cheap to insert and slow to index.
12. Linker — joins compiled pieces into one program — the tool resolving symbols, laying out sections and producing an executable or shared object.
13. Little-endian — the smallest byte first — byte order storing the least significant byte at the lowest address, as x86 and ARM do.
14. Load balancer — spreading requests across servers — a device or service distributing connections by round robin, least connections or hashing.
15. Loader — the code that puts a program into memory — the kernel or dynamic loader mapping segments, resolving symbols and jumping to the entry point.
16. localhost — the name a machine uses for itself — the hostname resolving to 127.0.0.1 and ::1, never leaving the machine.
17. Locality — recently or nearby data is likely used again — temporal and spatial locality, the reason caches work.
18. Lock — one at a time, please — a synchronization primitive giving exclusive access to shared state.
19. LOD — simpler models for distant objects — level of detail, swapping meshes or textures by screen size to save work.
20. Log — the running record of what happened — an append-only stream of events used for debugging, audit and recovery.
21. Logic gate — a tiny circuit applying one rule — a combinational circuit implementing a Boolean function of its inputs.
22. Logit — the raw score before it becomes a probability — the unnormalized output per vocabulary entry, fed to softmax.
23. Loopback — the machine talking to itself — the virtual interface for 127.0.0.0/8 and ::1, never leaving the host.
24. LoRA — training a small add-on instead of the whole model — low-rank adaptation, learning two small matrices whose product updates a frozen weight.
25. Loss function — the score that says how wrong the model is — the objective minimized in training, typically cross-entropy for language models.
26. Lossless — nothing is thrown away — compression from which the exact original bytes can be restored, as in FLAC, PNG and gzip.
27. Lossy — some detail is thrown away for size — compression discarding information judged imperceptible, as in JPEG, MP3 and H.264.
28. LRU — throw out what was used longest ago — least recently used, a common cache replacement policy.
29. LTE — the fourth generation mobile standard — 3GPP Long Term Evolution, an all-IP radio network using OFDMA downlink.

53.4.13 M#

1. MAC (crypto) — a tag proving a message was not altered — message authentication code, such as HMAC, computed with a shared secret key.
2. MAC address — the hardware name of a network port — a 48-bit link-layer address, the first 24 bits identifying the manufacturer.
3. Mach-O — the executable format on macOS — Apple’s binary format, with load commands and support for fat binaries holding several architectures.
4. 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.
5. Malloc — asking for memory while running — the C library call returning a pointer to an uninitialized block of the requested size.
6. MBR — the old partition table in the first sector — master boot record, four primary partitions and a 2 TiB limit.
7. Memory leak — memory taken and never given back — allocated memory that stays reachable but unused, growing the process footprint.
8. Merge — joining two lines of work — a commit with two or more parents, combining changes since the merge base.
9. Merge base — the last commit both branches share — the best common ancestor used as the reference point in a three-way merge.
10. Merge queue — testing changes in the order they will land — a forge feature building each pull request against the real future main branch.
11. mergeStateStatus — a forge’s summary of whether a merge is possible — GitHub’s field with values such as CLEAN, BLOCKED, BEHIND, DIRTY or UNKNOWN.
12. MESI — the four states a cache line can be in — modified, exclusive, shared, invalid: the coherence protocol keeping cores consistent.
13. Metadata — data about the data — attributes such as size, times, type and permissions, held separately from content.
14. Microkernel — a tiny kernel with drivers outside it — a design keeping only scheduling, memory and IPC privileged, with services in user space.
15. Microservice — a small service that does one job — an independently deployable service with its own data and interface.
16. Middleware — code sitting between request and handler — a chain of components processing requests before or after the application.
17. Migration (data) — changing the shape of stored data — a versioned script altering schema or contents, applied in order and recorded.
18. MIMO — several antennas sending several streams — multiple input multiple output, using spatial paths to multiply capacity.
19. Mipmap — smaller pre-made copies of a texture — a chain of half-size texture levels selected by screen footprint to avoid shimmering.
20. 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.
21. MMU — the hardware that translates addresses — memory management unit, walking page tables to map virtual to physical addresses.
22. Mode (file) — the permission bits on a file — the 12-bit field holding owner, group and other permissions plus setuid, setgid and sticky.
23. Model card — the label describing what a model is and is not — a document stating intended use, training data summary, evaluations and limitations.
24. Modulation — changing a wave so it carries data — varying amplitude, frequency or phase to encode symbols on a carrier.
25. Monolithic kernel — one big kernel with drivers inside — a design running services and drivers in kernel mode, as Linux does.
26. Monorepo — everything in one repository — a single repository holding many projects, with shared tooling and atomic cross-project changes.
27. Moore’s law — transistors per chip keep doubling — Gordon Moore’s 1965 observation, revised in 1975 to a doubling roughly every two years.
28. MOSFET — the switch nearly all chips are made from — metal-oxide-semiconductor field-effect transistor, whose gate voltage forms a channel.
29. Mount — attaching a filesystem into the tree — making a device or remote share visible at a directory path.
30. Mount point — the directory where a filesystem appears — the path at which a filesystem’s root is grafted into the namespace.
31. MTU — the biggest packet a link will carry — maximum transmission unit, 1500 bytes on standard Ethernet.
32. Multicast — one send, many listeners — delivery to a group address, where the network duplicates packets only where paths diverge.
33. Multi-head attention — several attention views at once — running attention in parallel subspaces and concatenating the results.
34. Multiplexing — many conversations over one link — interleaving several logical streams on one physical or transport channel.
35. Mutation testing — checking that tests would notice a bug — deliberately altering code to see whether the test suite fails.
36. Mutex — a lock only one holder may take — mutual exclusion primitive with owner tracking, blocking other threads until released.

53.4.14 N#

1. Namespace (Linux) — a private view of a system resource — a kernel feature isolating mounts, PIDs, network stacks, users or hostnames per process group.
2. NaN — the float that means “not a number” — an IEEE 754 value produced by invalid operations, unequal even to itself.
3. NAND flash — the storage in phones and SSDs — non-volatile memory of series-connected cells, written per page and erased per block.
4. NAT — many private machines behind one public address — network address translation, rewriting addresses and ports and tracking the mapping.
5. Netcode — the part of a game that handles the network — the synchronization design: tick rate, prediction, interpolation and reconciliation.
6. Netmask — which part of an address is the network — a bit mask marking the prefix, written as 255.255.255.0 or as /24.
7. Network interface — the port a machine uses to reach a network — a physical or virtual device with a MAC address and its own addresses.
8. Neural network — layers of weighted sums with bends between them — a differentiable function of stacked linear maps and nonlinearities, fitted by gradient descent.
9. Next hop — the router to hand this packet to — the neighbouring address a routing table entry sends matching traffic to.
10. Nginx — a common web server and reverse proxy — an event-driven server handling many connections with few processes.
11. Nibble — half a byte — four bits, exactly one hexadecimal digit.
12. NIC — the network card — network interface controller, handling framing, checksums and often offloads.
13. Node (compute) — one machine in a cluster — a host contributing CPU, memory and storage, managed by the cluster’s scheduler.
14. Node (process) — the transistor generation name — a marketing label such as 5 nm or 3 nm, no longer matching any physical dimension.
15. Nonce — a number used exactly once — a value ensuring freshness or uniqueness, never repeated under one key.
16. Non-volatile — it remembers with the power off — storage retaining state without power, unlike DRAM and SRAM.
17. Normalization (AI) — keeping numbers in a sensible range — layer or RMS normalization rescaling activations to stabilize training.
18. Notification (interrupt) — see interrupt — an asynchronous event delivered to software rather than polled for.
19. NTP — how machines agree what time it is — Network Time Protocol, disciplining clocks to within milliseconds over the internet.
20. Null pointer — a pointer deliberately pointing at nothing — the reserved address zero, whose dereference traps on most systems.
21. NUMA — memory that is closer to some cores than others — non-uniform memory access, where latency depends on which node owns the memory.
22. NVMe — the protocol built for flash, not for disks — a command set over PCIe with deep parallel queues and very low overhead.
23. NVRAM — small memory that survives a reboot — non-volatile RAM used for firmware settings and boot variables.
24. Nyquist — sample at least twice the highest frequency — the sampling theorem requiring a rate above twice the signal bandwidth to avoid aliasing.

53.4.15 O#

1. OAuth — letting an app act for you without your password — a delegation framework issuing scoped access tokens, RFC 6749.
2. Object file — compiled code not yet joined up — a relocatable binary with sections, symbols and relocation entries.
3. Observability — being able to tell what a system is doing — the ability to answer new questions from existing logs, metrics and traces.
4. OFDM — splitting a channel into many narrow lanes — orthogonal frequency division multiplexing, used by Wi-Fi, LTE, 5G and DSL.
5. Ohm’s law — push equals flow times resistance — V = IR, relating voltage, current and resistance in a linear element.
6. OLED — a screen where each dot makes its own light — organic light-emitting diode panels with no backlight, giving true black.
7. Opcode — the number that says which operation — the field of an instruction encoding selecting the operation to perform.
8. Opcode fusion — merging two instructions into one operation — a CPU front-end optimization combining common instruction pairs.
9. Open weights — the trained numbers are published — a model whose parameters are downloadable, which is not the same as open training data.
10. Orchestration — deciding what runs where — automated placement, scaling and recovery of workloads across a cluster.
11. Origin — the default name for where you cloned from — the conventional remote name git creates for the source repository.
12. Origin server — the machine holding the real content — the source a CDN fetches from when it has no valid cached copy.
13. Orphan (git) — an object nothing points to — an unreachable object, removable by garbage collection after its grace period.
14. Oscillator — the circuit that makes the ticking — a crystal or ring circuit producing a periodic reference signal.
15. OSI model — seven named layers for teaching — ISO 7498, from physical up to application, useful as vocabulary, not as an implementation.
16. Out-of-order — doing ready work first, then tidying up — executing instructions as operands become available, retiring them in program order.
17. Overclocking — running a chip faster than rated — raising frequency and often voltage beyond specification, at the cost of heat and stability.
18. Overfitting — memorizing the answers instead of learning — fitting noise in training data, shown by training loss falling while validation loss rises.
19. Overlay network — a network built on top of another — virtual links tunnelled over an existing network, as with VXLAN or WireGuard.
20. Overprovisioning — spare flash the drive keeps hidden — reserved capacity that improves garbage collection and endurance.

53.4.16 P#

1. PaaS — you bring the code, they run everything else — platform as a service, managing runtime, scaling and patching for you.
2. Packaging (chips) — putting the die in something you can solder — attaching a die to a substrate with bumps or wires and encapsulating it.
3. Packet — one labelled chunk of data — a network-layer unit of header plus payload, routed independently.
4. Packet loss — a packet that never arrives — discard caused by congestion, errors or policy, inferred from missing acknowledgements.
5. Packfile — many git objects compressed into one file — a container storing objects with delta compression, plus an index for lookup.
6. Page — the unit memory is managed in — a fixed-size block of virtual memory, usually 4 KiB, mapped to a physical frame.
7. Page fault — the page was not in memory — a trap when a virtual page has no valid mapping, handled by loading or allocating.
8. Page table — the map from virtual to physical pages — a multi-level structure walked by the MMU, cached in the TLB.
9. Parameter (AI) — one learned number in the model — a single weight or bias updated by training and stored in the model file.
10. Parity — one extra bit to spot an odd error — a bit making the count of ones even or odd, detecting single-bit errors.
11. Parser — the part that works out the structure — the component turning tokens into a syntax tree by grammar rules.
12. Partition — one labelled region of a drive — a contiguous block range described by an MBR or GPT entry.
13. Pass@k — did any of k attempts pass — a benchmark metric giving credit if at least one of k samples is correct.
14. Passphrase — a long password made of words — a secret chosen for entropy through length rather than symbol variety.
15. Patch — a file describing a change — a unified diff with context lines, applicable to matching source.
16. PATH — the list of folders the shell searches — an environment variable of directories scanned in order for a command name.
17. Payload — the actual content, minus the wrapping — the data a protocol carries, excluding headers and trailers.
18. PCIe — the fast lanes connecting chips inside a computer — PCI Express, point-to-point serial lanes; gen 5 runs 32 GT/s per lane.
19. PCM — sound stored as plain numbers — pulse-code modulation, uncompressed samples at a fixed rate and bit depth.
20. PE — the executable format on Windows — Portable Executable, with a DOS stub, COFF header and sections such as .text and .rdata.
21. Peering — two networks exchanging traffic directly — a bilateral agreement to swap customer routes, often settlement-free.
22. Permission — what you are allowed to do to a file — access bits or ACL entries checked by the kernel on open.
23. Persistent storage — data that outlives the process — storage surviving restarts, unlike memory or a container’s writable layer.
24. Phase — where a wave is in its cycle — angular offset in degrees or radians, the basis of phase-shift keying.
25. Photolithography — printing the circuit pattern with light — projecting a mask image onto photoresist to define features on a wafer.
26. Photoresist — the light-sensitive coating on a wafer — a polymer whose solubility changes on exposure, defining where etching happens.
27. Piconet — a small group of Bluetooth devices working together — one primary device and up to seven active secondaries sharing a hopping pattern.
28. Ping — asking a host whether it is there — sending ICMP echo requests and timing the replies.
29. Pipe — the output of one command becoming the input of the next — a kernel buffer joining one process’s stdout to another’s stdin.
30. Pipeline (CPU) — instructions in a production line — overlapping instruction stages so one finishes per cycle in the ideal case.
31. Pixel — one dot of the picture — the smallest addressable element of a raster image or display.
32. Plist — the settings file format on Apple systems — a property list, in XML or binary form, holding key-value configuration.
33. PN junction — where p-type meets n-type silicon — the boundary forming a depletion region and conducting in only one direction.
34. Pod — the smallest deployable unit in Kubernetes — one or more containers sharing a network namespace, address and storage volumes.
35. Pointer — a value that holds an address — a variable containing the memory address of another object.
36. Polling — asking repeatedly instead of being told — checking a status in a loop rather than waiting for an interrupt or event.
37. Port — the number identifying which program on a machine — a 16-bit endpoint identifier in TCP and UDP headers.
38. Positional encoding — telling the model where each word sits — added or rotated information giving order to otherwise position-blind attention.
39. POSIX — the portable Unix rulebook — IEEE 1003 standards defining system calls, shell and utilities.
40. PPI — how tightly packed the dots are — pixels per inch of a display, about 460 on current high-end phones.
41. Precision — how finely a number can be written — the count of significant bits or digits a format can represent.
42. Prefetch — fetching before it is asked for — hardware or software loading data into cache ahead of predicted use.
43. Prefill — reading the whole prompt in one go — the parallel forward pass over input tokens that fills the KV cache, compute bound.
44. Pretraining — the long first training on huge text — self-supervised next-token training that produces a base model.
45. Primary key — the column that identifies a row — a unique, non-null identifier for a table’s rows.
46. Privilege escalation — getting more power than you were given — an exploit raising a principal’s permissions beyond its intended level.
47. Process — one running program with its own memory — an address space, one or more threads, and a table of open file descriptors.
48. Profiling — measuring where the time actually goes — sampling or instrumenting a program to attribute cost to code paths.
49. Prompt injection — hidden text telling a model to misbehave — untrusted content in a model’s context that overrides intended instructions.
50. Propagation delay — the time a gate takes to change its output — the interval from input transition to a valid output, tens of picoseconds today.
51. Protocol — the agreed rules for a conversation — the message formats, ordering and state machine two parties follow.
52. Proxy — a middleman making requests for you — a server that terminates one connection and opens another on the client’s behalf.
53. PTY — a fake terminal for a program that expects one — pseudo-terminal, a master and slave pair providing terminal semantics without hardware.
54. Pull request — asking for your branch to be merged — a forge object linking a source branch, target branch, review and checks.
55. Push — sending your commits to a remote — uploading objects and asking the remote to update refs, refused if it is not a fast-forward.
56. PWM — a switch flicked fast to fake a level — pulse-width modulation, varying duty cycle to control average power.

53.4.17 Q#

1. QAM — packing more bits into each radio symbol — quadrature amplitude modulation; 1024-QAM carries 10 bits per symbol.
2. Quantization — using coarser numbers to save space — reducing weight precision, for example FP16 to INT8 or 4-bit, with a small accuracy cost.
3. Query (attention) — what one token is looking for — a projected vector compared against every key to produce attention weights.
4. Queue — a line of waiting work — a FIFO structure decoupling producers from consumers.
5. QUIC — a fast transport built on UDP — RFC 9000, giving streams, encryption and connection migration without head-of-line blocking.
6. Quorum — enough members agreeing to decide — a majority of replicas required for a consistent read or write.
7. Quota — a cap on how much you may use — an enforced limit on storage, requests or resources per account or user.

53.4.18 R#

1. Race condition — the answer depends on who gets there first — a bug where behaviour depends on the unsynchronized timing of concurrent access.
2. RAG — letting a model read documents before answering — retrieval-augmented generation, injecting retrieved passages into the prompt.
3. RAID — several drives acting as one, for speed or safety — striping, mirroring or parity across disks; RAID is not a backup.
4. RAM — the fast memory that forgets when power stops — volatile random-access memory holding running code and data.
5. Rebase — replaying your commits on a new base — creating new commits with the same changes but new parents and new hashes.
6. Refactoring — tidying code without changing behaviour — a behaviour-preserving transformation improving structure or clarity.
7. Reflog — git’s private diary of where refs pointed — a local log of ref updates, letting you recover from a bad reset.
8. Refresh rate — how often the screen redraws — display updates per second in hertz, commonly 60, 120 or 144.
9. Register — the CPU’s own handful of tiny stores — a named storage location inside the core, accessed in a fraction of a cycle.
10. Registry (containers) — the shop images are pulled from — a service storing and serving container images by name and digest.
11. Registry (Windows) — the central settings database — a hierarchical store of keys and values used by Windows and its applications.
12. Regularization — stopping the model memorizing — techniques such as weight decay, dropout or early stopping that limit overfitting.
13. REJECT — refusing a packet and saying so — a firewall action sending an ICMP unreachable or TCP RST, so the sender fails fast.
14. Remote — a named repository somewhere else — a stored URL plus fetch and push refspecs, such as origin.
15. Remote-tracking ref — your last known idea of a remote branch — a local ref under refs/remotes updated only by fetch or push.
16. Replication — keeping copies on more than one machine — maintaining synchronized data on several nodes for durability or read scaling.
17. Repository — the whole project with all its history — a directory containing the object database, refs and configuration.
18. Resistance — how much a material fights the flow — the ratio of voltage to current, in ohms, dissipating power as heat.
19. Resolution — how many dots the picture has — the pixel count of an image or display, such as 1920 by 1080.
20. Resolver — the helper that does DNS lookups for you — a recursive server querying the hierarchy and caching results by TTL.
21. REST — using plain HTTP methods on named resources — an architectural style with stateless requests and uniform verbs over URLs.
22. Reverse proxy — a middleman in front of the servers — a server accepting client requests and forwarding them to backends.
23. 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.
24. Ring buffer — a fixed queue that wraps around — a circular array with head and tail indices, overwriting or blocking when full.
25. RLHF — training a model on what people preferred — reinforcement learning from human feedback, optimizing against a learned reward model.
26. Root server — the servers at the top of DNS — the 13 named root identities serving the root zone, reached by anycast.
27. Rootkit — malware that hides itself in the system — code subverting the kernel or firmware to conceal its own presence.
28. RoPE — encoding position by rotating the vectors — rotary position embedding, applying a position-dependent rotation to queries and keys.
29. Round-trip time — how long there and back takes — the delay from sending to receiving the acknowledgement, driving TCP behaviour.
30. Router — the box that forwards between networks — a device choosing an outgoing interface by longest-prefix match on the destination.
31. Routing table — the list of where to send what — the forwarding entries of prefix, next hop, interface and metric.
32. 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.
33. RST — a rude end to a TCP connection — a reset flag telling the peer to abandon the connection immediately.
34. Runner — the machine that executes a CI job — an agent that claims jobs from a queue and reports results back.

53.4.19 S#

1. SaaS — you just use the website — software as a service, run entirely by the provider with no infrastructure for you.
2. Salt — a random extra ingredient in a password hash — a unique per-password value stored alongside it, defeating precomputed tables.
3. Same-origin policy — one site cannot read another’s data — the browser rule isolating documents by scheme, host and port.
4. Sampling (AI) — choosing the next word from the odds — drawing from the model’s output distribution, shaped by temperature and top-p.
5. Sampling rate — how many measurements per second — samples per second; CD audio uses 44,100 Hz.
6. Sandbox — a restricted area a program cannot escape — an isolation mechanism limiting a process’s syscalls and resources.
7. SATA — the older cable standard for drives — Serial ATA, 6 Gbit/s in revision 3, with one command queue.
8. Scaling laws — bigger models and more data give predictable gains — empirical power-law relations between compute, data, parameters and loss.
9. Scheduler — decides which task runs next — the kernel component choosing runnable threads by policy and priority.
10. Scope (OAuth) — the exact list of things a token may do — a string set attached to a token limiting the operations it authorizes.
11. SDK — the tools you need to build for a platform — a software development kit of libraries, headers, tools and samples.
12. Sector — the smallest addressable piece of a disk — 512 bytes traditionally, 4096 bytes on Advanced Format drives.
13. Segment — TCP’s unit of data — the transport-layer unit with sequence numbers, flags and payload.
14. Semantic versioning — the version number tells you what changed — MAJOR.MINOR.PATCH, where a major bump means a breaking change.
15. Semaphore — a counter that limits how many may proceed — a synchronization primitive with wait and signal operations.
16. Semiconductor — a material between a conductor and an insulator — a solid such as silicon whose conductivity is controlled by doping, field or light.
17. Serialization — turning objects into bytes to send or store — encoding structures into a byte stream, reversed by deserialization.
18. Serverless — you write the function, not the server — a model where the platform runs code on demand and bills by invocation and duration.
19. Session — the memory of who you are between requests — server or token state associating requests with an authenticated user.
20. SHA-256 — a common cryptographic fingerprint — a hash producing a 256-bit digest, used in TLS, git and signing.
21. Shader — a small program the GPU runs per vertex or pixel — GPU code for stages such as vertex, fragment or compute.
22. Sharding — splitting data across several databases — partitioning by key so each shard holds a subset of the rows.
23. Shebang — the first line saying which interpreter to use — the two bytes #! plus a path, read by the kernel when running a script.
24. Shell — the program that reads your commands — a command interpreter handling expansion, redirection, pipelines and job control.
25. Signal (Unix) — a short message telling a process something happened — an asynchronous notification such as SIGINT, SIGTERM or SIGSEGV.
26. Signal-to-noise ratio — how loud the message is compared with the hiss — the power ratio of signal to noise, usually in decibels.
27. SIM — the card that identifies you to the mobile network — a smart card holding the IMSI and authentication key, or an eSIM profile.
28. SIMD — one instruction working on many numbers — single instruction multiple data, as in SSE, AVX and NEON.
29. Single point of failure — the one part whose loss stops everything — a component with no redundancy on the critical path.
30. 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.
31. Slice — a view into part of an array — a reference with pointer, length and sometimes capacity, without copying.
32. SLO — the promise you hold yourself to — a service level objective, a target for a measured indicator over a window.
33. SMTP — how mail servers hand messages to each other — Simple Mail Transfer Protocol, RFC 5321, on ports 25, 465 or 587.
34. Snapshot — a frozen picture of data at one moment — a point-in-time copy, often made cheaply by copy-on-write.
35. Socket — the endpoint a program reads and writes a connection through — an OS object identified by address, port and protocol.
36. Softmax — turning scores into probabilities — exponentiating logits and dividing by their sum so the values total one.
37. Spinlock — waiting by looping instead of sleeping — a lock that busy-waits, correct only for very short critical sections.
38. Spread spectrum — deliberately smearing a signal over more bandwidth — modulating over a wide band to resist interference and interception.
39. Sprite — a small image drawn over the scene — a 2D bitmap composited into a frame, historically with dedicated hardware.
40. SQL injection — smuggling commands inside data — an attack where unescaped input becomes part of a database query.
41. SRAM — fast memory built from logic, used in caches — static RAM using six transistors per bit, needing no refresh.
42. SSD — storage with no moving parts — a solid-state drive of NAND flash plus a controller, with microsecond latency.
43. 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.
44. SSID — the name of a wireless network — the human-readable network identifier broadcast in beacons.
45. SSRF — tricking a server into fetching an internal URL — server-side request forgery, reaching private services from a trusted position.
46. Stack — the memory used for calls and locals — a LIFO region holding frames with return addresses, arguments and locals.
47. Staging area — what will go into the next commit — git’s index, holding the exact content to be committed.
48. Stateful firewall — it remembers connections, not just packets — a filter tracking flow state so replies are allowed automatically.
49. Static linking — the library is baked into the binary — copying library code into the executable at build time.
50. Streaming — playing while it is still arriving — delivering media progressively rather than downloading it whole.
51. Subnet — a slice of an address range — a network defined by a prefix, sharing one broadcast domain in IPv4.
52. Sub-pixel — the red, green or blue part of a dot — one colour element of a pixel, exploitable for text rendering.
53. Superscalar — issuing several instructions each cycle — a core with multiple parallel execution ports and wide issue.
54. Swap — using disk when memory runs out — backing anonymous pages with storage so more can be committed than exists.
55. Symbolic link — a file that points at another path — a special file holding a path string, resolved at open time.
56. System call — a program asking the kernel to do something — the trap instruction and ABI by which user code enters the kernel.
57. systemd — the thing that starts everything on modern Linux — an init system and service manager with units, sockets and journal.

53.4.20 T#

1. Tag — a fixed name for one commit — a ref under refs/tags, lightweight or an annotated object with message and signature.
2. TCP — the protocol that makes sure everything arrives in order — a connection-oriented transport with sequence numbers, acknowledgements and retransmission.
3. Tearing — the picture split across two frames — a display artefact when the buffer swaps mid-scanout, fixed by vsync.
4. Temperature — how adventurous the model’s word choice is — a divisor on logits before softmax; lower is more deterministic.
5. Thread — one line of execution inside a program — a schedulable flow with its own stack and registers, sharing the process address space.
6. Threat model — deciding who you are defending against — an explicit statement of assets, adversaries, capabilities and out-of-scope risks.
7. Three-way handshake — the greeting that opens a TCP connection — the SYN, SYN-ACK, ACK exchange establishing sequence numbers.
8. Throughput — how much work gets done per second — completed operations or bits per unit time, distinct from latency.
9. Tick rate — how often the game server updates the world — server simulation steps per second, often 20 to 128 in shooters.
10. TLB — a small cache of address translations — translation lookaside buffer, holding recent virtual-to-physical page mappings.
11. TLD — the last label of a domain name — the top-level domain such as com, org or in, delegated from the root zone.
12. TLS — the encryption under HTTPS — Transport Layer Security; version 1.3, RFC 8446, needs one round trip and requires forward secrecy.
13. Token — the small piece of text a model actually sees — a subword unit from the tokenizer’s vocabulary, roughly 0.75 English words each.
14. Tokenizer — the tool that cuts text into tokens — the encoder mapping text to integer IDs, usually by byte-pair encoding.
15. Top-p — keep only the most likely words that add up to p — nucleus sampling, restricting choice to the smallest set whose probability exceeds
16. Trace (observability) — the story of one request across services — a tree of timed spans sharing one trace identifier.
17. Traceroute — showing the routers along the way — sending packets with increasing TTL and reading the ICMP time-exceeded replies.
18. Trailing whitespace — invisible spaces at the end of a line — characters that break diffs and comparisons without being visible.
19. Transaction — all of it or none of it — a group of operations with atomicity, consistency, isolation and durability.
20. 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.
21. Transistor — an electrical tap — a semiconductor switch or amplifier; in CMOS logic, a field-effect transistor.
22. Transpiler — a compiler from one language to another readable one — a source-to-source translator, as TypeScript to JavaScript.
23. Trap — a deliberate jump into the kernel — a synchronous exception raised by an instruction, such as a system call.
24. Trilateration — finding a position from several distances — computing a location from ranges to known points, as GPS does.
25. TRIM — telling the drive which blocks are now rubbish — a command letting the filesystem mark blocks free so the SSD can erase them early.
26. Truncation — cutting data that does not fit — discarding bits, characters or tokens beyond a limit, often silently.
27. Truth table — every input combination and its output — an exhaustive listing of a Boolean function’s behaviour.
28. TTL (IP) — a hop counter that stops loops — a header field decremented per router, triggering ICMP time exceeded at zero.
29. TTL (DNS) — how long an answer may be cached — the seconds a resolver may reuse a record before asking again.
30. TTY — the terminal a program is attached to — a kernel device providing line discipline, echo and job control.
31. Tunnel — one network carried inside another — encapsulating packets inside another protocol, as with VPNs and GRE.
32. Two-factor authentication — a password plus something else — requiring a second independent factor such as a code or hardware key.
33. 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.
34. Type system — rules about what values may be combined — a static or dynamic discipline classifying values and rejecting invalid operations.

53.4.21 U#

1. UDP — send it and hope — a connectionless transport with no ordering, no retransmission and very little overhead.
2. UEFI — the modern replacement for the BIOS — firmware with its own boot manager, GPT support, drivers and optional Secure Boot.
3. 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.
4. Unit test — checking one small piece on its own — a fast, isolated test of a single function or class.
5. Unreachable — nothing can get there from here — an object with no path from a root, or a network with no route.
6. Upstream — the branch or project yours follows — the configured remote branch a local branch compares and pushes to.
7. Uptime — how long since the last restart — elapsed time since boot, not the same as availability.
8. 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.
9. User mode — the restricted half of the processor — the unprivileged state where a program cannot touch devices or kernel memory directly.
10. User space — everything outside the kernel — processes running unprivileged, reaching the kernel only by system calls.
11. UTF-8 — Unicode written as bytes, ASCII still working — a variable-length encoding using one to four bytes per code point.
12. UUID — a name unique without asking anyone — a 128-bit identifier, usually version 4 random or version 7 time-ordered.

53.4.22 V#

1. Value (attention) — the content a token contributes when attended to — a projected vector summed with attention weights to form the output.
2. Vector database — storage that finds things by meaning — an index over embeddings supporting approximate nearest-neighbour search.
3. Version control — keeping every version and who changed what — a system recording snapshots, authorship and lineage of files.
4. Vertex — one corner of a shape — a point with position and attributes, processed by the vertex stage.
5. Virtual machine — a whole fake computer inside a real one — an isolated guest with its own kernel, scheduled by a hypervisor.
6. Virtual memory — every program thinks it owns the whole address space — per-process address translation through page tables, with protection and paging.
7. Virtualization — one machine pretending to be several — hardware-assisted isolation of guests, using extensions such as VT-x or AMD-V.
8. VLAN — several separate networks over one set of wires — IEEE 802.1Q tagging, giving separate broadcast domains on shared links.
9. Voice coil — the coil that moves a speaker cone — a wire coil in a magnetic gap, driven by current to move the diaphragm.
10. Volatile (memory) — it forgets when power stops — storage requiring power to retain state, as DRAM and SRAM do.
11. Voltage — electrical push — potential difference in volts, the work per unit charge between two points.
12. Volume — storage attached to a container or machine — a named block or filesystem mount whose lifetime is separate from the workload.
13. VPN — a private tunnel across a public network — an encrypted tunnel giving remote hosts an address inside a protected network.
14. Vsync — waiting for the screen before swapping the picture — synchronizing buffer swaps to the display refresh to avoid tearing.
15. Vulnerability — a weakness someone can exploit — a flaw allowing an attacker to violate a security property, often tracked by CVE number.

53.4.23 W#

1. Wafer — the thin silicon disc chips are made on — a 300 mm polished slice cut from a boule, carrying hundreds of dies.
2. Watchdog — a timer that reboots a stuck system — hardware or software resetting the system if not periodically reset by software.
3. Wear levelling — spreading writes so no cell dies early — an SSD controller policy distributing program and erase cycles across blocks.
4. Webhook — the server calls you when something happens — an HTTP POST sent by a service to a URL you registered.
5. WebSocket — a two-way channel over one web connection — RFC 6455, upgrading an HTTP connection to a persistent frame-based channel.
6. Weight — one number that scales an input — a learned multiplier in a layer’s matrix, the bulk of a model’s parameters.
7. Wi-Fi — wireless local networking — IEEE 802.11 standards, branded by generation, currently up to Wi-Fi 7 from 802.11be.
8. Word (CPU) — the natural size the machine works in — the register and native operand width, 64 bits on current mainstream CPUs.
9. Workflow — the file describing an automated pipeline — a declarative definition of triggers, jobs and steps for a CI system.
10. Working set — the pages a program actually needs right now — the memory touched over a recent interval, the amount that must stay resident.
11. Working tree — the actual files you can see and edit — the checked-out files in your directory, separate from the index and object store.
12. WPA2 — the Wi-Fi encryption most networks still use — 802.11i security with AES-CCMP and a four-way handshake.
13. WPA3 — the newer Wi-Fi encryption — security using SAE key exchange, resisting offline dictionary attacks on the passphrase.
14. Write amplification — the drive writing more than you asked — the ratio of physical NAND writes to host writes, driven by garbage collection.

53.4.24 X#

1. x86 — the instruction set in most PCs — Intel’s CISC architecture from the 1978 8086, extended to 64 bits as x86-64 in 2003.
2. XDR — the widest brightness range a display claims — extreme dynamic range, a marketing name for HDR panels with high peak luminance.
3. XML — structured text with tags — a markup language for machine-readable data, standardized in 1998.
4. XOR — true when the inputs differ — the exclusive-or Boolean function, the core of parity, adders and simple ciphers.
5. XSS — injecting script into someone else’s page — cross-site scripting, where untrusted input is rendered as executable script.

53.4.25 Y#

1. Y2K — the year 2000 date problem — the failure risk from two-digit year fields, largely averted by remediation before 2000.
2. YAML — an indentation-based configuration format — a superset of JSON where structure comes from indentation, common in CI and Kubernetes.
3. Yield — the share of chips that come out working — the fraction of dies on a wafer passing test, the main driver of chip cost.

53.4.26 Z#

1. Zero trust — trust nothing just because it is inside the network — an architecture authenticating and authorizing every request regardless of network position.
2. Zero-day — an attack for which no fix exists yet — a vulnerability exploited before the vendor has released a patch.
3. Zombie process — a finished process nobody has collected — a terminated child whose exit status has not yet been reaped by its parent.
4. Zone (DNS) — one slice of the name tree under one authority — a portion of the namespace served by one set of authoritative servers.

53.5 Where to go next#

1. Understanding comes from doing. You did not learn to ride a bicycle by reading about balance, and this is the same.
2. Pick the one layer in this book that annoyed you most because you did not quite get it. Go there first. Discomfort is a good compass.
3. Build the smallest possible version of something you used today. A shell that runs one command. A web server that returns one line. A tiny assembler.
4. Then break it on purpose. Unplug the network mid-transfer. Fill the disk. Send a malformed header. You learn more from the failure than the success.
5. Read real source code, not just tutorials. Start with something small and old: a coreutils command, a toy compiler, an early version of a database.
6. Read the actual specifications. RFCs are shorter and clearer than their reputation. So is the IEEE 754 summary. So is the git object format.
7. Learn one tool that shows you the truth: a packet capture tool, a debugger, a profiler, or strace. One of these changes how you think permanently.
8. When something breaks, write down what you observed before you write down what you think it means. Keep those two columns separate. That is diagnosis.
9. Do not chase every new framework. The layers under them barely change. The person who knows the layers can pick up any framework in a week.
10. Teach it to someone. If you cannot explain it plainly, you have not finished learning it. That is the whole reason this book has a plain half.
11. Be sceptical of benchmark numbers, including ones you like. Ask what was measured, on what, by whom, and what was left out.
12. It is normal to forget most of the details. Keep this chapter. Remember the shape of the thing, and look the numbers up when you need them.
13. Nobody understands all of this at once, including the people who built it. Every expert you admire has a large map and a few deep holes.
14. You started with charge in a wire and finished with a language model. That is one continuous story, and you now know it end to end. Go and build.

53.6 The whole book in 100 lines#

1. Everything starts with charge, a property of matter that pushes and pulls.
2. Voltage is push, current is flow, resistance is how hard the path fights back.
3. Ohm’s law ties them together: voltage equals current times resistance.
4. Silicon is neither a good conductor nor a good insulator, and that is why it is useful.
5. Add tiny amounts of other elements and you get n-type and p-type silicon.
6. Join them and you get a junction that passes current in only one direction.
7. Add a third terminal and a small voltage controls a large flow. That is a transistor.
8. A transistor used as a switch is the only real trick in the whole machine.
9. Sand becomes a pure crystal, the crystal becomes a wafer, the wafer becomes chips.
10. Light prints the pattern, chemicals cut it, and the layers are built up in turn.
11. Not every die works, so yield quietly decides the price of everything.
12. Wire a few transistors one way and you get a gate: AND, OR, NOT, NAND.
13. NAND alone can build every other gate, and therefore every digital circuit.
14. Gates wired in a pattern add binary numbers without knowing what addition is.
15. Feed a gate’s output back into its input and it holds a value. That is memory.
16. A clock decides when things may change, so signals have time to settle first.
17. Six transistors hold one bit quickly. That is SRAM, and it becomes cache.
18. One transistor and one capacitor hold one bit cheaply. That is DRAM, and it forgets.
19. Charge trapped on an isolated gate holds a bit with no power. That is flash.
20. Nothing in any of this knows what a number means.
21. Meaning is a convention. We agree that a pattern of bits stands for something.
22. Binary counts in twos. Hexadecimal writes four bits per digit for human eyes.
23. Negative numbers use two’s complement, so one adder handles both signs.
24. Fractions use floating point, standardized as IEEE 754 in 1985, and it rounds.
25. Text is numbers too. ASCII gave 128 characters. Unicode gives over a million.
26. UTF-8 stores Unicode as bytes and leaves old ASCII files working unchanged.
27. Pictures are grids of pixels, and each pixel is three numbers for brightness.
28. A framebuffer holds those numbers, and the screen scans them out many times a second.
29. Sound is air pressure measured thousands of times a second and stored as numbers.
30. A converter turns those numbers back into a voltage that moves a coil and a cone.
31. A CPU fetches an instruction, decodes it, executes it, and writes the result.
32. It does this in a pipeline, so several instructions are in progress at once.
33. It guesses which way each branch will go, and it is usually right.
34. It runs work out of order and finishes it in order, to hide the waiting.
35. Memory is far slower than the core, so caches keep recent data close by.
36. A cache line is 64 bytes, and code that respects that runs several times faster.
37. Programs use virtual addresses, and hardware translates them through page tables.
38. That gives every process its own world and stops one program reading another’s.
39. Storage is not memory. Storage keeps things when the power stops.
40. A hard disk seeks in milliseconds. A solid-state drive answers in microseconds.
41. Flash erases in big blocks, so drives shuffle data and hide where it really is.
42. Filesystems turn a flat array of blocks into names, folders and permissions.
43. Buses carry data between chips, and inside a computer the fast one is PCIe.
44. Firmware runs before any operating system and knows how to wake the machine.
45. Software is a pattern of bits held in the same memory as data. That is the big idea.
46. A compiler reads source text, works out what it means, and writes machine code.
47. It tokenizes, parses into a tree, checks meaning, optimizes, then emits code.
48. An interpreter skips the output file and carries out the meaning directly.
49. A linker joins the compiled pieces and a loader maps them into memory to run.
50. Languages are tools with opinions, each built for the problem of its own time.
51. An operating system shares one machine between many programs, safely.
52. The kernel is privileged. Your code is restricted and asks by system call.
53. A scheduler decides who runs next, thousands of times every second.
54. Drivers translate general requests into the exact language of one device.
55. The shell is only a program that reads your words and starts other programs.
56. Pipes join those programs so one program’s output becomes another’s input.
57. A file extension is a hint, not a fact. The bytes at the start are the fact.
58. An executable is a file with a header telling the loader how to start it.
59. Pressing a key sends a code that becomes an event that becomes a character.
60. A font renderer turns that character into pixels, composited into one frame.
61. A GPU exists because pictures need the same small sum done millions of times.
62. Thousands of simple lanes beat a few clever cores when the work is parallel.
63. A network is machines agreeing how to wrap, address and forward data.
64. Data is cut into packets so one big transfer cannot block everyone else.
65. Each layer adds a header and treats the layer above it as opaque payload.
66. An IP address names an interface. A MAC address names a port on one link.
67. Private addresses are reused everywhere, and NAT hides many machines behind one.
68. Routers forward by longest prefix match and know nothing of your conversation.
69. BGP is how independent networks tell each other which prefixes they can reach.
70. DNS turns names into addresses through a hierarchy of caches and authorities.
71. TCP adds sequence numbers, acknowledgements and retransmission to make a stream.
72. UDP adds almost nothing, which is exactly what real-time traffic wants.
73. Traceroute shows the path by sending packets that expire one hop further each time.
74. Silence is evidence. A timeout with no reply tells you what a refusal does not.
75. Diagnosis is separating what an observation proves from what it merely suggests.
76. Radio carries the same bits on a wave, shaped by modulation and shared by turns.
77. TLS wraps a connection in encryption, and a certificate chain proves who answered.
78. A firewall drops or rejects, a VPN tunnels, and a CDN moves content closer to you.
79. The web is documents fetched by HTTP, marked up in HTML, styled by CSS, moved by JavaScript.
80. An API is a promise about requests and answers, so machines can call machines.
81. Git stores snapshots, not differences, and names every object by its content hash.
82. A commit points at a tree and at its parents, and cannot change without changing its name.
83. Branches are only moving labels, which is why making one costs nothing.
84. Because the whole history is local, you can work fully with no network at all.
85. Merge joins two histories. Rebase rewrites yours onto a new base, with new hashes.
86. A forge adds accounts, review, permissions and automation on top of plain git.
87. Continuous integration runs your tests on a machine you do not own, against one exact commit.
88. Cloud is renting someone else’s computers, with the hard parts already solved.
89. Containers isolate processes. Virtual machines isolate whole kernels.
90. Security is a threat model, least privilege, and honesty about what you cannot stop.
91. A game is a loop: read input, advance the world by a fixed step, draw, repeat.
92. Everything in that loop must fit the frame budget, or the player feels it.
93. Across a network the client guesses ahead, and the server has the final say.
94. Machine learning replaces rules you write with numbers fitted to examples.
95. A network of weighted sums and bends is trained by gradient descent on a loss.
96. Backpropagation works out which weight caused how much of the error.
97. A transformer lets every token look at every other token, all at once.
98. A language model only predicts the next token. Everything else follows from that.
99. It has no memory beyond its context, no access to truth, and no intent of its own.
100. From charge in a wire to a conversation with a machine, it is one continuous story, and you have now read it.