Skip to content

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-Control directive: 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 OPTIONS request 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