A. Glossary
Terms are grouped alphabetically. The chapter link takes you to the full explanation.
- Accessibility tree — the parallel tree of roles, names and states that assistive technology reads instead of pixels. Ch 15
- Accessible name — what a screen reader announces for an element, computed from labels, text content or ARIA. Ch 15
- Anycast — many servers announcing the same IP, so routing delivers users to the nearest. Ch 6
- ARIA — attributes that adjust accessibility semantics (never behaviour). First rule: prefer native HTML. Ch 15
async/defer— script attributes that download in parallel; async runs on arrival, defer runs in order after parsing. Ch 9- Baseline — cross-browser support label: newly available in all major browsers, or widely available for 30+ months. Ch 14
- bfcache — back/forward cache: a frozen copy of a page restored instantly on Back/Forward. Ch 9
- BGP — the protocol networks use to announce reachable address ranges to each other. Ch 5
- Bind group — WebGPU’s pre-validated bundle of resources for shaders. Ch 21
- Blue-green deploy — two full environments; switch traffic between them. Ch 4
- Brotli / zstd / gzip — HTTP compression schemes for text. Ch 6
- Bundler — tool that resolves the module graph and emits optimized chunks. Ch 1
Cache-Control— header instructing every cache how long and how to store a response. Ch 6- Canary release — rolling a change out to a small percentage of traffic first. Ch 4
- Canonical URL — the preferred URL for duplicate content, via
rel=canonical. Ch 22 - CDN — a network of edge servers that cache and deliver content near users. Ch 6
- CHIPS — partitioned third-party cookies, one jar per top-level site. Ch 12
- CI — automated checks on a fresh machine for every push. Ch 3
- CLS — Cumulative Layout Shift: the largest burst of unexpected layout movement; good ≤ 0.1. Ch 16
- Code-splitting — breaking bundles into chunks loaded on demand via dynamic
import(). Ch 1 - Cold start — the delay to boot a serverless instance before serving. Ch 6
- Commit (rendering) — the main thread handing layout, property trees and display lists to the compositor. Ch 10
- Compositor thread — renderer thread that assembles layers into frames and runs transform/opacity animations independently of the main thread. Ch 10
- Compute shader — GPU program for general parallel computation (WebGPU). Ch 21
- Content hash — a fingerprint of file contents embedded in its filename. Ch 1
content-visibility— CSS that skips rendering work for off-screen content. Ch 10- Context loss — a WebGL context’s GPU resources being destroyed by the browser/OS. Ch 20
- Core Web Vitals — LCP, INP, CLS, judged at p75. Ch 16
- CORS — server opt-in that lets other origins read its responses. Ch 13
- CrUX — Chrome UX Report: field data from opted-in Chrome users, 28-day windows. Ch 17
- CSP — Content Security Policy: header restricting what a page may load and execute. Ch 13
- CSR / SSR / SSG / ISR — client-side rendering, server-side rendering, static generation, incremental static regeneration. Ch 7
- CSRF — tricking a logged-in browser into making a state-changing request. Ch 13
- DCL (DOMContentLoaded) — event when the document is parsed and deferred scripts have run. Ch 9
- Deoptimization — V8 discarding optimized code when type assumptions break. Ch 11
- Display list — recorded drawing commands produced by paint. Ch 10
- DNS — the distributed system mapping names to IP addresses. Ch 5
- Draw call — one GPU command to draw geometry with the current state; costs CPU. Ch 20
- Dropped frame — a display refresh with no new frame ready. Ch 10
- ETag — a response version identifier used for conditional revalidation (304). Ch 6
- Event loop — the main thread’s cycle: one task, all microtasks, maybe render. Ch 11
- Expand/contract — reversible multi-step schema migration. Ch 4
- FCP — First Contentful Paint; good ≤ 1.8 s. Ch 16
- Feature flag — runtime switch separating deploy from release. Ch 4
fetchpriority— hint to raise or lower a resource’s fetch priority. Ch 9- FLIP — First, Last, Invert, Play: animate layout changes with transforms. Ch 19
- FOIT / FOUT — flash of invisible / unstyled text during font loading. Ch 10
- Forced synchronous layout — reading geometry after a write, forcing immediate layout. Ch 10
- Fragment shader — GPU program run once per covered pixel. Ch 20
- Frame budget — time between refreshes: 16.67 ms at 60 Hz, 8.33 ms at 120 Hz. Ch 10
- Garbage collection (generational) — reclaiming unreachable memory; young generation scavenged often, old generation marked and swept. Ch 11
- HMR — hot module replacement in dev servers. Ch 1
- HPACK / QPACK — header compression for HTTP/2 / HTTP/3. Ch 5
- hreflang — annotations linking language/region versions of a page. Ch 22
- HSTS — header forcing HTTPS for a domain. Ch 13
- Hydration — re-running components on the client to attach behaviour to server HTML. Ch 7
- Immutable —
Cache-Controldirective: never revalidate during freshness. Ch 6 - Import map — JSON mapping bare module specifiers to URLs in the browser. Ch 1
- IndexedDB — the browser’s async, transactional object database. Ch 12
- INP — Interaction to Next Paint: input delay + processing + presentation; good ≤ 200 ms. Ch 16
- Instancing — drawing many copies of geometry in one draw call. Ch 20
- Islands — static HTML with isolated interactive components that hydrate independently. Ch 7
- Latency / RTT — round-trip time of one message; dominates mobile loading. Ch 5
- Layer (composited) — separately rastered piece of the page the GPU can move/fade. Ch 10
- Layer explosion — too many layers, high GPU memory. Ch 10
- Layout (reflow) — computing positions and sizes of boxes. Ch 10
- Layout thrashing — repeated forced layouts from interleaved reads/writes. Ch 10
- LCP — Largest Contentful Paint; four sub-parts; good ≤ 2.5 s. Ch 16
- Live region — element whose updates are announced by screen readers. Ch 15
- Lockfile — exact resolved dependency tree with integrity hashes. Ch 2
- LoAF — Long Animation Frames API with script attribution. Ch 16
- Long task — main-thread task over 50 ms. Ch 11
- Main thread — the renderer thread that runs JS, style, layout and paint. Ch 8
- Microtask — promise callbacks, await continuations, queueMicrotask; drained after each task. Ch 11
- Minification — shrinking code without changing behaviour. Ch 1
no-cache/no-store— revalidate every time / never store. Ch 6- OffscreenCanvas — canvas rendering from a worker. Ch 20
- Origin / Site — scheme+host+port / scheme+registrable domain. Ch 8
- p75 — 75th percentile; the Core Web Vitals pass criterion. Ch 16
- Paint — recording display lists (not producing pixels). Ch 10
- Peer dependency — “the host app provides this” (e.g., React). Ch 2
- Phantom dependency — importing a package you didn’t declare, available only through hoisting. Ch 2
- Pipeline (WebGPU) — immutable bundle of shaders and fixed-function state. Ch 21
- Popover API — declarative top-layer popups with light dismiss. Ch 14
- Preflight — CORS
OPTIONSrequest before non-simple cross-origin requests. Ch 13 - Preload scanner — secondary parser that fetches resources ahead of the main parser. Ch 9
- Progressive enhancement — a baseline that works everywhere plus layered enhancements. Ch 14
- Property trees — Chromium’s transform/clip/effect/scroll trees enabling compositor-only updates. Ch 10
- QUIC — UDP-based transport under HTTP/3 with per-stream loss recovery. Ch 5
- Raster — turning display lists into pixels, in tiles, usually on the GPU. Ch 10
requestAnimationFrame— callback before the next frame’s rendering steps. Ch 11- Resource hints — preconnect, dns-prefetch, preload, modulepreload, prefetch. Ch 9
- robots.txt — crawl (not index) instructions for bots. Ch 22
- RSC — React Server Components: server-only components shipped as payload, not code. Ch 7
- RUM — real-user monitoring. Ch 17
- SameSite — cookie attribute controlling cross-site sending (Strict/Lax/None). Ch 12
- Scroll-driven animation — animation progress tied to scroll (
animation-timeline). Ch 19 - Semver — MAJOR.MINOR.PATCH versioning;
^and~ranges. Ch 2 - Service worker — background script intercepting network requests. Ch 12
- Session window (CLS) — shifts grouped with < 1 s gaps, ≤ 5 s long. Ch 16
- Side effects (bundling) — module evaluation that changes the world, blocking tree-shaking. Ch 1
- Site isolation — one renderer process per site, a Spectre defence. Ch 8
- sitemap.xml — list of canonical URLs with honest
lastmod. Ch 22 - Slow start / congestion window — TCP ramping its sending rate. Ch 5
- Source map — mapping from built code back to source. Ch 1
- Speculation Rules — declarative prefetch/prerender of likely next pages. Ch 9
- SRI — Subresource Integrity: hash-pinning external scripts. Ch 13
stale-while-revalidate— serve stale instantly, refresh in background. Ch 6- Streaming SSR — sending HTML in chunks as data resolves. Ch 7
- Style recalculation — computing final CSS values per element. Ch 10
- SwiftShader — CPU implementation of graphics APIs used as a software fallback. Ch 20
- Synthetic monitoring — scripted scheduled checks. Ch 23
- TBT — Total Blocking Time: lab sum of long-task time over 50 ms. Ch 16
- TLS 1.3 — one-round-trip encrypted handshake; certificates and chain of trust. Ch 5
- Transferable — object whose ownership moves between threads without copying. Ch 11
- Transpiler — source-to-source compiler (Babel, SWC, esbuild). Ch 1
- Tree-shaking — removing unused exports. Ch 1
- Trusted Types — CSP feature forcing HTML sinks through reviewed policies. Ch 13
- TTFB — Time to First Byte; good ≤ 0.8 s. Ch 16
- TTL — DNS record cache lifetime. Ch 5
- Vertex shader — GPU program run once per vertex. Ch 20
- View Transitions — API that animates between DOM states or documents via snapshots. Ch 10
- Virtualization — rendering only visible rows of long lists. Ch 10
- VSync — the display’s refresh signal and frame deadline. Ch 10
- WebGL / WebGL2 — OpenGL ES 2.0 / 3.0-based GPU APIs. Ch 20
- WebGPU / WGSL — modern explicit GPU API and its shading language. Ch 21
will-change— hint to prepare a layer for an upcoming animation. Ch 10- Worker — background JS thread without DOM access. Ch 11
- XSS — injected script running with a page’s privileges. Ch 13