Glossary

The element that holds a whole table, from to .

The table's title. It must be the first thing inside ; browsers draw it centred above the grid.

Table row: holds the cells of one row, from left to right.

Table header: a header cell that labels other cells. Drawn bold and centred by default.

Table data: an ordinary data cell holding one value.

The part of an HTML document that holds metadata. Nothing in it is drawn in the page area; the visible content goes in .

An element that wraps an img and one or more source elements, to swap in a different picture (art direction) or format.

The special method behind +. a + b calls a.__add__(b); it should return the result, usually a new object.

A list of a module's public names. from module import * imports exactly these.

The dictionary where Python keeps a function's hints, for example {'n': int, 'return': int}.

The set-up method. The with statement calls it before the block; its return value is what as binds.

The special method behind ==. A dataclass's version compares the fields in order.

The clean-up method, called with three arguments: the error's type, the error and its traceback, or three Nones when the block ended normally.

The method Python runs on every new object right after making it, to give it its starting attributes.

The method Python calls automatically on each new instance to set up its attributes.

The special method that sets up a new object. Coins(3) makes the object, then calls __init__ with it as self and 3 as n.

The file that marks a folder as a regular package. It runs when the package is first imported and may be empty.

A module's name: the module's own name when it is imported, and '__main__' for the file you run.

The special method that returns an object's text form for programmers. print() and str() fall back to it when there is no __str__.

The special method that gives an object's text form for developers; print() uses it when there is no __str__.

The special method for a friendly text form. print(x) and str(x) use it when a class defines it.

The tsc option that writes a .d.ts file next to each .js file it outputs.

A new box made as the first child of the element, before its own content. It exists only when the content property is set.

Matches an element that is the first child of its parent. Same as :nth-child(1).

Matches an element while a pointer, such as a mouse, is over it (or over one of its children).

A selector that matches the top element of the document. In an HTML page that is the html element.

A pseudo-class that matches the document's root element, the element in a web page.

Null-conditional access (stops and gives null if the left side is null), null-coalescing (use the right side if the left is null), and null-coalescing assignment (assign only if null).

The parent folder, one level up. A single . means this folder.

A file listing names and patterns that Git should not track, such as .env or __pycache__/.

The free, open-source platform C# runs on, for Windows, macOS and Linux. It includes the dotnet tool, the CLR and a large library.

A hidden part of every function: a link to the scope the function was created in. A call of the function uses it as the new scope's outer link.

The hidden internal link from an object to its prototype (or to null). Read it with Object.getPrototypeOf(obj).

The xUnit attribute that marks a method as a test with no inputs.

A test that runs once for each row of data; each [InlineData] attribute gives one row of arguments.

@shout above def greet means greet = shout(greet), done once when the def runs.

A decorator in contextlib that turns a generator function into a context manager: code before yield is the set-up, code after it the clean-up.

An at-rule that names an animation and lists its waypoints, such as 50% { scale: 1.4; }.

A line such as @layer base, components; that creates layers and fixes their order before any styles are put in them.

A rule that registers a custom property with a type, an initial value and whether it inherits, so the browser can check and animate it.

An npm package from the DefinitelyTyped project that holds .d.ts files for a JavaScript library that ships none.

Placed before a pointer, as in *p, it follows the address to the object there, to read it or write it.

A parameter with two stars. It collects every extra keyword argument into a dict of name: value pairs.

A parameter with one star. It collects every extra positional argument into a tuple.

Parameters that collect any positional and keyword arguments, so a wrapper can pass them all on to the original function.

Inside a member function, the object the function was called on. Returning *this by reference gives that object back.

The file that lists the filesystems to mount at boot: one line each, with six fields (what, where, type, options, dump, check order).

The file that lists groups, one per line: name, password placeholder, GID, and the members.

The file that lists users, one per line: name, password placeholder, UID, GID, comment, home folder, shell.

Placed before a variable, as in &x, it gives that variable's address.

Separates a lambda's parameters (left) from its body (right). Read it as "goes to".

Python's interactive mode: it reads a line, runs it, prints the answer and loops back for the next one.

One transistor plus one capacitor: the DRAM cell. The transistor is the door between the capacitor and the bit line.

The smallest mux: two inputs, one select bit. Y = (NOT S AND A) OR (S AND B).

An HTTP answer meaning the stored copy is still current, sent with no file attached.

A mux with four inputs and two select bits: 00, 01, 10 and 11 pick D0, D1, D2 and D3.

Four key messages between the access point and a device on a WPA2 or WPA3 network that prove both hold the same secret and create fresh encryption keys.

Four EAPOL-Key frames that turn the shared master key (PMK) into fresh session keys. In WPA2-Personal, a recording of it is enough to test password guesses offline.

Protocol, source IP, source port, destination IP and destination port. Together they name one connection.

The adaptation layer that squeezes IPv6 headers (40 bytes) down to as little as 2 bytes and splits big packets so they fit 802.15.4 frames.

A digit made of seven bars, named a to g, that light in different patterns to show 0 to 9.

4 bytes inserted after the source MAC: TPID 0x8100, then 3 priority bits, 1 drop-eligible bit and a 12-bit VLAN ID.

Four bytes added after the source MAC address: 0x8100, then a priority and a 12-bit VLAN ID (1 to 4094).

Port-based network access control: a device gets in only after an authentication server approves its own credentials.

The anchor element, … . Its content is the clickable text; its href says where to go.

The DNS record that holds an IPv6 address. The A record holds an IPv4 address.

The empty document every new frame holds until its src page arrives.

A path that starts with /. It is read from the root, so it means the same thing from any folder.

A path that starts at / and names every folder on the way, such as /home/sam/notes/todo.txt. It works from anywhere.

A full URL with a scheme and a host. It means the same thing on any page.

The rule A + A·B = A: if A alone already makes the result 1, the term A·B adds nothing.

A class marked abstract cannot be created with new; an abstract method has no body and every non-abstract derived class must override it.

A tree of the program's operators and values. Spacing and brackets are gone; the tree's shape shows what is worked out first.

Deciding on the server, for every request, whether this user may do this action on this record. Also called authorization.

The switches people and devices plug into: one port per desk, VLAN membership, Power over Ethernet.

The box that links Wi-Fi (radio) devices into the home network.

The box that joins Wi-Fi devices to the wired network. It has a radio on one side and an Ethernet cable on the other, and passes frames between them.

A switch port that belongs to exactly one VLAN. Frames leave it without a tag, so the device needs no VLAN support.

A switch port in a single VLAN. Frames on it carry no VLAN tag, so the device plugged in does not need to know VLANs exist.

One of the two transistors that act as doors between an SRAM cell's storage nodes and its bit lines.

Making a page usable by everyone, including people who use a screen reader, only a keyboard, or other assistive technology.

A version of the page the browser builds for assistive technology: each part with its role, name and state.

The browser's summary of the page for assistive technology: one node per meaningful element, each with a role, a name and sometimes a state.

What a node is called: a button's text, an image's alt, a field's label, or an aria-label.

One of the methods behind a property: get runs when the property is read, set runs when it is written.

Atomicity (all or nothing), Consistency (valid state to valid state), Isolation (no one sees half-done work) and Durability (committed changes survive crashes).

Atomicity, Consistency, Isolation, Durability: the four promises of a transaction (Haerder and Reuter, 1983).

Acknowledgement: a tiny frame the receiver sends 10 µs (in 2.4 GHz) after a data frame to say it arrived. No ACK means send again.

The next byte number the receiver expects, which also means it has every byte before it (a cumulative ACK).

The consumer's signal that it has finished a message; only then does the queue delete it.

A reply saying "I got it". TCP uses them to resend lost data; UDP sends none.

Access control list: an ordered list of permit and deny rules a router or layer 3 switch checks for each packet; first match wins.

Access control list: an ordered list of allow and deny rules. A plain ACL is stateless: it judges each packet on its own.

A ready-made .NET delegate type for methods that take no parameters and return nothing (void).

Shell commands that put a venv's bin folder first in PATH (and add (.venv) to the prompt), and undo that again.

An op-amp with resistors and capacitors around it that passes some frequencies and blocks others.

An input that does its job when it is 0 rather than 1, marked with a bar over its name (S̄, R̄).

Authenticated data: a bit the resolver sets in its reply when the answer passed DNSSEC validation.

A small wrapper that gives an object the interface its caller expects, like a travel plug.

Choosing each next segment's quality from the measured throughput and the buffer level.

Analog-to-digital converter: turns a voltage into a number, for example 0 to 1023 for 10 bits.

The number of a box in memory. The CPU asks for box 0, box 1, and so on.

The number of a place in memory. Every byte has one; an object's address is the address of its first byte.

The range of addresses a DHCP server may lend out, here 192.168.1.100 to 192.168.1.199.

A GCC and Clang feature (-fsanitize=address) that checks memory accesses while the program runs and reports bad ones.

Two neighbours that have synchronised their maps and now exchange updates (state Full).

For each vertex, a list of its neighbours. Its size grows with the number of edges.

A grid with a row and a column per vertex; a cell says whether (or how strongly) two vertices are joined. It always has V × V cells.

A trust score for where a route came from (Cisco defaults: connected 0, static 1, OSPF 110). Lower wins, for the same prefix only.

A trust score for routes to the same destination (0 to 255). Lower wins; connected 0 and static 1 on Cisco routers.

Short broadcast packets on channels 37, 38 and 39 that say a device is there and can be connected to.

A function that turns many values into one, such as COUNT, SUM, AVG, MIN or MAX.

How long a row stays in the table without a new frame from that MAC; 300 seconds by default.

Additive increase, multiplicative decrease: add a little each round trip, halve on loss. It produces the sawtooth and shares a link fairly.

A standard function such as std::find, std::sort or std::count that works on a range of iterators, not on a particular container.

One of two or more names that refer to the same object. A change made through one shows through the others.

Another name for the same thing. A reference is an alias for the object it is bound to.

Making a new object on the managed heap. The garbage collector must later clean up every allocation.

The tunnel addresses a peer may send from, and the addresses that get sent to it.

The text alternative of an image: read aloud by screen readers and shown if the picture cannot load.

The bar |, meaning or: cat|dog matches either word, trying the left one first.

The arithmetic logic unit: the part of a CPU that adds, subtracts and does logic on its two inputs.

Arithmetic logic unit: the part of a CPU that does arithmetic, such as adding and subtracting, and logic, such as AND and OR, on binary numbers.

Arithmetic logic unit: the circuit that adds, subtracts and does logic on two inputs.

A block that runs at every rising edge of clk, the moment the clock goes from 0 to 1. Values saved in it become flip-flops.

Speed-up on n cores = 1 / ((1 − p) + p / n), where p is the part of the work that can run in parallel; the serial part sets the limit.

Access and Mobility Management Function: handles registration and keeps track of where each phone is.

Constant on average over many calls, even though a few calls (here the ones that grow the vector) take longer.

Sending a small request that triggers a much bigger reply, so each attacking packet turns into more traffic at the victim.

The signed number in front of |0⟩ or |1⟩. Square it to get a probability; amplitudes can cancel or add up.

A pattern part that matches a position, not a character: ^ for the start of the string, $ for the end.

AND gives 1 only if all inputs are 1; OR gives 1 if any input is 1; NOT gives the opposite of its one input.

Combine bools: and is True only if both sides are True, or if at least one is, and not flips True and False.

The animation property plays a named @keyframes over a duration, without waiting for a change.

The negative electrode of a cell while it discharges. In a lithium-ion cell it is graphite that holds the lithium when the cell is charged.

The two ends of a diode. Current flows from anode (p side) to cathode (n side); the cathode is marked with a band.

Flagging behaviour that is far from a normal baseline, such as one source touching many ports in seconds.

A conductor sized to the wave that turns a radio-frequency current into a radio wave, and back.

A special type that switches the check off for a variable. An escape hatch to avoid while learning.

A type that turns checking off for a value. A parameter with no annotation becomes any.

A type that turns type checking off for a value. Anything is allowed, so mistakes are not caught.

A type that means could be anything: TypeScript stops checking a value whose type is any.

A type that switches checking off: any value fits, and any use of it is allowed.

Announcing the same address from many sites, so each packet goes to the nearest one and a flood is split between them.

Announcing the same address from many sites, so routing delivers each packet to the nearest one (RFC 4786).

Application programming interface: the requests a program accepts from other programs, and the answers it gives.

Application programming interface: the list of requests a service accepts and what each returns, such as POST /urls and GET / .

The set of requests a server agrees to answer, such as GET /messages, usually replying with JSON.

The states an app moves through: foreground (on screen), background, suspended (in memory, not running) and not running.

A program that runs the back-end code for each request, such as a Python function, and builds the answer.

A method that adds nodes after the last child of an element.

A list method that adds one item to the end of the list.

A list method that adds one item to the end of a list; a comprehension does this for every kept item.

A review decision that says the change is ready to merge.

Debian's high-level package tool: it reads the package lists, works out dependencies, downloads .deb files and calls dpkg.

A value passed in a call, such as 3 and 4 in area(3, 4).

A value passed in a call, such as 3 in total(3, 4).

The actual value passed in a call, like 3 in area(3, 4). Arguments fill parameters in order.

The actual value handed to a function in a call, such as [8, 6, 10].

A value passed in a call, such as "tea" in order("tea").

The value you pass in a call, such as 3 in area(3, 4). For an int parameter it is copied into the parameter.

The value you pass in a call, such as 2 and 3 in Add(2, 3). By default it is copied into the parameter.

A word after the command name that gives the command extra information, such as which files to use.

Accessible Rich Internet Applications: attributes such as role, aria-label and aria-expanded that edit the accessibility tree. They do not change looks or behaviour.

$(( expression )): Bash works out the sum (whole numbers only) and puts the answer in its place.

Address Resolution Protocol (RFC 826): finds the MAC address that belongs to an IP address on the local network.

Address Resolution Protocol: asks the LAN “who has this IP?” and the owner replies with its MAC address.

A computer's short-lived table of IP-to-MAC pairs it has learned recently.

On a local network, falsely claiming another device's IP address (such as the router's) so its traffic is sent to you. It puts an attacker on the path, where it can read queries instead of guessing.

The three parts of a test: set up the inputs, call the code under test, check the result.

A block of memory split into equal-sized slots that sit side by side. A Python list is built on one, and can grow.

One value that holds a list of values, in order. Written with square brackets: ["apple", "pear"].

A list of values kept in order, written with square brackets, such as [10, 20, 30].

A fixed number of values of one type, stored side by side in one block of memory, such as int a[4].

A fixed number of elements of one type stored side by side in memory, such as int a[3].

A list type such as number[] (also written Array ): every item must be a number.

How many items enter the system per unit of time, averaged over a long time. λ is the Greek letter lambda.

The average number of arrivals per unit of time, such as 4 requests per second. λ is the Greek letter lambda.

How many customers arrive per second on average. The mean gap between arrivals is 1 ÷ λ.

The average number of packets that arrive per second.

When the new value reaches the end of a path: the sum of the clock-to-Q delay and every gate and wire delay on the way.

A short function written () => ... . It has no this of its own and uses the this of the code around it.

The broad goal of getting machines to do tasks that seem to need intelligence, such as understanding speech or sorting email.

In except ZeroDivisionError as err , gives the caught exception object a name so the handler can use it.

A number that identifies a routing domain to BGP. In RFC 7938 fabrics all spines share one and every leaf has its own, from the private range.

The number that identifies an AS in BGP. Numbers 64496 to 64511 are reserved for examples like this lesson.

The list of AS numbers an announcement has passed through, newest first. Used to spot loops and to compare routes.

An old table that gives 128 characters (English letters, digits, signs and control codes) the numbers 0 to 127. A is 65.

Application-specific integrated circuit: a chip designed for one job and made in a factory, unlike an FPGA, which is rewired after it is made.

The .NET framework for building web apps and web APIs; minimal APIs are its shortest way to write endpoints.

A program that turns assembly into machine code, filling in the address of every label.

The file the compiler writes, such as Hello.dll: IL plus metadata that describes its types and methods.

A program written one instruction per line with short names (mnemonics) such as LDI and ADD, meant for people to read.

A statement that does nothing when its condition is True and raises AssertionError when it is False.

A check that must be true. In Python, assert raises an AssertionError when its expression is false.

A statement that must be true at a given moment; the simulator reports an error when it is false.

A check such as assert.equal(actual, expected). It does nothing when the check holds and throws an AssertionError when it does not.

A check such as Assert.Equal(expected, actual). If it does not hold, it throws and the test fails.

The Error object an assertion throws when it fails. It carries the actual value, the expected value and the operator.

The exception a false assert raises. pytest catches it and marks the test as failed.

A continuous assignment: the wire on the left always equals the expression on the right. It describes combinational logic.

Type A is assignable to type B when every value of A is also allowed as a B.

A line like age = 30: Python works out the right side, then stores the result under the name on the left.

Storing a new value in an existing variable with =, as in age = age + 1;. The old value is replaced.

Stores the value on the right into the variable on the left. It does not mean "is equal to".

Stores the value on the right in the variable on the left. It does not compare.

The statement name = value. Python works out the right side first, then ties the name on the left to the result.

The step where a device asks to join an access point and is given an association ID (AID). After it, the AP forwards the device's frames.

A script attribute: download in parallel and run as soon as the file is available, in whatever order the files arrive.

A modifier that lets a method use await. An async method usually returns Task or Task ; without any await it runs synchronously (warning CS1998).

A function declared with async. Calling it returns a promise, which its return value fulfils (or an error it throws rejects).

Code that can start a slow operation, such as a download, and do other work while it waits instead of standing still.

Creates a new event loop, runs the given coroutine as a task until it finishes, then closes the loop. The usual entry point of an asyncio program.

A promise that every message is delivered, possibly more than once (for example after a crash before the ack).

Indivisible: an atomic operation happens all at once, so no other thread can see it half done. std::atomic makes ++ atomic.

Extra information inside an opening tag, written name="value", such as href="about.html" on a link.

A name stored on an object, read and written with a dot: c.count.

A name stored inside an object, such as n in self.n = n. Each object keeps its own attributes.

One fact about an entity, such as a book's title. It becomes a column.

Proving who you are (a password, a security key, a certificate). Authorisation then decides what you may do.

Checking who someone is, for example by a password, and on later requests by a session cookie.

Holds a domain's zone and gives the final answer, marked AA.

Deciding what an authenticated user may do, such as reading only their own messages. Always checked on the server.

A file on the server, ~/.ssh/authorized_keys, listing the public keys allowed to log in as that user, one per line.

A property written { get; set; } with no bodies; the compiler writes the backing field and both accessors.

How the browser puts items with no position of their own into the next free cells, in source order.

An editor suggesting names, parameters and types as you type, using what the types say.

How local variables are stored, usually on the stack: memory is set aside when the block is entered and given back when it ends.

The C++ standard's name for how local variables live: created when their block starts, destroyed automatically when it ends.

A network run by one organisation with one routing policy, such as an ISP, a cloud provider or a university.

The service works when it is needed: not crashed, switched off or flooded.

The typical step count over many inputs. A Python dict lookup is O(1) on average but O(n) in the rare worst case.

Marks where a coroutine may pause until something it needs, such as data from the network, is ready.

Pauses the async function it is in until a promise settles, then gives back the fulfilled value (or throws the rejection reason).

Inside an async function, pauses that function until a promise settles, then gives back its value (or throws its error).

Waits for an awaitable (a coroutine, Task or future). While it waits, the current task is suspended and the event loop can run other tasks.

Waits for a task without blocking the thread: if the task is unfinished, the method saves its place and returns; when the task completes, the method resumes and await gives back the result.

The C# keyword that pauses an async method until a task finishes. The method's state may move to the heap while it waits, so a span cannot be held across it.

A small language for working with fields: it splits each line into $1, $2, ... and runs your program once per line.

A shallow tree of sorted nodes used by most databases for indexes. Each level narrows the search, so a lookup takes about log n steps.

PostgreSQL's default index type: sorted leaf pages of entries, linked to their neighbours, under inner and root pages of separator keys.

A balanced tree of pages that keeps keys sorted; PostgreSQL's default index type. Database B-trees are usually B+-trees: all keys live in the leaves.

The part that runs on servers: the code that handles requests and the database that keeps the data.

A quick calculation with rounded assumptions (requests per second, storage per year) to see how big a system must be.

The link, usually fibre, that connects a base station to the operator's core network.

The private field a property stores its data in. For an auto-property the compiler creates a hidden one.

The server's limited queue of half-open connections. When it is full, new SYNs are dropped.

An ordered list of the work still to do. The most valuable item sits on top.

When a guess fails, the engine goes back to its last choice (for example, giving back a character a quantifier took) and tries another way.

A copy of the data from the past that you can go back to.

How many bits per second a link can carry, for example 1 Gb/s.

The width of the range of frequencies a signal uses, such as a 20 MHz Wi-Fi channel.

An independent grid of cells inside a DRAM chip, with its own rows and sense amplifiers. DDR4 chips have 8 or 16.

How many digits a number system has, and how much each place grows: 10 for decimal, 2 for binary, 16 for hex.

Writing a number with 62 symbols (0-9, a-z, A-Z). Seven base 62 characters can name about 3.5 trillion different values.

A copy of all of a server's data files, taken while it runs, for example with pg_basebackup. Recovery starts from it.

The input small enough to answer directly, without another call. It is what stops the recursion.

An answer known without any work, such as fib(0) = 0 and fib(1) = 1, or 0 coins to make 0.

The class another class is built on. Animal is the base class of Dog.

The class another class inherits from, such as Shape. It holds the members its derived classes share. Every class ultimately derives from object.

The class named in brackets, as Animal in class Dog(Animal). Also called superclass.

The radio equipment at a cell tower: an eNodeB in 4G (LTE), a gNodeB in 5G (NR).

How many symbols a line sends per second. For UART each symbol is one bit, so 115200 baud is 115200 bits per second, even when several bits in a row are the same and the line does not change.

Binary-coded decimal: one decimal digit, 0 to 9, written as a 4-bit binary number.

Best Current Practice 38 (RFC 2827): networks drop outgoing packets whose source address does not belong to them.

A short broadcast frame an access point sends about ten times a second to announce its network name, channel and security.

Member functions that return iterators to the first element and to the position just past the last one.

Block, Element, Modifier: a naming method for classes, such as card, card__title and card--sale, so each part is styled with one class.

A satellite that simply repeats the signal from one side to the other, without routing packets itself.

Border Gateway Protocol, version 4: how ASes tell each other which address blocks they can reach.

Border Gateway Protocol: how networks tell each other which address blocks they can reach, and withdraw them.

Announcing addresses you do not hold, by mistake or on purpose, so that other networks send that traffic to you.

A way to describe how the number of steps grows as n grows, keeping only the fastest-growing part and ignoring constant factors.

Counting with only the digits 0 and 1. Each place is worth twice the one to its right: 1, 2, 4, 8, 16, 32, 64, 128.

Counting in base 2. Each place is worth double the one to its right: 1, 2, 4, 8, 16 and so on.

Searching a sorted list by comparing with the middle item and throwing away the half that cannot contain the target. O(log n).

A binary tree where, at every node, the left subtree holds only smaller values and the right subtree only larger ones.

A method every function has: fn.bind(x) returns a new function whose this is locked to x for good. It does not run fn.

To attach a reference to its object. It happens once, when the reference is made, and never changes.

A name joined to a value, such as count holding 0. let bindings can change; an import binding cannot be assigned by the importer.

DHCP snooping's list of leases: MAC address, IP address, port, VLAN and lease time.

Python's built-in module for binary search on sorted lists; bisect_left(a, x) returns where x is or would go.

The smallest piece of data: a single 1 or 0.

The smallest piece of data: a single 0 or 1.

A binary digit: 0 or 1. An IPv4 address is 32 bits long.

The smallest piece of data a computer stores: a 0 or a 1.

Short for binary digit: a single 0 or 1. In a chip it is a wire near 0 V (0) or near the supply voltage (1).

One binary digit: 0 or 1. In a circuit it is a low or high voltage, off or on.

One binary digit: 0 or 1. In a circuit, a low or a high voltage; here a dark or a glowing lamp.

A binary digit, 0 or 1. In hardware it is one of two states, such as a low or high voltage.

A pair of wires, BL and BL̄, down a column. Data is read from and written to the cells through them.

How many bits per second a video uses. Higher bitrate means more detail and bigger segments.

The file that holds every configuration bit for one design; loading it sets up the FPGA.

Combining two bit patterns so a bit is 1 only where both are 1. Address AND mask gives the network address.

A write-up after an incident that records what happened, its impact, why the system allowed it, and fixes, without blaming people.

Bluetooth Low Energy: 40 channels of 2 MHz, short bursts, very low power. Used by watches, keyboards and sensors.

The group of lines that belong together under a line ending in a colon, marked by being indented the same amount.

The unit flash erases at once, made of many pages (for example 64). After an erase every bit is 1.

The lines between curly braces { and }. An if runs its block only when its condition is true.

The indented lines after a line that ends with a colon. They run, or are skipped, together.

A box that starts on a new line and, with width: auto, fills the full width of its container. h1 and p are block by default.

Storage the kernel reads and writes in fixed-size blocks, such as a disk (/dev/sda) or one of its partitions (/dev/sda1).

An element that starts on a new line and takes the full width available, such as a heading, a paragraph or a list.

A fixed memory block built into the FPGA fabric; on AMD 7 series chips each holds 36 Kb.

Holding the thread so nothing else can run, as a long calculation or time.sleep() does.

Making a thread stop and wait, doing nothing, for example by reading .Result before a task is done. await waits without blocking.

A call that arrives when every line is busy and is turned away. Its probability is the grade of service, such as 1%.

The part of the page that holds everything you see: headings, paragraphs, links, images.

The lines between the loop's curly braces { }: what runs in every round.

The indented lines under the for or while line: the part that repeats.

The verdict for data whose signatures do not check out. A validating resolver throws it away and never caches it.

Repetitive code that must be written but says little, such as an __init__ that only copies its arguments.

A value that is either True or False.

Python's type for yes-or-no answers. It has only two values, True and False. A condition such as age < 13 works out to a bool.

The type with exactly two values, True and False. Every comparison gives a bool.

The C++ type with exactly two values, true and false. Comparisons such as > and == give a bool.

The C# type with exactly two values, true and false. Comparisons such as > and == give a bool, and every if or while condition must be one.

A type with only two values, true and false, used for yes-or-no questions and decisions.

A value that is either true or false. Every comparison gives one.

The type with only two values: true and false.

Algebra on 0 and 1 with AND (written · or nothing), OR (+) and NOT (written ', so D' is NOT D).

An attribute with no value, such as controls: being present switches it on, leaving it out switches it off.

A value that is only true or false, named after George Boole. Computers store it as 1 (true) or 0 (false).

A small program that loads the kernel and the initramfs into memory, gives the kernel its command line, and jumps to it.

A line drawn around the padding. It has a width, a style (such as solid) and a colour.

A router at the edge of a Thread mesh that forwards IPv6 packets to and from the home Wi-Fi or Ethernet network.

Many hacked devices, often computers, cameras and home routers, controlled remotely by one attacker.

The slowest link on a path. It decides how fast the whole path can go, and its queue is where packets wait or are dropped.

A PTP switch that syncs to the grandmaster on one port and acts as master for the devices on its other ports.

A JTAG feature (it needs TDI and TDO, so SWD cannot do it) that puts a test cell at every signal pin so a tester can drive and read the pins without running code, finding opens and shorts.

A test that an index is valid before it is used. Built-in arrays have none; std::array::at and std::vector::at do.

The rectangle the browser makes for an element. Layout is deciding where the boxes go.

The way CSS lays out every element: a rectangle made of content, padding, border and margin.

Decides what width and height measure: the content only (content-box, the default) or everything up to the outside of the border (border-box).

Wrapping a value type such as int inside an object on the heap. Generic code with a value type argument avoids it.

Copying a value (such as a struct) into a new object on the heap so it can be treated as an object. A ref struct is never allowed to be boxed.

Bridge Protocol Data Unit: the small message switches use to share bridge IDs and path costs, every 2 seconds by default.

Reading or writing a property whose name is the result of an expression, as in cat[key] or cat["fur colour"].

A movable name that points at one commit. Committing on a branch moves it forward to the new commit.

One of the separate paths in a parallel circuit.

Guessing whether a jump will be taken so fetch can carry on; a wrong guess is flushed.

A repository rule, for example: main only accepts pull requests with an approval and passing checks.

Explores level by level with a queue; finds the fewest edges from the start in an unweighted graph.

A statement that ends the loop it is in at once.

A marked line where a debugger pauses the program so you can inspect the variables.

A width at which the layout changes, because a media query starts or stops applying.

A switch's spanning tree ID: a priority (32768 by default) followed by its MAC address. Lowest wins.

Switching on a newly built board for the first time and getting it working, stage by stage: power, clocks, code.

The address ff:ff:ff:ff:ff:ff (all 48 bits set). Every card on the segment keeps a broadcast frame.

A frame sent to ff:ff:ff:ff:ff:ff, meant for every device on the local network. ARP questions use it.

A frame sent to ff:ff:ff:ff:ff:ff, which every device on the local network receives.

A message to every device on the local network. In IPv4 the address 255.255.255.255 means 'everyone here'.

The address with every host bit set to 1. A message sent to it reaches every device on the subnet.

The set of devices a broadcast frame (to ff:ff:ff:ff:ff:ff) reaches. Each VLAN is one broadcast domain.

Broadcasts circling a loop and multiplying until they fill the links and swamp every device.

The program that reads HTML files and draws the pages they describe, such as Chrome, Firefox, Safari or Edge.

An empty slot (a no-op) that travels through the pipeline during a stall or after a flush and changes nothing.

The last part of the trip, from the target back up through its ancestors. Most events, including click, bubble.

A switching regulator that steps a voltage down by switching it fully on and off and smoothing the pulses with an inductor and a capacitor.

One slot in a hash table. Keys whose hash codes give the same remainder share a bucket.

Video the player has already downloaded but not yet shown. It lets playback continue while the network wobbles.

Memory where a file object collects written text before sending it to the disk in one go, when the buffer fills, on flush() or on close.

The editor's working copy of a file, kept in memory. You change the buffer; saving copies it to the disk.

Too much buffering for a link's speed: under load the queue grows long and adds large delay before any packet is dropped, so TCP's signal to slow down comes late.

Too much buffering for a link's speed: when the link is overloaded the queue grows long and adds large delay before any packet is dropped.

A mistake in a program that makes it fail or give a wrong result.

Every output file and the files it is made from. The build tool uses it to choose the order and to skip files that are up to date.

The files CMake writes (Makefiles or build.ninja) that a build tool such as make or Ninja follows to run the compiler.

A CMake setting (Debug, Release, RelWithDebInfo, MinSizeRel) that picks the compiler's optimisation and debug flags.

Error types the engine throws itself, such as TypeError, ReferenceError, SyntaxError and RangeError.

A command the shell runs itself, without starting a program from the disk. cd, echo and type are builtins in bash.

Every device taps into one shared cable. Simple, but one break stops everything and only one device can send at a time.

Shared wires that connect the caches; what one cache sends, all the others can see.

A group of 8 bits. The letter A is one byte: 01000001.

Eight bits in a row. One byte has 256 patterns, so it can hold a whole number from 0 to 255.

A small unit of memory: 8 bits. Memory addresses count bytes, so a slot of 8 bytes moves the address on by 8.

A group of eight bits. It has 256 patterns, enough for the numbers 0 to 255.

The unit of memory size: 8 bits, each a 0 or a 1. sizeof tells you how many bytes a type uses.

A group of 8 bits. It can hold 256 patterns, the numbers 0 to 255.

Simple instructions made by CPython from your file, run by the Python virtual machine rather than by the CPU.

Simple instructions for a virtual machine instead of a real chip. CPython's bytecode is shown by the dis module and cached in .pyc files.

The small, simple instructions CPython compiles your source into. It is an implementation detail and changes between Python versions.

Current compared with capacity. 1C would empty a full cell in about an hour; 2C in about half an hour.

A modern, type-safe programming language from Microsoft, standardised as ECMA-334. Say "see sharp".

A rating such as Cat5e, Cat6 or Cat6a that says how fast a cable can carry data, and how far.

A small, fast store that keeps copies of answers that are slow or costly to get again.

A small, fast store kept in memory (RAM) that holds copies of popular data. A hit finds the data there; a miss does not.

A small, fast memory that keeps copies of data used recently, so the next use does not have to wait for slower memory.

A small, fast memory (SRAM) beside the CPU that keeps copies of recently used parts of main memory.

A small, fast memory next to the CPU that keeps copies of recently used memory.

Keeping every cached copy of the same memory address in agreement, so no core reads a stale value.

A hit is answered from a stored copy; a miss has to fetch the file from the origin first.

A hit finds the copy in the cache; a miss does not, so the answer must come from the slower source.

The block of data a cache moves at a time, usually 64 bytes, so the neighbours of a value come along with it.

The block of neighbouring bytes a cache copies as one unit: 64 bytes on most Intel and AMD chips, 16 in the figure.

The unit the cache moves to and from main memory: 64 bytes on current Intel and AMD chips.

A read whose data is not in the cache, so it must be fetched from a slower level or from main memory.

Getting a resolver to store a false record, so it then hands the wrong answer to everyone who asks until the record's TTL expires.

A pattern where the app checks the cache first and, on a miss, loads from the database and puts a copy in the cache itself.

Running a function by writing its name with brackets, such as area(3, 4). Python jumps into the function, then comes back.

Running a function by writing its name followed by brackets and arguments, as in total(3, 4).

A method every function has: fn.call(x, ...args) runs fn once with this set to x. apply does the same with the arguments in an array.

Running a function: its name followed by brackets holding the arguments, such as average([8, 6, 10]).

Running a function by writing its name and arguments, area(3, 4). The caller pauses until the function returns.

The working space Python makes for one call, holding its local variables. It is cleared when the call ends.

The scratch space Python makes for one call of a function, holding that call's own variables, like n.

The scratch space a call gets for its local variables; the ECMAScript specification calls it an execution context. It is removed when the call returns.

The stack Python keeps of the functions currently running: a call pushes a frame, a return pops it.

The pile of frames for calls still running. The newest is on top, and it is the first to finish.

The pile of frames for the calls that are running now. The newest call is on top; frames are popped in last-in, first-out order.

The pile of calls that have not finished yet, one frame per call. A call pushes a frame; a return or a throw pops it.

The pile of function calls that are running right now. A call pushes a frame on top; when it returns, the frame comes off.

The engine's list of functions that are running now. The one on top runs; a paused async function is not on it.

The pile of frames for the calls that are running right now, newest on top.

The memory a running program uses for the functions that are currently running: one frame per call, newest on top.

Memory for running methods. Each call gets a frame on top, holding its parameters and locals; it is removed when the call returns.

The list of method calls that have not finished yet. Each call has a frame holding its parameters and locals; the newest is on top.

A function you pass to other code so it can be called later, for example when a download finishes.

A function you hand to something else to run later, such as the arrow function given to setTimeout or .then.

A function you pass to other code, which calls it later, such as the arrow function given to setTimeout or .then.

The usual way to write JavaScript names with several words: first word lower case, then a capital for each new word, as in maxLives.

Campus area network: the LANs of several buildings, such as a school or company site, joined by the organisation's own fibre.

Two metal plates with a thin insulator between them. It stores electric charge.

A tiny store of electric charge. In a DRAM cell, full stands for 1 and empty for 0.

How many slots a list has room for. It can be more than its length, so appends can use the spare room.

How many elements a vector's current block can hold before it must grow (v.capacity()).

How much charge a cell holds. 3000 mAh means 3000 milliamps for one hour, or 300 milliamps for ten hours.

[x]: the closure stores its own copy of x, made when the lambda expression is evaluated.

[&x]: the closure refers to the original x, so it sees later changes, and must not be used after x is gone.

The square brackets at the start of a lambda. They name the variables from around the lambda that it may use.

The first part of an event's trip, from the top of the DOM tree down to the target.

A local variable from outside a lambda that the lambda uses. The lambda shares the variable itself, not a copy of its value.

How many things on each side of a relationship: one-to-one (1:1), one-to-many (1:N) or many-to-many (M:N).

A range such as ^2.1.3 that allows newer minor and patch versions (from 2.1.3 up to, not including, 3.0.0).

The traffic actually served: A × (1 − B). Divided by c it gives each line's utilisation.

A large telecom company that owns long-distance links and rents capacity on them to others.

The bit that moves one column to the left when a column's sum is too big for one digit, as in 1 + 1 = 10.

The extra 1 a column passes to the next column on its left when its total is 2 or 3.

The carry arriving from the column to the right, added in along with A and B.

The carry a full adder sends on to the column to its left.

The carry bit going into a full adder from the column on its right, and the one it sends to the column on its left.

A faster adder design that works out all the carries together from the input bits instead of passing them along one stage at a time.

The browser's method for choosing one value when several declarations set the same property on the same element.

The browser's way of picking one value when several declarations set the same property on the same element.

A named group of styles made with @layer. Layers are ordered by first mention, and a later layer beats an earlier one before specificity is compared.

Capital and small letters count as different, so score, Score and SCORE are three different names.

Code that converts a value to another type, such as (int)box.Value. A wrong cast throws an InvalidCastException at run time.

A pattern, usually with a repeat inside a repeat, that has so many ways to fail that the engine runs for a very long time. On untrusted input it is an attack called ReDoS.

The positive electrode while the cell discharges. In a lithium-ion cell it is a lithium metal oxide that takes the lithium back in.

Content delivery network: cache servers near viewers that keep copies of popular files, such as video segments.

Content delivery network: many edge servers in different places that keep copies of websites' files close to visitors.

Content delivery network: servers spread around the world that keep copies of a site's files near its users.

Content delivery network: servers in many places, close to users, that answer with cached copies of responses.

The area one tower's antennas cover. A mobile network is a patchwork of cells.

The device that starts a connection and sets its timing, usually the phone or computer.

The server's certificate plus the intermediate that signed it, leading up to a root CA the browser already trusts.

Control group: a set of processes whose CPU, memory and I/O use the kernel counts and can limit. Version 2 is a tree of folders at /sys/fs/cgroup.

A slice of a band that one network uses. In 2.4 GHz, channels 1, 6 and 11 do not overlap.

A slice of a radio band that one network uses. In 2.4 GHz the channels are 5 MHz apart but about 20 MHz wide, so neighbours overlap.

A thin conducting layer that forms under the gate when the gate voltage is high enough, joining source and drain.

char holds one character in single quotes, such as 'A' (always 1 byte); bool holds true or false (usually 1 byte).

One letter, digit, space or symbol in a string. In Python each character is one Unicode code point.

One letter, digit, space or symbol in a string. Reading one, as in name[0], gives a string of length 1.

A set of characters that one position may match: [a-z], [0-9], or shorthands such as \d (digit), \w (letter, digit or underscore) and \s (whitespace).

The rule for turning a file's bytes into letters. Web pages use UTF-8, set with .

The rule that turns bytes into characters. Web pages should use UTF-8, where each ASCII character is one byte.

The code that turns bytes into letters. UTF-8 is the one HTML uses; declares it.

The ratio of voltage to current in a wave travelling along a line, set by trace width, height and board material; often 50 ohms.

A rule with a test, such as year > 0, that every row must pass (true or NULL).

A rule on a column or table, such as CHECK (bal >= 0), that every row must satisfy; a statement that would break it fails.

A point where every dirty page has been written to disk and a checkpoint record is logged. Crash recovery replays from here.

A 16-bit check value over the header, data and IP addresses that lets the receiver spot damaged bits.

The command that changes a file's mode, by letters (g+w) or by number (660). Only the owner or root may use it on a file.

A command that gives a file execute permission, so you can run it as ./name.

A server that runs the tests on every push and blocks changes when the exit code is not 0.

Automated checks, such as tests, that run on every push to the pull request.

The three goals for data and systems: confidentiality (only the right people read it), integrity (only allowed changes) and availability (it works when needed).

The encryption and hash pair used after the handshake, here TLS_AES_128_GCM_SHA256.

A closed loop that charge can flow all the way round. A gap anywhere stops the current everywhere.

Code that stops calling a failing service for a while (open), then lets a test call through (half-open) before closing again.

The glass around the core, 125 µm across, with a slightly lower refractive index so light stays in the core.

A blueprint, written with class Name:, that describes what its objects hold and what they can do.

A neat syntax for a constructor function plus a prototype object that holds its methods. typeof a class is "function".

A blueprint that describes the fields and methods every object made from it will have.

A blueprint for objects. Running a class statement builds a class object that holds the methods defined inside it.

A type you define: data members plus the member functions that work on them. class Tally { ... }; is one.

A blueprint and a type: it declares the fields every object of that type has and the methods (and constructors) that work on them.

An HTML label you can put on any number of elements: class="new". One element can have several classes, separated by spaces.

A dot and a class name, such as .new. It matches every element whose class attribute contains that word.

A selector that starts with a dot, such as .note. It matches every element whose class attribute includes note.

A template that makes classes, such as std::vector or std::unique_ptr .

The original Bluetooth: 79 channels of 1 MHz and a steady stream. Often used for audio.

A without type="module". With src and no async or defer, it stops the parser until it has downloaded and run.

Sorting packets into classes by their headers (addresses, ports, protocol), then writing the class into the packet so later routers can read it.

An element's list of classes. classList.add puts a class on it, so CSS rules for that class apply.

A part of a statement that starts with a keyword, such as FROM drinks or WHERE price < 4.

Code that is easy for a person to read, understand and change: clear names, small functions, no surprises.

A signal that switches between 0 and 1 at a steady rate, so that many parts of a circuit can act in step.

A signal that flips between 0 and 1 at a steady rate; every flip-flop in a synchronous circuit updates in step with it.

One period of the clock. In a pipeline every instruction moves one stage on at each rising edge.

The instant a clock signal changes; on a rising edge it goes from 0 to 1, and flip-flops copy their input then.

The moment the clock signal changes. On a rising edge it goes from 0 to 1, and every flip-flop updates together.

How far one clock is ahead of or behind another; NTP's θ = ((t2 − t1) + (t3 − t4)) / 2.

The difference in arrival time of the same clock edge at different flip-flops.

The difference in arrival time of the same clock edge at different flip-flops. A clock tree keeps it small.

How many times a second the CPU's clock ticks, in hertz. 2.4 GHz is 2.4 billion ticks a second.

How many steps a processor takes per second, in gigahertz (GHz): billions of ticks per second.

A network of switches in stages where every switch in one stage connects to every switch in the next, described by Charles Clos in 1953. Leaf-spine is a folded Clos network.

A function together with the scope it remembers. It can keep reading and changing that scope's variables after the outer call has ended.

A function that keeps names from the function it was defined in, such as func inside wrapper, even after that function has returned.

The hidden object the compiler makes to hold captured variables, so they live as long as the delegate that uses them.

The object a lambda expression produces. You can copy it, store it in a variable and call it like a function.

The unnamed class the compiler invents for each lambda expression. Its operator() holds the lambda's body.

The part of .NET that loads assemblies, JIT-compiles IL to machine code, runs it and manages memory.

A tool that reads a project description (CMakeLists.txt) and writes a build system for your platform and compiler.

The recipe file for CMake: which targets to build, from which source files, and how they depend on each other.

Complementary MOS: circuits that pair n-channel and p-channel MOSFETs, so one is on while the other is off.

Complementary metal-oxide-semiconductor: circuits built from pairs of p-channel and n-channel MOSFETs, so one is off whenever the other is on.

Complementary MOS: the way most chips build gates, using pairs of two kinds of transistor (nMOS and pMOS).

Complementary MOS: the way most chips build gates, from pairs of nMOS transistors (on at 1) and pMOS transistors (on at 0).

Constrained Application Protocol (RFC 7252): web-style GET/PUT/POST/DELETE requests over UDP port 5683, with a 4-byte header and no broker.

A round cable with a centre wire, an insulator, a metal shield and a jacket, used for cable TV and internet.

What the compiler produces for a module or function body: the bytecode plus the local names, constants and the stack size it needs.

The number Unicode gives a character, such as 99 for c or 233 for é. ord() shows it.

Another engineer reads a change before it merges, to catch bugs, share knowledge and keep the code consistent.

The method that turns sound into bytes and back; G.711 sends 64 kb/s of sound.

Active queue management (AQM): the router drops or marks packets early to keep delay short. CoDel acts when waits stay above 5 ms for 100 ms; FQ-CoDel also gives each flow its own queue.

How closely the parts inside one module belong together. High cohesion means one module, one job.

A two-tier design for smaller sites, where one redundant pair of switches does both the distribution and the core jobs.

An object that holds many values under one name, such as List or Dictionary from System.Collections.Generic.

pytest's first phase: finding test_*.py and *_test.py files and the test functions inside them.

When two different keys pick the same slot.

A test, run during update, for whether two things touch, such as a ball reaching a wall.

Coloured bands on a resistor that give its value: two digits, a multiplier and a tolerance.

An attribute on th or td that makes the cell span that many columns, such as colspan="2".

One named fact that every row has, such as year. Every value in a column has the same type.

One named fact that every row has, with a fixed data type, such as name text. Textbooks call it an attribute.

The short reply a database such as PostgreSQL sends after a statement, such as INSERT 0 1, UPDATE 1 or DELETE 2: the command and how many rows it affected.

Text after a #. It is a note for people; Python skips it.

Text after // (to the end of the line) that the compiler ignores: a note for people reading the code.

A saved snapshot of the whole project, with an author, a time, a message and a pointer to its parent commit (every commit has one except the first).

A saved snapshot of the project, with a message and a link back to its parent commit (two parents for a merge commit).

A saved snapshot of your changes to the code, with a message saying what changed.

The command that ends a transaction and makes its changes permanent and visible to everyone.

Ends a transaction and makes all its changes permanent and visible to other sessions at once.

PostgreSQL's record of each transaction's status (in progress, committed or aborted), kept in pg_xact.

A circuit that answers 'is this voltage above that one?' with an output at one rail or the other.

An operator that compares two values and gives a bool: == (equal), != (not equal), , =.

An operator that compares two values: == (equal), != (not equal), and >=.

When tsc checks and converts the code, before the program runs. Run time is while it is running.

While the compiler is building your program from source code. Nothing has run yet.

A language whose programs are translated into machine code before they run. C++ is one.

A program that translates a whole program ahead of time, usually into a machine-code file you can run later.

A program that translates source code into another form, such as machine code (gcc, clang) or bytecode (CPython's compiler).

The tool that checks code against the rules of the language and translates it into machine code.

The program that checks your C# and turns it into IL. Roslyn is the name of the C# compiler.

One setting tsc reads, such as target, strict or outDir. They live under compilerOptions in tsconfig.json.

A part of a system with one job, such as a web app, a service or a database.

The stage that stacks the painted layers in order, applies transform and opacity, and hands the finished frame to the screen.

The browser's last rendering step: stacking the painted layers, with their transforms, into the final picture.

Building an object out of other objects held in its attributes (has-a), such as a Bank holding a list of accounts.

The final value of every property for one element, after matching the rules, the cascade and the defaults.

Joining strings end to end with +. The result is a new string.

Joining strings end to end. In JavaScript, + concatenates when either side is a string.

Joining strings end to end with +. If one side is a string, the other side is turned into text first.

A C++20 named requirement on a template parameter, such as std::totally_ordered , checked where the template is used.

Several tasks making progress by taking turns, for example two threads sharing one CPU core.

Making progress on several jobs by switching between them. asyncio is concurrent on one thread, not parallel: it switches only at await.

The test in round brackets after if, such as temp > 25. JavaScript turns its value into true or false.

A yes-or-no question in code, such as temp >= 25. Python works it out to True or False.

An expression whose answer is true or false, such as n > 0 or n == 1. if and while use one to decide what runs next.

An expression such as i <= 3 that is worked out to true or false before every round.

Code that runs only when a condition is true, written with if, else if and else.

A extends B ? X : Y: the type X if A is assignable to B, otherwise the type Y.

A material whose electrons move freely, so current flows easily. Copper has about one free electron per atom.

Only the people who should read the data can read it. Usually kept with encryption.

Devices that should match slowly becoming different, usually through manual changes and typos.

The memory cells inside the FPGA that hold the loaded bitstream; on most FPGAs it is SRAM.

The first CMake step (cmake -S . -B build): check the compiler and write the build system into the build folder.

Two or more matching rules that set the same property on the same element to different values.

More traffic heading for a link than it can carry, so packets queue up and, once the queue is full, are dropped.

The sender's limit on segments in flight (sent but not yet acknowledged). TCP raises it while things go well and cuts it on loss.

A group of vertices that can all reach one another along edges, and nothing else.

A route a router adds automatically for each network plugged into one of its working ports.

A panel in the browser's developer tools where console.log writes messages for the developer.

Write prints text and leaves the cursor on the same line; WriteLine prints text and then a line break.

Makes a variable that must get its value at once and can never be given a new one.

A promise that an object is read-only after it is initialized. Its value may be worked out at run time.

A reference you can only read through (const T&). It avoids a copy and cannot change the object.

A name for a value that does not change, written in capitals in Python, such as TAX_RATE = 0.20.

An expression the compiler can evaluate while building, needed for array sizes, static_assert and template arguments.

Working out expressions made only of constants, such as 2 * 3, at compile time instead of every time the program runs.

The step count stays the same however big n gets, as in items[5].

C++20: marks a function that must run at compile time; calling it with a run-time value is an error.

A function the compiler may run at compile time when its arguments are constant; otherwise it runs normally at run time.

A variable whose value the compiler must work out while building. It is also const.

A fixed limit on the solution that you do not get to choose, such as a deadline, a budget or a required language.

A rule on a form field, written as an attribute such as required, type="email" or min="13".

A limit on what a type parameter can be, written with extends, as in .

A rule on a type argument, written with extends: in Pick , K must be keys of T.

A rule after where that limits which types may replace T, such as where T : struct or where T : IComparable .

A rule written into a table's definition that every row must obey. The DBMS refuses any change that would break it.

A generic type with its type arguments filled in, such as Box or Box .

The function new calls to set up a new object; in a class it is the method named constructor.

The special method new runs to set up a fresh object.

A member function with the class's name and no return type. It runs when an object is made and sets it up.

A member function with the class's name and no return type. It runs automatically when an object is created and gives it a valid starting state.

A special method with the class's name and no return type. It runs once when new creates an object and gives the object a valid start.

A program that takes messages off a queue and does the job each one describes.

A running copy of an image: the app's process, kept apart from others, with a thin writable layer on top of the image.

A standard library object that holds a group of elements and owns their memory, such as std::vector, std::list or std::map.

One or more ordinary processes that the kernel isolates with namespaces and limits with cgroups. They share the host's kernel.

A packaged app plus everything it needs to run, stored as a stack of read-only layers. Built from a Dockerfile.

@container (...) { ... }: rules that apply when a test about the element's nearest query container is true.

The property that makes an element a query container. inline-size lets queries ask its width; size lets them ask its width and height.

The box an element is laid out inside, here the body's content area. A block's width: auto fills it.

The rectangle an absolute box is placed against: the padding box of its nearest positioned ancestor, or else the initial containing block.

The property that fills a ::before or ::after box, for example content: "✓ ".

The innermost part of a box, where text and images go.

A response header that tells the browser which scripts it may run, a second line of defence against XSS.

An object with __enter__ and __exit__ methods that sets something up before a with block and cleans it up afterwards.

Saving exactly where one process stopped and loading where the next one stopped, so the CPU can switch between them.

Stored side by side in one block of memory, as a std::vector stores its elements.

The rest of a method after an await. It runs when the awaited task completes.

Keeping every green build ready to release, so a person can release it at any time with one action.

Keeping every tested change ready to release at any moment. Continuous deployment goes further and releases every passing change automatically.

Releasing every change that passes the pipeline to users automatically, with no button press.

Everyone merges small changes into the shared main branch often, and an automated pipeline checks every push.

Automatically building and testing every change as soon as it is committed.

A part of a form a visitor can use, such as a text box ( ), a number box ( ) or a button.

The order in which a program's statements run. By default top to bottom; if, else and loops change it.

How tsc follows ifs, returns and other branches to know which types can reach each line.

The pipeline does not yet know which instruction comes next because a jump has not been decided.

The part of a network that decides where traffic should go: learning the map and building the tables.

The control plane (AMF, SMF, UDM) decides and signals; the user plane (UPF, gNB) carries your actual data.

A wire from the control unit to one part of the datapath, such as RegWrite (may a register change?) or ALUOp (which operation should the ALU do?).

A wire from the control unit that steers the datapath, such as RegWrite (a register may change), ALUSrc (the ALU's second input), ALUOp (what the ALU does) or PCSrc (take the jump).

The logic that reads the opcode and sets the mux selects and write enables of the datapath.

The part of a processor that reads each instruction's opcode and sets the control signals that tell the datapath what to do.

A control is a safeguard that lowers risk, from people (training), process (routines such as patching: installing the maker's updates that fix known software flaws, and making backups) or technology (filters, MFA). Defence in depth stacks several different controls, so one failure is caught by the next layer.

The direction current is drawn in: from the + end to the − end, the way positive charge would move. Electrons drift the opposite way.

Making a value of one type from another: str(5) is '5', int("42") is 42, float("1.5") is 1.5.

A small piece of text a server sets with Set-Cookie and the browser sends back with Cookie, so the site can recognise you.

A small name=value pair a server asks the browser to keep and send back with later requests to the same site.

Zigbee's three jobs: the coordinator starts the network, routers (mains-powered) relay, end devices never relay, and battery-powered ones sleep most of the time.

The constructor that makes a new object from an existing one of the same type, written T(const T&). For an owning type it makes a deep copy.

The centre of the fibre, where the light travels: about 9 µm in single-mode, 50 or 62.5 µm in multimode.

A complete processor inside a chip: it fetches and runs its own stream of instructions. A multicore chip has several.

The part of a processor that runs instructions. A CPU has a few big cores; a GPU has thousands of small ones.

One independent processor inside a CPU. Each core runs one thread at a time, so more cores means more threads at the same instant.

The fast centre of the network that carries traffic between distribution blocks, the server room and the internet, with no filtering.

The operator's central systems: they check SIMs, track where each phone is, give out addresses and connect to the internet.

A function defined with async def that can pause at await and carry on later from the same spot.

A function defined with async def. Calling it returns a coroutine object instead of running the body.

A paused computation made by calling a coroutine function. It runs only when awaited, passed to asyncio.run(), or wrapped in a Task.

A number on each link; lower is better. A path's cost is the sum of its links. By default 100 Mb/s ÷ link speed.

The planner's estimate of work, in arbitrary units where reading one page in order costs 1.0. It is not a time.

The unit of charge: the charge of about 6.24 billion billion (6.24 × 10¹⁸) electrons.

Count is how many values a list holds; Capacity is how many fit in its current array before it must grow.

Counts rows. COUNT(column) counts only the rows where that column is not NULL.

A number that only goes up, like total bytes sent; a rate comes from the difference between two readings.

A circuit that steps through numbers in order, usually adding 1 on every clock edge.

A variable, often called i, that counts the rounds and is changed by the update.

How much one module depends on the details of another. Low coupling makes changes stay local.

A bond in which two atoms share a pair of electrons, one from each atom.

A measure of how much of the design's behaviour the tests actually exercised, for example how many input cases were tried.

Central processing unit, or processor: the chip that carries out instructions, one after another.

The standard Python implementation, from python.org, written in C. It compiles code to bytecode and runs it in a virtual machine.

A method that makes a new element. It is not in the tree, and not on the page, until you add it.

The slowest path from one flip-flop to the next; it sets the shortest possible clock period and so the highest clock speed.

The slowest path through the logic between two clock edges; it sets the shortest possible clock period.

Your table of cron jobs: one line per job, five time fields and a command. Edit it with crontab -e.

The direction across the main axis. In a row it runs top to bottom.

Two gates wired so that each one's output feeds an input of the other.

Two inverters each feeding the other's input. The loop holds itself in one of two steady states: a stored bit.

One code base that builds apps for several systems, as Flutter (Dart) and React Native (JavaScript) do.

A mistake where user text is put into a web page as HTML, so the browser may run it as code. Fixed by escaping output.

Unwanted noise pushed onto one trace by fast edges on a neighbouring trace, through electric and magnetic coupling.

WireGuard's rule that ties each peer's public key to its allowed IPs, both for sending and for checking what arrives.

A circuit built around a small slice of quartz that vibrates at a very stable rate, used as the source of a clock.

Carrier Sense Multiple Access with Collision Avoidance: listen before talking, wait a random number of slots, and expect an ACK for every frame.

Cascading Style Sheets: the language that sets how HTML looks, such as colours, fonts and layout.

Cascading Style Sheets: the language that says how HTML content looks, such as colours, sizes and spacing.

The unit page layout and media queries are measured in. It is not the same as one dot on the screen.

The unit CSS widths are measured in. One CSS pixel can be several of the screen's device pixels.

CSS's basic length unit, 1/96 of a CSS inch. On a sharp screen one CSS pixel covers several device pixels.

The CSS Object Model: the browser's tree of the rules in a page's stylesheets, built by parsing the CSS.

The physical address of a stored row version (a tuple): (page number, line pointer number), such as (0,3).

NVIDIA's name for one small arithmetic lane in its GPUs. It is much simpler than a CPU core.

How much charge flows past a point each second. Measured in amperes: 1 A = 1 C/s.

A resistor in series with a part such as an LED, chosen with Ohm's law to set a safe current.

A property whose name starts with two dashes, such as --brand. It holds a value for other declarations to read and styles nothing by itself.

A property whose name starts with --, such as --brand. It is inherited and read with var(--brand).

Cybersecurity is protecting an organisation's systems, data and people from harm, such as theft, damage or disruption. Assets are the things worth protecting: data, the computers and services that hold it, and the people who use them.

A one-bit memory: at the rising edge of the clock it copies its input D to its output Q, and holds Q the rest of the time.

A program that keeps running in the background with no terminal, waiting for work, such as the cron daemon.

A pointer that still holds the address of memory that has been freed. Using it is undefined behaviour.

A reference to an object that no longer exists; using one is undefined behaviour.

An instruction needs a value that an earlier instruction still in the pipeline has not written yet, such as OUT r0 right after ADD r0, r1.

A variable inside a class; every object has its own. Tally's data member is int n.

The things a system stores (here Book, Member and Loan) and how they link to each other.

The part that forwards each packet out of the right port, very fast, by looking it up in a table. Also called the forwarding plane.

Two threads access the same memory location, at least one writes, and nothing orders the accesses. In C++ this is undefined behaviour.

The kind of value a column accepts, such as integer (whole numbers) or text. PostgreSQL refuses a value of the wrong type; SQLite stores it anyway unless the table is declared STRICT.

A program that keeps data safely on disk and finds exactly the rows you ask for, usually with SQL.

An organised store of data, kept so that many programs and people can find it, change it and trust it.

A class made with the @dataclass decorator, which writes __init__, __repr__ and __eq__ from its fields.

One self-contained UDP message: the 8-byte header plus the data. Each one travels on its own.

The part of a processor that holds and moves data: program counter, memories, register file, ALU and the multiplexers between them.

The parts that hold and change data: registers, the ALU, memory and the multiplexers between them.

Power on a decibel scale counted from 1 milliwatt: 0 dBm = 1 mW, 20 dBm = 100 mW, -30 dBm = 1 µW.

Database management system: the program (PostgreSQL, MySQL, SQLite) that stores the tables, checks every change against the schema and answers queries.

Database management system: the program that runs a database, such as PostgreSQL, MySQL or SQLite.

Distributed denial of service: the attack comes from many machines at once, so blocking one address does not help.

NOT (A AND B) = NOT A OR NOT B, and NOT (A OR B) = NOT A AND NOT B.

How long a router waits without hearing a neighbour's Hello before declaring it down: 40 seconds by default.

A row version that no running or future snapshot can see; it still takes space until VACUUM removes it.

A side queue for messages that failed too many times or cannot be handled, kept for a person to inspect.

Threads that each hold a lock and wait for a lock another one holds, so none of them can ever continue.

A tool that runs a program step by step and shows its variables. Python's built-in one is pdb; breakpoint() starts it.

The automatic conversion of a plain array into a pointer to its first element, for example when it is passed to a function. The size is lost.

One property and its value, ending with a semicolon: color: tomato;.

The line that makes a variable, such as let score = 0 or const maxLives = 3.

The line that creates a variable: the type, then the name, often with a starting value, as in int age = 30;.

A statement that introduces a name and its type, such as int square(int x); without a body. It may appear many times.

A file that holds only types: what exists and its shape, with no code to run.

When an interface is declared more than once, tsc joins the declarations into one shape.

A keyword that says something exists and its code lives elsewhere, so only its type is written.

A circuit that turns an N-bit binary number into exactly one active output line out of 2^N.

A circuit that turns a binary number into one active output line, for example 10 turns on line 2 of 4.

The loss of a qubit's quantum state as it interacts with its surroundings (heat, stray fields). Error correction fights it.

A function that takes a function or class and returns it changed. @name above a definition applies it: C = name(C).

A function that takes a function and returns a new one, usually applied with @name on the line above a def.

A small capacitor placed right next to a chip's power pins, as a local reserve of charge.

A small capacitor, often 0.1 µF, placed right next to a chip's power pin to supply quick bursts of current.

A copy that duplicates the owned memory too, so the two objects share nothing and can change independently.

The Python keyword that defines a function: def area(w, h): followed by an indented body.

The keyword that defines a function: def, the name, parameters in brackets, a colon, then an indented body.

The policy that anything not explicitly allowed is dropped, usually as an implicit last rule, deny all.

Anything no rule allows is dropped.

The router a host sends traffic to when the destination is not on its own subnet.

The router a device sends packets to when the destination is outside the local network.

The router a device sends packets to when the destination is not on its own LAN. Here 192.0.2.1.

The router a device sends every packet to that is not for its own local network.

The row 0.0.0.0/0. It matches every address, so it catches packets that no more specific row fits.

0.0.0.0/0: matches every address and is used only when no more specific route fits. Often points to the ISP.

The route used when no other matches: hand the packet to the gateway, usually your router, which leads to the internet.

A value a parameter takes when the call leaves it out, like h = w. It makes the parameter optional.

A value written in the def, such as size="S". Python works it out once, when def runs, and uses it when a call leaves that parameter out.

The value a field has before anything sets it: 0 for numbers, false for bool, null for reference types such as string.

An argument to field(): a function called to make a fresh default, such as list, for each new object.

A C++20 feature: bool operator==(const T&) const = default; makes the compiler compare the members one by one.

Several independent layers of protection, so one failure is not the end.

A script attribute: download in parallel, then run after the document is parsed, in file order, before DOMContentLoaded.

A query does nothing when it is built; it runs only when it is enumerated, for example by foreach. It runs again each time.

The declaration that also provides the entity itself, such as a function's body. A non-inline function has exactly one in a program.

An object (a reference type, on the heap) that knows which method to call (Delegate.Method) and on which object (Delegate.Target).

A type whose values are references to methods with a given shape (parameter types and return type), such as Func .

An operator that removes a property, key and value, from an object: delete cat.age.

The SQL command that removes whole rows from a table: DELETE FROM table WHERE condition.

Gives heap memory back. Use delete for memory from new, and delete[] for memory from new[].

How long the last frame took. Moving by speed × dt keeps motion the same speed at any frame rate.

The reverse of a mux: one input, several outputs. The select bits choose which output receives the input; the others stay 0.

Sorting arriving data to the right program by its port and 5-tuple.

An attack that uses up a service's resources so real users are turned away. Nothing is stolen; the service just stops.

A package your code needs. A transitive dependency is one that your dependencies need.

Something your code needs in order to run, such as a library (flask) or a particular version of Python.

A module that another module imports. Dependencies run before the modules that import them.

Another package a package needs in order to work, written in its Depends field, for example libc6 (>= 2.34).

A thin zone at the p-n junction with no free carriers. Its leftover charges block current until it is pushed thin.

A node's depth is the number of links from the root down to it. A tree's height is its largest depth.

Follows one path as far as it can, then backtracks; uses a stack or recursion.

Python's double-ended queue, from the collections module. Adding or removing at either end is fast.

Reading the element an iterator marks, written *it. Dereferencing end() is undefined behaviour.

A class built on a base class with struct Dog : Animal (or class Dog : public Animal). It inherits the base's members and can add or override its own.

A class that inherits from a base class with a colon, such as Square : Shape. It gets the base members and can add and override its own.

A named, reusable solution to a design problem that comes up again and again. A shared idea, not a piece of code to copy.

The factory's limits, such as minimum trace width, gap and hole size; the design rule check tests the layout against them.

A named design choice, such as a brand colour or a spacing step, kept in one place (often a custom property on :root) and reused everywhere.

A named design value, such as the brand colour, kept in one place and reused everywhere. In CSS it is often a custom property.

On each link, the one end nearest the root. It forwards frames onto that link.

A written description of how every device should be configured. Tools make the devices match it.

A member function named ~ plus the class name. It runs by itself when an object's lifetime ends, for a local object at the end of its scope.

The member function named ~ plus the class name, such as ~Cup(). It takes no arguments and runs automatically when an object's lifetime ends.

A special member function, written ~ClassName(), that C++ calls automatically when an object's life ends.

A short way to unpack values from an object or an array into separate variables, such as const { name } = user or const [first] = nums.

Code in the OS that knows how to control one kind of device, such as a disk or a speaker.

How many device pixels (dots of light) fit across one CSS pixel on this screen, such as 1, 2 or 3.

A way of working that joins building software (development) with running it (operations), so one team owns the whole loop and ships small changes often.

Dynamic Host Configuration Protocol: the router lends each device an address and tells it where to send things.

Dynamic Host Configuration Protocol: the way a device borrows an IP address and its network settings from a server.

A switch feature that lets DHCP server messages in only through trusted ports and records each lease it sees as a binding.

Asking a DHCP server for address after address under made-up client MACs until its pool is empty, so real devices get none.

The same idea in curly braces: {n: n * 10 for n in nums} builds a dict, {n % 2 for n in nums} a set.

A collection of key and value pairs. Each key is unique and maps to one value; lookups by key are close to O(1).

Python's built-in hash map: a collection that maps keys to values, written like {"ann": 31}.

A collection of key: value pairs, written in curly braces, such as {"Ana": 31}. You look values up by key.

The difference between two versions of the code: the lines added (+) and removed (-).

Two traces carrying opposite copies of a signal; the receiver reads the difference, so noise common to both cancels.

A part that lets current flow one way only: in at the anode, out at the cathode.

Another word for a folder: a place in the file system that holds files and other folders.

Linux's word for a folder: a list of names, each pointing to a file or to another directory.

A page in memory that has been changed but not yet written back to the file on disk.

Reading another transaction's change before it commits. PostgreSQL never allows it.

The standard-library disassembler: dis.dis(f) prints the bytecode of f.

Storage that keeps files even when the power is off. An SSD (solid-state drive) is a fast kind of disk, but still much slower than memory.

The CSS property that sets a box's type, such as block, inline, inline-block or none. Its starting value is inline.

A ready-made operating system: the Linux kernel plus a shell, commands and apps. Ubuntu, Debian and Fedora are examples.

The switches that join the access switches together, route between VLANs and apply policy such as access lists.

A generic box with no meaning of its own. Fine for grouping or styling when no semantic element fits.

A signature a sending server adds to a message, checked with a public key the domain publishes in DNS.

Direct memory access: a controller that copies data between a device and memory without the CPU, then raises one interrupt.

Demilitarised zone: a zone for public-facing servers, between the internet and the internal network.

A resolver feature (RFC 6147) that builds an AAAA record from an A record by putting the IPv4 address inside a NAT64 prefix.

A record holding a zone's public key. Resolvers use it to check the zone's signatures.

DNS Security Extensions: signatures added to DNS so a resolver can check that an answer really came from the zone owner and was not changed.

A short text recipe for building an image: start from a base image, install things, copy in the code, name the start command.

The cable data standard. A cable modem talks DOCSIS over the shared TV coax to a CMTS at the ISP.

The first line, . Not an element: it tells the browser to use today's rules (standards mode).

A store that keeps each record as one document, such as a JSON object, under a key, and can look inside it.

Document Object Model: the page as a tree of objects in the browser's memory, which scripts can read and change.

Document Object Model: the tree of nodes the browser builds from the HTML. JavaScript reads and changes the page through it.

The Document Object Model: the browser's tree of elements, built from the HTML tags.

Document Object Model: the tree of objects the browser builds from the HTML. Changing it changes the page.

An event fired when the HTML is fully parsed and all deferred scripts have run. It does not wait for async scripts, images or stylesheets.

Adding a tiny, controlled amount of another element to a semiconductor to change how well it conducts.

Discover, Offer, Request, Ack: the four messages that get a device its first address.

Four measures of software delivery from the DORA research programme: deployment frequency, lead time for changes, change failure rate and time to restore.

DNS over TLS (port 853) and DNS over HTTPS: two ways to encrypt DNS between your device and the resolver.

Reading or writing a property with a fixed name after a dot, as in cat.name.

The .NET CLI command that builds a test project, runs its tests and prints the results.

The usual way to write an IPv4 address: four numbers from 0 to 255 with dots between them.

Drawing the next frame into a hidden back buffer, then swapping it with the front buffer the screen shows.

Debian's lower-level package tool: it unpacks a .deb onto the disk and keeps the list of installed packages in /var/lib/dpkg/status.

Dynamic random-access memory: memory that stores each bit as charge on a capacitor and must be refreshed because the charge leaks.

Where the element is actually painted after its transform. getBoundingClientRect() measures its axis-aligned bounds.

Design rule check (every shape obeys the factory's width and spacing rules) and layout versus schematic (the layout is the same circuit as the netlist).

Don't repeat yourself: each rule or piece of knowledge should be written in exactly one place.

Delegation signer: a hash of a child zone's key, published and signed in the parent zone. It is how a parent vouches for its child.

Differentiated Services Code Point: 6 bits in the IPv4 or IPv6 header (RFC 2474) that carry a packet's class, such as EF 46, DF 0 or LE 1.

Digital subscriber line: data sent as high-pitched tones on the copper phone pair (ITU-T G.993.2). Ends at a DSLAM.

A fixed block for fast arithmetic such as multiply and add (DSP: digital signal processing).

Running IPv4 and IPv6 side by side on the same device or network, each with its own addresses and routes.

Short for "double underscore": the two underscores on each side of a special method's name, as in __init__ (said "dunder init").

The check a computer makes before using an address: a Neighbor Solicitation about it, sent from ::, that nobody should answer.

How long a transition or animation takes, written in seconds (0.3s) or milliseconds (300ms).

The block being tested, placed inside the testbench.

The fraction of each switching period that the switch is on. In an ideal buck converter it equals Vout / Vin.

A switch feature that checks ARP messages on untrusted ports against the binding table and drops any that do not match.

Solving a problem by breaking it into smaller questions, solving each one only once and storing the answers to build bigger ones.

Protocols such as OSPF and BGP that let routers tell each other about networks and failures, so routes adapt on their own.

A language feature where variables have no fixed type; only values do, so one variable can hold a number, then a string.

Traffic between servers inside a data center. North-south traffic goes in and out, to and from the internet.

External BGP runs between two different ASes; internal BGP shares those routes between routers inside one AS.

Ephemeral elliptic-curve Diffie–Hellman: each side mixes its private key with the other's public key to reach the same secret.

Equal-cost multipath: when several paths are equally good, use them all, picking one per flow with a hash of header fields.

Explicit Congestion Notification: routers mark packets instead of dropping them, and the sender slows down when the mark is echoed back.

A connection between two vertices, such as a road. Undirected edges work both ways; directed edges go one way.

Input at the limits of normal use, such as zero, negative numbers, empty lists or very big values.

A CDN server near visitors that answers requests from its cached copies.

Two D latches in a row on opposite clocks. Q copies D only at the clock's rising edge and holds it for the rest of the cycle.

Expedited Forwarding, DSCP value 46: a mark that asks routers to send these packets first.

A small FAT-formatted partition on the disk where UEFI firmware looks for boot loaders, such as \EFI\ubuntu\grubx64.efi.

A property of particles such as electrons (negative) and protons (positive). It is measured in coulombs (C).

The material between the electrodes that lets ions pass but blocks electrons, so the electrons must flow through the outside circuit.

A tiny particle with a negative charge of 1.602176634 × 10⁻¹⁹ C. In a metal wire, some electrons are free to move.

An opening tag, its content and its closing tag together, such as Hello! : one part of the page.

One part of a page the browser makes from an HTML tag, such as the heading made from .

One value inside an array. a[2] is the element with index 2.

Short for "else if": a further test, checked only when every test above it was False.

Short for else if: a further question, asked only when every question above it was False.

The block that runs when every test above it was False. It has no condition.

The block with no condition that runs when every test above it was false.

The catch-all at the end of a chain: its block runs only when every question above it was False.

Another test, checked only when every test above it was false. It is simply else followed by another if.

A multiple of the element's own font size (or, inside font-size itself, the parent's font size).

A length relative to a font size. In font-size, 1em is the parent's font size, so 2em is twice it.

Wrapping data in a header (and sometimes a trailer) as it goes down the layers. The receiver removes them in reverse order.

Keeping an object's data behind its methods, which check the rules. In Python a leading underscore, as in _balance, marks data as internal.

The reverse of a decoder: it turns one active input line into the binary number of that line.

An HTTP method plus a route pattern, linked to a handler, such as GET /todos → () => todos.

Enqueue adds an item at the back of a queue; dequeue removes the item at the front. With a deque: append() and popleft().

A link between qubits: measured, their results are correlated (here they always agree) even though neither qubit had a set value beforehand. Measured in other ways, the correlations are stronger than any pair of separate bits can produce.

A kind of thing you keep facts about, such as book or member. It becomes a table.

The module the program starts from, here main.js (node main.js or ).

A named set of constants, written with enum. Numeric members are numbered from 0 unless you give values.

The SMTP addresses MAIL FROM and RCPT TO that servers use for delivery, separate from the message's headers.

A named setting that programs the shell starts receive, such as HOME (your home folder) or PATH (where to look for commands).

A named setting given to a program from outside when it starts, such as DB_HOST=db.internal.

A short-lived port the operating system lends a program for one connection, usually from the dynamic range 49152–65535.

A drawing of entities, attributes and relationships, made before writing any CREATE TABLE.

The unit of traffic intensity in telephony (ITU-T E.600): arrival rate × mean holding time, the average number of busy lines.

The unit of traffic intensity: one erlang keeps one server busy all the time. A = arrival rate × mean service time (ITU-T E.600).

The unit of traffic: one line (or server) busy all the time. Offered load in erlangs = arrival rate × average holding time.

The probability that an arrival finds all servers busy when there is no waiting room, so it is lost (blocked).

B(c, A) = (A^c/c!) / Σ A^k/k! for k = 0 to c: the share of calls lost when A erlangs are offered to c lines. Computed in practice with the recursion B(k) = A·B(k−1) / (k + A·B(k−1)).

The probability that an arrival finds all c servers busy and has to wait, for a system with unlimited waiting room.

How much failure the SLO allows (100% minus the SLO). Teams ship changes while it lasts and fix reliability when it runs out.

An object made by new Error(...) or a subtype such as RangeError. It has a name, a message, and in every major engine a stack trace.

Encapsulating Security Payload (RFC 4303, IP protocol 50): the wrapper that encrypts a packet and adds an integrity tag and sequence number.

One unit of data on an Ethernet network: destination and source MAC, EtherType, payload and FCS, led by a preamble and SFD.

The envelope a packet travels in across one link. It carries a destination MAC, a source MAC and a type.

Two bytes that say what the payload is, such as 0x0800 for IPv4 or 0x0806 for ARP.

The two-byte type field in an Ethernet frame that says what is inside: 0x0806 for ARP, 0x0800 for IPv4.

Something that happens on the page, such as a click. A script can listen for it and run a function when it happens.

A signal that something happened on the page, such as a click, a key press or a form being sent.

A member that lets an object (or class) tell other code that something happened. Declared with the event keyword and a delegate type.

Handling events for many child elements with one listener on their parent, using bubbling and event.target.

A loop on one thread that runs ready tasks one at a time and resumes waiting tasks when what they wait for is done.

The host's loop that, whenever the call stack is empty, runs every waiting microtask, then takes the next task, and repeats.

The part of the runtime that, whenever the call stack is empty, picks the next job or task and runs it.

The scheduler at the heart of asyncio: on one thread it runs ready tasks one at a time and wakes parked ones when their timers or sockets are ready.

The object the browser passes to a listener, describing the event: its type, target, currentTarget and more.

The element whose listener is running right now. It is null outside a listener.

The element the event happened on. It stays the same for the whole trip.

A rogue access point that copies a real network's name (SSID) to lure devices into joining it.

Python's way of signalling an error, such as ValueError. Raising one stops the function and reports the problem.

A value thrown by throw (or by the engine) that stops normal flow until some code catches it.

An object Python raises when something goes wrong while a line runs. Its type (such as ZeroDivisionError) says what kind of problem it is, and it carries a message.

An object of a class derived from System.Exception that reports an error. It carries a Message and a StackTrace.

An error that happens while the program runs, such as NameError or ZeroDivisionError. Unless it is handled, it stops the program.

A file of machine code the operating system can load and run, such as hello (hello.exe on Windows).

The ALU produces the result (for LDI it passes the value through unchanged), and the result is stored in the destination register at the clock edge.

Exhaustive tries every input case; random picks cases at random; directed tests are chosen by hand to hit specific cases.

A number a program reports when it ends. 0 means success.

The number a program returns when it ends. 0 means success; node --test returns 1 if any test failed.

The number a program returns when it ends. pytest returns 0 when all tests passed and 1 when some failed.

A number a program hands back when it ends: 0 means success; an uncaught exception gives 1.

The number a program hands back to the system when it ends. 0 means success; main's return value sets it.

The number a program hands back to the shell when it ends: 0 means success, anything else means a failure.

A number a process leaves behind when it ends. 0 means success; anything else usually means an error.

A number a command returns when it ends: 0 for success, 1 to 255 for failure. $? holds the last one.

A command that prints the plan PostgreSQL chose for a query, with its cost and row estimates, without running it.

EXPLAIN that also runs the query and prints the real row counts (and times) next to each estimate.

Retrying after waits whose limit doubles each time, with a random wait below that limit so clients do not retry together.

The distribution of the gap between Poisson arrivals: P(gap > t) = e^(−λt), mean 1/λ. Short gaps are the most common.

A keyword that makes a name from this module available to other modules, as in export let count = 0.

Makes a name in a module available to other modules.

A program on a machine that strangers can reach over the network, such as SSH on port 22 or HTTPS on 443.

The part written first, such as n * 10: what each kept item becomes in the new list.

Builds an interface on top of another: interface Dog extends Pet { id: ID } has all of Pet's properties plus id.

Many bits of a signal overlaid on a scope; the size of the open 'eye' shows how much margin the link has.

The screw-on connector used for coax; the coax centre wire itself is its pin.

A string with an f before the quotes; code inside {braces} is worked out and its value put into the text.

Code whose job is to create objects, so the caller asks for a kind of thing instead of naming a class. The book's versions are Factory Method and Abstract Factory.

Making a standby the new primary when the old primary fails; in PostgreSQL with pg_promote() or pg_ctl promote.

The value after the comma in var(--name, fallback). It is used when the custom property has no value.

A false positive flags harmless traffic; a false negative misses a real attack.

A value that counts as false in a condition: false, 0, -0, 0n, "", null, undefined and NaN.

How many child pointers one page holds. With hundreds per page, a few levels reach millions of keys.

The unit of capacitance: how much charge a capacitor stores per volt (Q = C × V). Real parts are measured in µF (millionths) and nF (billionths).

Resending a segment as soon as three duplicate ACKs arrive, instead of waiting for the retransmission timer.

A merge where the current branch is simply behind, so Git just moves its pointer forward. No new commit is made.

Frame check sequence: a 4-byte CRC-32 code at the end of an Ethernet frame. The receiver recomputes it to spot damaged frames.

Frame check sequence: a 4-byte CRC-32 the receiver recomputes to detect damaged frames.

A feature is an input the model sees (cups bought). A label is the right answer for that example (the bill).

Wiring an output back into an input of the same circuit, so the circuit's past affects its present.

Fetch reads the instruction at PC from memory; decode splits it into opcode, registers and immediate, and the control unit turns the opcode into control signals.

The built-in function that sends an HTTP request and returns a promise for the Response. Defined by the WHATWG Fetch Standard.

A cable that carries bits as light inside thin strands of glass.

A named value stored inside each object, such as balance. In TypeScript it has a type.

A class variable with a type annotation, such as x: int, inside a dataclass. Fields are kept in the order they are written.

A variable that belongs to an object, such as N in class Box { public int N; }.

A variable that belongs to each object, such as Owner or Balance.

A variable that belongs to an object, such as int _target. Usually private.

One word of a line as awk sees it: by default, fields are separated by spaces or tabs.

Named data saved on disk. Unlike a variable, it is still there after the program ends.

A file is a named sequence of bytes kept on a disk. The extension, the end of its name such as .txt or .png, tells programs how to read the bytes.

The way a file's data is stored, usually named by the file's ending: .jpg, .png, .mp3, .mp4.

What open() returns: it remembers which file is open, in which mode, and where you are in it. Here it is named f.

The error open() raises when you ask to read a file that does not exist.

The structures written into a partition (for ext4: a superblock, inode tables and bitmaps) that keep track of files, folders and free space.

The flag that says "I have no more data to send". Each direction is closed with its own FIN and ACK.

A block after try (and catch) that always runs last, whatever happened.

A block after try (and any catch) that runs when the try statement ends, normally or after a caught exception: the place for clean-up.

A short hash of a public key (for example SHA256:…) that people can compare by eye. ssh-keygen -l prints it.

A MAC over the whole handshake that proves neither side's view of it was tampered with.

A circuit that is always in one of a fixed, small number of states and moves between them by fixed rules.

A device or program that checks every packet against rules and lets through only what the rules allow.

One line saying which traffic may cross, by source, destination and port. The first matching rule wins.

The first program the CPU runs, kept in a flash chip on the main board. It wakes the hardware and starts a boot loader. Older PCs use BIOS instead.

Every cell holds one value: no lists or repeating groups.

A function treated like any other value: stored in a name, passed as an argument, returned from another function.

Updating the world in exact, equal slices of time (such as 1/60 s), as many as the time owed, instead of once per frame.

Home internet over 4G or 5G radio from a nearby mast instead of a cable.

A 1-bit note the ALU leaves after an operation. The Z (zero) flag is 1 when the last result was 0; JZ and JNZ read it to decide whether to jump.

Non-volatile memory that keeps the program when the power is off.

A box with display: flex. It lays out its children with the flex layout rules.

A child of a flex container. Flex items line up along the main axis.

One row of items. With flex-wrap: wrap a container can have several flex lines.

How much of the free space an item takes (default 0), and how much it gives up when space runs short (default 1).

A one-bit memory. A D flip-flop copies its input to its output on the rising edge of the clock and holds it otherwise.

A one-bit memory that copies its input when the clock ticks and holds it until the next tick.

A number with a decimal point, such as 1.5 or 3.0. Stored in binary, so it can be very slightly off (0.1 + 0.2).

A conductor sealed in insulating oxide between a flash cell's control gate and its channel. Electrons placed on it stay trapped.

A backup static route with a higher administrative distance, used only when the main route disappears.

Sending a copy of a frame out of every port except the one it came in on.

Python's division that rounds down to a whole number: 23 // 2 is 11.

// divides and rounds down (7 // 2 is 3); % gives what is left over (7 % 2 is 1).

One conversation between two programs, such as your video call or the photo upload. Routers tell flows apart by addresses, ports and protocol.

One conversation between two programs, such as one file copy; its frames share the same addresses and ports.

One conversation between two programs, such as one database query; its packets share the same addresses and ports.

A summary of one conversation (addresses, ports, protocol, packets, bytes) exported by NetFlow or IPFIX.

A switch's list of rows. Each row has match fields, a priority and actions; the matching row with the highest priority is used.

Which element receives the keyboard. Tab moves focus to the next control in the order of the HTML.

The comma-separated list of fonts in font-family. The browser uses the first one it has.

The copper pads and outline for one real part package, placed on the board layout.

for n in nums: takes the items of a list one at a time, left to right, and gives each the name n.

A loop that takes the items of a sequence, such as a list or range(1, 5), one at a time.

A loop that runs its body once for each item of a sequence, such as a list, in order.

for name in list; do ... done runs the lines between do and done once for each item, with name set to that item.

A loop that visits every item of an array in order, putting each one in a variable in turn.

A column whose values must match the key of a row in another table, linking the two tables.

A column whose values must match the primary key of a row in another table, so a row can point at another row.

A column whose values must match a row of another table, such as books.author_id pointing at authors.id.

A column whose values must match a key in another table, such as books.author_id REFERENCES authors (id).

A column whose values must match a key in another table, such as orders.cust matching customers.cust.

A column whose values must match the key of a row in another table, such as book.author_id → author.id.

The two system calls a shell uses to start a program: fork makes a copy of the shell, execve loads the new program into that copy.

The element: a group of controls whose values the browser sends together to the address in its action attribute.

Connecting a diode with its p side more positive than its n side, so current can flow.

Recorded traffic stays safe even if a long-term key is stolen later, because session keys came from throwaway key pairs.

Traffic recorded today stays safe even if the long-term secret (here the password) leaks later, because each session key came from throwaway random secrets.

Sending a frame out of the single port the table says leads to its destination.

Also called bypassing: a wire that carries a fresh result straight back to the execute stage, so the next instruction need not wait for write back.

Field-programmable gate array: a chip of configurable logic blocks and wiring that you set up after it is made.

A fraction of the free space: what is left after fixed tracks and gutters. 2fr gets twice as much as 1fr.

The part of a URL after #. It names an element on the page by its id; the browser scrolls to it.

A packet plus an Ethernet header and FCS trailer: the link layer's unit.

One message on a local network (Ethernet). Its header starts with the destination MAC, then the source MAC.

One still picture made by one trip round the loop. Shown quickly one after another, frames look like motion.

One still picture of a video. Shown quickly one after another, frames look like movement.

One picture the screen draws. A 60 Hz screen draws a new frame about every 16.7 ms.

The fresh set of parameter and local values a function gets each time it is called.

The workspace Python makes for one function call, holding its variables. Calls stack frames on top of each other; an escaping exception drops them.

The workspace for one running call: its local variable slots, its value stack and which instruction runs next.

The time the browser has for each frame: about 16.7 ms on a 60 Hz screen.

A Content-Security-Policy directive a site sends to say which pages, if any, may frame it.

How many frames the game makes each second. 60 fps leaves about 16.7 ms per frame.

A function declared outside any class (also called a non-member function). Both operands arrive as ordinary parameters.

What is left of the container's main size after the items' sizes and the gaps. justify-content and flex-grow share it out.

An optional build of CPython (3.13+) that can run without the GIL (PEP 703).

How many times a wave repeats each second, measured in hertz (Hz). 1 GHz is a billion waves per second.

How many times a wave repeats each second, measured in hertz (Hz). 1 GHz is a billion times a second.

Frequency is how many clock cycles happen per second (hertz); the period is the time of one cycle. Period = 1 ÷ frequency.

Switching radio channels many times a second in an order both sides know.

The clause that names the table to read. It supplies the rows every other clause works on.

The part of a web app that runs in the browser: HTML for structure, CSS for looks and JavaScript for behaviour.

The front end reads one language and writes IR; the back end turns IR into code for one kind of machine.

Fibre to the home: a glass fibre runs all the way into the house.

The state of a promise that succeeded; it holds its value, which never changes again.

A circuit that adds three bits (A, B and a carry in) and gives a sum and a carry out; two half adders and an OR gate.

A small circuit that adds three bits (A, B and a carry-in) and gives a sum bit and a carry-out bit.

Reading every row of a table to find the matching ones. The work grows with the number of rows, O(n).

A copy of a whole page stored in the WAL with the first change to that page after a checkpoint, so a half-written (torn) page can be restored.

A delegate type for a function. Where takes a Func (an int in, true or false out); Select takes a Func here.

Built-in generic delegate types. Func returns a TResult; Action returns nothing.

A named set of steps you can run whenever you need them, such as area.

A block of code saved to run later, here the arrow function () => { ... } that runs on every click.

A named list of steps, written once, that runs each time it is called.

A named piece of code that takes values in, does some work and gives one value back.

A named group of steps. You define it once with def and run it by calling it, as many times as you like.

A named block of code that can take inputs and give back a value. You write it once and run it by calling its name.

Using a function's name without round brackets () to store it or pass it to another function, as in map(double, xs).

A statement such as function total(price, count) { ... } that creates a function and binds it to a name. It is hoisted: the name works from the top of the script.

A template that makes functions, such as larger or std::max.

X → Y: rows that agree on X always agree on Y. For example, ord → cust: one order has one customer.

What the system must do, such as "members can borrow and return books".

A set of gates is functionally complete if it can build every possible truth table. NAND alone is; so is NOR alone.

A decorator for wrappers: it copies the original function's name, docstring and other details onto the wrapper and sets __wrapped__.

The loop at the heart of a game: read input, update the world, draw a frame, and repeat until the game ends.

Gamma, Helm, Johnson and Vlissides, the four authors of the 1994 book Design Patterns, which catalogued 23 patterns.

Space between neighbouring items (and between lines), never at the outer edges.

The gutter between neighbouring tracks, set with gap (or row-gap and column-gap). It is never added at the outside edges.

The engine's automatic removal of values that can no longer be reached, such as a finished call's scope that nothing refers to.

The part of the CLR that finds objects no root can reach and reclaims their memory.

The control terminal of a MOSFET: a plate on a thin insulator whose voltage opens or closes the channel.

How many gates a circuit needs; fewer gates means less area, less power and usually less delay.

A one-bit memory with a data input D and an enable E. While E is 1, Q copies D; while E is 0, Q holds its value.

A box that speaks two kinds of network and translates between them, here a Zigbee radio on one side and MQTT over IP on the other.

An age group of objects: gen 0 for new objects, gen 1 for survivors of one collection, gen 2 for long-lived objects. Young generations are collected far more often.

A model that produces new content, such as text or images. A language model writes by predicting a likely next word (token), again and again.

The iterator a generator function returns. Each next() runs its body up to the next yield, then pauses, keeping its local variables.

A def whose body contains yield. Calling it does not run the body; it returns a generator.

The role of a div (and of a span): a container with no meaning. Screen readers do not announce it as anything.

A function (or type, or class) written with a type parameter, so it works for many types while keeping each one exact.

A built-in fallback such as serif, sans-serif or monospace. It always matches a font the computer has.

A lambda with an auto parameter (C++14 and later). Its operator() is a template, so one lambda works for many types.

A type that takes other types as arguments in angle brackets, like Partial .

A type with a parameter, such as AsText ; you fill it in with a real type, as in AsText .

A type with a type parameter in angle brackets, such as List . List fills T with int, so the list holds only ints and the compiler checks every use.

A class, struct, interface or delegate written with one or more type parameters, such as Box or List .

A circular orbit 35,786 km above the equator whose lap equals one turn of Earth, so the satellite seems fixed in the sky.

The standard image file for one PCB layer, sent to the factory with a drill file.

The two methods a form can use. GET puts the name=value pairs in the address after a ?; POST sends them in the body of the request.

A dict method, d.get(key, default), that returns the key's value or the default when the key is missing.

Group ID: the number of a group. A process carries its user's groups, and a file records one group.

CPython's global interpreter lock: it lets only one thread run Python code at a time.

CPython's lock that lets only one thread run Python bytecode at a time. Each process has its own.

A pattern with wildcards, such as *.txt. Bash replaces it with the sorted list of file names that match.

A name assigned at the top level of a file, outside any function. Every function in the file can read it.

The outermost scope: names declared at the top level of a script.

global x inside a function makes x refer to the module's x, so assigning it changes the global name.

Address records sent with a referral so the resolver can reach a name server whose name is inside the zone it serves.

The 5G base station (gNodeB). It handles the radio and connects to the core over fibre.

General-purpose input/output: pins the program can drive high or low, or read.

Gigabit passive optical network (ITU-T G.984): one fibre from the OLT, split passively to up to 64 homes.

Graphics processing unit: a processor with thousands of simple cores built to do the same sum on lots of data at once.

Repeatedly changing each weight a little in the direction that lowers the loss: w = w − learning rate × gradient.

The best clock on a PTP network, chosen automatically; every other PTP clock syncs to it, directly or through boundary clocks.

A set of vertices together with edges that join pairs of them.

A set of nodes (also called vertices) joined by edges, such as places joined by roads.

An ARP message a host sends about its own address without being asked, to announce it (and others may spot a conflict).

An order of binary numbers, such as 00, 01, 11, 10, in which each step changes exactly one bit.

Always taking the choice that looks best right now, such as the biggest coin. Fast, but not always correct.

A program that prints only the lines that match a pattern.

An element with display: grid. It lays out its children in rows and columns.

A direct child of a grid container. Each item is placed in one or more grid cells.

A dividing line between tracks, numbered from 1. Three column tracks sit between lines 1 to 4.

The 0 V reference point in a circuit, where currents return and from which voltages are measured.

A brief jump in a chip's ground voltage when many outputs switch at once, caused by the inductance of the ground path.

A large area of copper, often a whole layer, connected to ground (0 V).

A wire held at 0 V, standing for logic 0, where currents return.

A site with big dishes that talks to the satellites and connects them to the internet over fibre.

One of the eight 16-bit parts of an IPv6 address, written as up to four hex digits between colons.

A part of a pattern in round brackets. It can be repeated as one unit, and the text it matched can be read with group(n).

All the rows that share the same value in the GROUP BY columns, such as every latte order.

Sorts the rows into groups, one per distinct value of the listed columns; each group becomes one output row.

The wrapper that carries a session's packets between gNB and UPF; a tunnel number (TEID) marks which session they belong to.

The value an undeclared custom property holds. var() with no fallback then makes its declaration act as unset.

A quantum gate that turns |0⟩ into (|0⟩ + |1⟩)/√2 and |1⟩ into (|0⟩ - |1⟩)/√2. Applying it twice undoes it.

An XOR gate and an AND gate that add two bits, giving a sum S = A XOR B and a carry C = A AND B.

A TCP connection in the SYN-RECEIVED state: the server has sent its SYN-ACK and is waiting for the ACK.

A TCP connection that has received a SYN and sent a SYN-ACK but is still waiting for the final ACK.

Moving a phone's connection from one cell to the next while it is in use.

Switching a connection from one satellite to the next as they move across the sky.

Opening messages that set up a connection before any data, like TCP's SYN, SYN-ACK, ACK. UDP has none.

The opening messages in which both sides agree on a version, cipher suite and keys, and the server proves its identity.

The two messages in which the peers prove who they are and make fresh session keys.

A rule (RFC 8305) for connecting to a dual-stack site: try IPv6 first, start IPv4 shortly after if IPv6 is slow, keep whichever connects first.

The physical parts of a computer you can touch: the CPU, memory, screen, keyboard and so on.

A language for describing circuits as text, such as Verilog (IEEE 1364, now part of SystemVerilog, IEEE 1800) or VHDL (IEEE 1076).

A number a switch computes by mixing header fields (MAC addresses, IP addresses, ports). The same fields always give the same hash, which picks the cable.

The 40-character name Git computes from a commit's contents (SHA-1 by default), such as 6ad1b38...; any change gives a different hash.

A one-way function: easy to compute from the input, practically impossible to turn back. The same input always gives the same hash.

A whole number that hash() works out from a value. Dicts and sets use it to decide where a key belongs, so they can find it without searching.

A number computed from a value. A dictionary uses the key's hash code to pick the bucket where the pair is stored.

A function that turns a key into a whole number. The same key always gives the same number while the program runs.

Placing each record on a node chosen by a hash of its key, so the same key always lands on the same node.

A value whose hash never changes, so it can be a key. Strings, numbers and tuples of them are hashable; lists and dicts are not.

Keeps or drops whole groups, after the aggregates are worked out, such as HAVING SUM(price) > 5.

A situation where the next instruction cannot safely go on in the next tick, for example because it needs a result that is not ready yet.

A situation where the next instruction cannot safely go on in the next clock cycle. The three kinds are data, control and structural hazards.

Git's marker for where you are: normally it points at the branch you have switched to.

The part of the page that holds information about it (metadata), such as the title and character set. Not drawn on the page.

Extra bytes a layer puts in front of the data, with the information that layer needs, such as addresses or port numbers.

A Name: value line after the first line, such as Host or Content-Type. An empty line ends the headers.

A file (often .h or .hpp) of declarations that other files #include, so they can use what it declares.

Lines at the top of the message such as From:, To:, Subject: and Date:, shown to people.

A title for the page or a section of it, written with h1 to h6. h1 is the page title; each lower level is a part of the one above.

Spare capacity kept on purpose so utilisation stays well below 1, which keeps queues and delay short.

A large area of memory for objects that are made on request and may outlive the call that made them.

The area of memory that holds objects a program creates while it runs, such as lists and dictionaries.

The memory you take with new and give back with delete; its objects live until you delete them (dynamic storage).

Memory for objects, managed by .NET. The garbage collector frees objects that nothing refers to any more.

Memory you ask for while the program runs with new, and give back with delete. It lasts until you free it.

A small OSPF packet each router sends on every link, by default every 10 seconds, to find and keep its neighbours.

A colour written as # and three pairs of hexadecimal (base 16) digits, one pair per light, such as #ff6347.

A digit in base 16: 0–9 then a–f. Each one stands for 4 bits.

Counting in base 16 with the digits 0-9 and A-F. Programmers write each byte as two hex digits: 65 is 41, 255 is FF.

Base 16, with digits 0 to 9 and A to F. Written with the prefix 0x in Python, as in 0xFF.

A hit: the level asked has the data. A miss: it does not, so the request goes to the next, slower level.

A hit finds the line already in the cache; a miss has to fetch it from the next, slower level of memory.

Leaving both inputs inactive, so the latch keeps its last value.

How long D must stay steady after the clock edge.

How long after a clock edge a flip-flop's input must stay steady, so a new value must not arrive too early.

How long one call (or job, or session) keeps its line or server busy.

A bond that is one electron short. Electrons hopping into it make the hole move like a positive charge; p-type silicon carries current this way.

A place in the silicon where an electron is missing. It acts like a moving + charge.

Your own folder on the disk, for example /home/alex. The shell writes it as ~ for short.

Your own folder, usually /home/ . The shell writes it as ~ for short.

Your own directory, usually /home/yourname. cd with nothing after it takes you there; ~ is short for it.

One link a packet crosses, from one device to the next.

Any device that sends and receives data on a network: a phone, a laptop, a TV, a server.

The program JavaScript runs inside, such as a web browser or Node.js. It provides timers, queues and the event loop.

A firewall running on one machine itself, guarding it even from devices on the same network.

The server's own key pair. It signs the key exchange so you can tell you are talking to the real server.

A loop where the program spends a large share of its time; the place where speed-ups pay off.

A shard that gets far more work than the others, for example because one key is very busy.

Resting the mouse on a name in an editor such as VS Code; it shows the type tsc inferred.

The attribute on an a element that holds the URL the link points to.

HyperText Markup Language: plain text with tags that describes the structure of a web page.

Hypertext Transfer Protocol: the request-and-response language browsers and web servers speak.

The verb of a request: GET reads, POST creates, PUT replaces, PATCH changes a part, DELETE removes.

A message a browser sends to a server, such as GET /api/users/7, asking for a resource.

The server's reply: a status line (such as 200 OK), headers, and a body.

The web server's answer meaning OK: the page you asked for is there.

Input and output: how a computer swaps data with devices such as keyboards, screens, disks and network cards.

I/O-bound work mostly waits (network, disk); CPU-bound work mostly computes. Threads suit the first, processes the second.

The increment operator: adds 1 to i.

Inter-Integrated Circuit: two shared wires, SDA (data) and SCL (clock); each chip has a 7-bit address and answers with an ACK bit.

A two-wire bus (clock SCL, data SDA) where a controller addresses chips by a 7-bit address and every byte is acknowledged.

Internet Control Message Protocol: the small control and error messages of IP, such as Echo, Time Exceeded and Destination Unreachable.

A tiny test message (echo request) that a host answers with an echo reply. ping sends it and times the reply.

An HTML name for one element: id="top". It must be unique in the page.

A hash and an id, such as #top. It matches the element whose id attribute is top.

A selector that starts with #, such as #intro. It matches the element whose id attribute is intro.

Doing an action twice has the same effect as doing it once, so a push can be safely repeated.

Sending a request twice has the same effect on the server as sending it once. GET, PUT and DELETE are; POST is not.

Safe to repeat: doing it twice has the same effect as doing it once.

The name of a variable. It may use letters, digits, _ and $, but cannot start with a digit or be a reserved word.

The technical word for a name: letters, digits and underscores, not starting with a digit.

Which object something is. id() gives a number unique to the object while it lives; is checks whether two references are the same object.

Intrusion detection system: a sensor that inspects traffic, usually copies of it, and raises alerts. It cannot stop traffic.

A low-power, short-range radio standard: at 2.4 GHz it sends 250 kb/s in frames of at most 127 bytes. Zigbee and Thread both use it.

The interface for a sequence that hands out its items one at a time. Arrays and List implement it, so LINQ works on them.

Runs the indented block under it only when its condition is True.

Runs its indented block only when its condition is True.

A choice: if the condition is true, the first statement runs; otherwise the else statement runs. Exactly one of them runs.

An optional filter, such as if n > 2: only items whose test is True reach the expression.

Inline frame: an element that embeds a second, separate web page inside the current one.

Internet Key Exchange version 2 (RFC 7296): the handshake on UDP port 500 that agrees keys, checks identities and creates SAs.

Simple, CPU-independent instructions such as ldstr and call, stored in an assembly. Also called CIL.

The protocol a mail app uses to read mail that stays on the server (port 993 with TLS).

A number written right inside an instruction, such as the 2 in LDI r0, 2. In TINY-8 it is the 8-bit imm8 byte.

A number written right inside the instruction itself. In TINY-8 it is the second byte, such as the 1 in LDI r3, 1 or the address 32 in ST r2, [32].

Never changing data once it is made; new values are built instead. A tuple is immutable in Python; a list is not, but you can choose not to change it.

Cannot be changed after it is made. Python strings are immutable, so changes always build a new string.

Cannot be changed. Strings are immutable: methods and + always make new strings.

Rows or columns the browser creates by itself when items do not fit the tracks you declared.

A start or end tag the file left out, which the parser adds by itself, such as html, head, body or a missing .

The statement that finds a module, runs it the first time, and makes its names usable as module.name.

A statement that links names exported by another module into this one, as in import { count, add } from "./counter.js".

Brings an exported name from another module into this one.

A statement that finds a module, runs it the first time, and binds a name to it in your file.

The list of files or folders that belong to the project, such as ["src"].

A build that skips every step whose outputs are already newer than its inputs.

The spaces at the start of a line. Python uses it to decide which lines are inside a block; four spaces per level is the usual style.

Spaces at the start of a line. Python uses them to group lines into blocks; a stray one is an IndentationError.

The position number of an item. Counting starts at 0; negative indexes count back from the end (-1 is the last).

The numbered place of a character, counting from 0. Negative indexes count from the end (-1 is the last).

A second, sorted structure over one or more columns, with a pointer from each entry to its row, so lookups do not need a full scan.

The number of an item's place in the array. The first item is at index 0, the next at 1, and so on.

The position of a character in a string, counting from 0. The last index is length minus 1.

The position of an item in an array, counted from 0. In [10, 20, 30], 10 is at index 0.

An item's position, counted from 0. fruits[0] is the first item; fruits[-1] is the last.

An item's position in a list, counting from 0: nums[0] is the first item.

An element's position, counted from 0. Valid indexes run from 0 to size - 1.

The position of an element in an array, counted from 0. For N elements the valid indexes are 0 to N-1.

A separate structure that a DBMS keeps next to a table so it can find rows by a column's value without reading every row.

A separate structure beside a table that lets the DBMS find rows by a column's value without reading every page.

A plan that walks an index to the matching entries, then fetches only those rows from the table.

T[K]: the type of property K inside type T, such as User["id"], which is number.

A coil of wire that stores energy in a magnetic field and resists sudden changes in current.

A loop whose condition never becomes false, so it never ends.

A loop whose condition never becomes false, so it never stops. Usually a bug, often a forgotten update like n = n - 1.

Describing servers, networks and other infrastructure in code files, so tools can create identical copies every time.

When an element has no value of its own for an inherited property, it copies its parent's value.

An element taking a property's value from its parent when no rule sets its own. Custom properties are inherited.

Building a new class on an existing one: the new class can use everything the existing class defines and add or replace parts.

Making a new class from an existing one: a Dog is an Animal plus more, so a Dog can be used wherever an Animal is expected.

A subclass, class Savings(BankAccount):, reuses its parent's methods; defining a method with the same name overrides the parent's version.

A property with an init accessor: it can be set in an object initializer or constructor, and never after the object is made.

A rectangle the size of the viewport, anchored at the top of the page. It scrolls with the page.

A compressed cpio archive the kernel unpacks into memory as a temporary root file system. Its /init program finds and mounts the real disk.

A mistake where user text is glued into a command (such as SQL) so the text can change what the command does.

In the path: every packet must pass through the device to reach its destination.

A box that sits on a line next to its neighbours and is as wide as its content. width does not apply to it. span is inline by default.

An element's size along the direction text runs. In horizontal text, such as English or Arabic, it is the width.

A display value for a box that sits in a line like an inline box but takes a width and height like a block.

A join that keeps only the pairs of rows that match. Rows with no partner are left out.

What you give a program while it runs. input() reads one line you type (from the standard input stream, sys.stdin).

Checking that input has the shape you expect (a whole number, a short name) and rejecting the rest, ideally with an allow-list.

A built-in function that writes a question, waits for you to type a line and press Enter, and returns that line as a string.

A built-in function that writes an optional prompt, waits for a line and returns it as a string, without the newline.

The SQL command that adds new rows to a table: INSERT INTO table (columns) VALUES (values).

vim's typing mode, entered with i and left with Esc; vim shows -- INSERT -- while you are in it.

A sort that grows a sorted part on the left, inserting each next item into its place by shifting bigger items right.

One object made from a class, by calling the class like a function, such as Counter(5).

A value stored on one object, usually through self, as self.name = name. Each object has its own.

The compiler writing a real function or class from a template, with the parameters filled in, such as larger from larger .

The fixed list of instructions one kind of CPU understands, each with its own number code. x86-64 and Arm are two real ones.