Glossary

Terms used in the lessons, explained briefly. In lessons you’ll spot them by the dotted underline — hover over them.

A

API: The interface one program uses to talk to another — e.g. an HTTP endpoint returning JSON, or the methods of an object.
ARIA: Attributes (aria-label, aria-expanded...) that add information for screen readers where native HTML isn't enough.; Details in the lesson “Accessibility” →
Accessibility (a11y): A site that anyone can use: with a keyboard, a screen reader, zoom or low vision.; Details in the lesson “Accessibility” →

B

Bundle: The JS (and CSS) files generated at build time from your code and libraries and sent to the browser. The smaller, the faster the page.; Details in the lesson “Modules: import / export” →

C

CDN: A network of servers around the world keeping copies of static files close to users so they load fast.; Details in the lesson “How the web works” →
CORS: The mechanism by which a server explicitly allows other origins to read its responses. Configured on the server, not in the frontend.; Details in the lesson “Security: XSS, CSRF, CORS” →
CSR (client-side rendering): The page is built in the browser by JavaScript; the server sends nearly empty HTML. Slower first paint and weaker for SEO.; Details in the lesson “SSR, SSG, ISR, CSR, PPR” →
CSRF: An attack where another site sends a request on your behalf using your cookies. Defenses: SameSite=Lax, checking Origin, tokens.; Details in the lesson “Security: XSS, CSRF, CORS” →
Cache: A stored copy of an expensive result (query, request, render) reused so the work isn't repeated. It can go stale, so it needs invalidation.; Details in the lesson “Caching: 'use cache', tags and PPR” →
Canonical: The "original" URL of a page reachable at several addresses, declared with <link rel="canonical">.; Details in the lesson “Technical SEO” →
Cascade layers (@layer): CSS layers with explicit priority: rules in a later-declared layer beat earlier layers regardless of specificity.; Details in the lesson “Cascade, specificity, inheritance” →
Client Component: A component marked with 'use client': sent to the browser as JS, it can use state, effects, events and browser APIs.; Details in the lesson “Server vs Client Components” →
Closure: A function that remembers the variables from the place it was created, even after that code has finished running.; Details in the lesson “Functions and closures” →
Commit: A saved "snapshot" of the project in Git, with a message explaining the change.; Details in the lesson “Git: the basics” →
Component: A React function that receives props and returns UI (JSX). The basic building block of an interface.; Details in the lesson “Components, props and JSX” →
Controlled input: A form field whose value lives in React state (value + onChange). The opposite: uncontrolled — the value lives in the DOM.; Details in the lesson “Forms in React” →
Cookie: A small piece of text the browser stores for a site and sends back to the server automatically on every request. Used for sessions and preferences.; Details in the lesson “Cookies, localStorage, sessionStorage” →
Crawler (Googlebot): A search engine program that discovers pages by following links and downloads them for indexing.; Details in the lesson “How Google works” →

D

DNS: The system that translates a domain name (example.com) into the server's IP address — the internet's phone book.; Details in the lesson “How the web works” →
DOM: The page represented as a tree of objects, built by the browser from HTML, which JavaScript can read and change.; Details in the lesson “DOM and events” →
Design tokens: Named variables for visual decisions (colors, fonts, radii). Components use the tokens, not raw values.; Details in the lesson “Themes and design tokens” →

E

Environment variable: A setting or secret (DB URL, API keys) given to the app from outside the code, different for local, preview and production.; Details in the lesson “Env, build and deploy” →
Event bubbling: After an event happens on an element it "bubbles up" through all its parents, which can listen to it. The basis of event delegation.; Details in the lesson “DOM and events” →
Event loop: How single-threaded JS runs the callbacks of asynchronous operations once the current code has finished.; Details in the lesson “Async: Promise and await” →

F

Feature-Sliced Design (FSD): A frontend architecture methodology with layers (app, views, widgets, features, entities, shared) where imports only go downward.; Details in the lesson “Feature-Sliced Design” →
First-class function: Functions are values: you can store them in variables, pass them as arguments and return them from other functions.; Details in the lesson “Functions and closures” →
Flaky test: A test that sometimes passes and sometimes fails without the code changing — usually because of timing or ordering.; Details in the lesson “Playwright: end-to-end tests” →

H

HTTP header: A name: value pair attached to a request or response (Content-Type, Cache-Control, Cookie) describing the message.; Details in the lesson “HTTP: methods, statuses, headers” →
HTTPS: Encrypted HTTP (with TLS): nobody on the network can read or change the data. Required for Secure cookies and many modern APIs.; Details in the lesson “How the web works” →
Higher-order function: A function that takes other functions as arguments or returns a function — e.g. map, filter, addEventListener.; Details in the lesson “Functions and closures” →
Hoisting: Before running, JS registers the declarations in a scope: functions can be used before their line, var is undefined, let/const throw (TDZ).; Details in the lesson “Scope, hoisting and this” →
Hook: A React function (useState, useEffect...) that gives a component memory, effects or context. Its name starts with "use".; Details in the lesson “Custom hooks” →
Hydration: The step where React takes the HTML rendered on the server and attaches JS and events so it becomes interactive.; Details in the lesson “Server vs Client Components” →

I

ISR (incremental static regeneration): Static pages regenerated periodically or on demand, without a full rebuild.; Details in the lesson “SSR, SSG, ISR, CSR, PPR” →
Idempotent: An operation that has the same effect whether you run it once or many times (GET, PUT, DELETE — but not POST).; Details in the lesson “HTTP: methods, statuses, headers” →

J

JSON: A text format for data, similar to JS objects, used to send data between the browser and the server.; Details in the lesson “fetch, JSON and AbortController” →
JSX: HTML-like syntax inside JavaScript that React uses to describe the UI.; Details in the lesson “Components, props and JSX” →
JWT (JSON Web Token): A three-part token (header.payload.signature); anyone can read the payload, the signature proves it wasn't modified.; Details in the lesson “Authentication and sessions” →

M

Memory leak: Memory held by data that's no longer needed but can't be freed because something still references it (listener, timer, cache).; Details in the lesson “Map and Set” →
Mock: A fake replacement for a dependency (API, time, module) in a test, so the test is fast and predictable.; Details in the lesson “Vitest: unit tests” →
Mutation: Changing an existing object or array in place (push, sort, obj.x = 1) instead of creating a new one.; Details in the lesson “References and immutability” →

N

Narrowing: In TypeScript: a check (typeof, in, ===) after which TS knows the exact type of a value from a union.; Details in the lesson “Union types and narrowing” →

O

Origin: The combination of protocol + domain + port (https://example.com:443). The browser isolates origins from each other.; Details in the lesson “How the web works” →

P

Partial Prerendering (PPR): Next.js instantly serves a pre-generated "static shell", and the page's dynamic parts stream in afterwards.; Details in the lesson “Caching: 'use cache', tags and PPR” →
Prefetch: Loading a page or resource in the background before the user gets to it, so navigation feels instant.; Details in the lesson “Layouts, states and navigation” →
Primitive value: A simple, immutable value: string, number, boolean, null, undefined, bigint, symbol. Copied by value.; Details in the lesson “Variables and types” →
Promise: An object representing a value that will arrive later; it's pending, then fulfilled (with a value) or rejected (with an error).; Details in the lesson “Async: Promise and await” →
Props: The data a React component receives from its parent, like arguments. They are read-only.; Details in the lesson “Components, props and JSX” →
Prototype: The object another object is secretly linked to; missing properties are looked up along the prototype chain.; Details in the lesson “Classes and prototypes” →
Pull Request (PR): A request to merge one branch into another, with room for review, discussion and automated checks (CI).; Details in the lesson “Workflow: PRs, review, Conventional Commits” →
Pure function: For the same input it always returns the same output and has no side effects (changes nothing outside).; Details in the lesson “Functions and closures” →

R

Race condition: A bug where the result depends on the order in which async operations finish — e.g. an old response overwriting the new one.; Details in the lesson “fetch, JSON and AbortController” →
Reducer: A pure function (state, action) => new state. The basis of useReducer and Redux.; Details in the lesson “Redux Toolkit” →
Reference: The address of an object in memory. Variables holding objects hold the reference, so two variables can point to the same object.; Details in the lesson “References and immutability” →
Request: The message the client sends to the server: method (GET, POST...), URL, headers and optionally a body.; Details in the lesson “HTTP: methods, statuses, headers” →
Response: The message the server sends back: status code (200, 404...), headers and body.; Details in the lesson “HTTP: methods, statuses, headers” →

S

SSG (static site generation): Pages are generated once, at build time, and served as static files — very fast.; Details in the lesson “SSR, SSG, ISR, CSR, PPR” →
SSR (server-side rendering): The page's HTML is generated on the server on every request, with fresh data.; Details in the lesson “SSR, SSG, ISR, CSR, PPR” →
Schema (validation): A description of the shape and rules of some data (e.g. with Zod); from it you get validation, error messages and the TypeScript type.; Details in the lesson “Validation with Zod” →
Scope: The part of the code where a variable exists and can be used: global, function or block.; Details in the lesson “Scope, hoisting and this” →
Semantic HTML: Using the tag that describes what the content is (nav, main, button, article), not just how it looks.; Details in the lesson “Structure and semantics” →
Semver: MAJOR.MINOR.PATCH versioning: major for breaking changes, minor for new features, patch for bug fixes.; Details in the lesson “Workflow: PRs, review, Conventional Commits” →
Server Action: A 'use server' function called from the UI (form, button) that runs on the server — for mutations. It's a public endpoint: check auth and validate.; Details in the lesson “Server Actions and forms” →
Server Component: A component that runs only on the server: it can be async and read data directly, and its code never reaches the browser.; Details in the lesson “Server vs Client Components” →
Server state: Data that lives on the server (users, products); in the browser you only have a copy that can go stale.; Details in the lesson “Server state and TanStack Query” →
Session: How the server recognizes you between requests after login — usually through a cookie.; Details in the lesson “Authentication and sessions” →
Specificity: The score of a CSS selector (IDs, classes, elements) that decides which rule wins when several target the same element.; Details in the lesson “Cascade, specificity, inheritance” →
Stacking context: An isolated group of elements for z-index: a child can't rise above elements outside its parent's context.; Details in the lesson “Positioning and z-index” →
State: A React component's memory: data that changes over time; when it changes, the component re-renders.; Details in the lesson “State, derivation and reducers” →
Store: An object holding the app's global state outside components; components subscribe to it (Redux, Zustand).; Details in the lesson “Kinds of state and how to choose” →
Suspense: A React component that shows a fallback (skeleton, spinner) while the content inside is loading.; Details in the lesson “Data fetching and streaming” →
staleTime: In TanStack Query: how long cached data is considered fresh and won't be refetched. Defaults to 0.; Details in the lesson “Server state and TanStack Query” →

T

TDZ (temporal dead zone): The zone between the start of a scope and a let/const declaration, where the variable exists but using it throws a ReferenceError.; Details in the lesson “Scope, hoisting and this” →
Tree shaking: Removing exported code that nothing imports at build time. Works only with static import/export.; Details in the lesson “Modules: import / export” →
Truthy / falsy: How a value converts to boolean. Falsy: false, 0, "", null, undefined, NaN. Everything else is truthy.; Details in the lesson “Variables and types” →
this: A special variable of a function pointing to the object it's called on; it depends on how you call it, not where it's written.; Details in the lesson “Scope, hoisting and this” →

U

Utility-first: Styling with small single-purpose classes (p-4, flex, text-lg) composed right in the markup — the Tailwind approach.; Details in the lesson “Utility-first and layout” →

W

Waterfall (request cascade): Requests that wait for each other even though they could run in parallel — the page loads needlessly slowly.; Details in the lesson “Data fetching and streaming” →
Webhook: An HTTP request an external service (Stripe, a CMS) sends to your app automatically when something happens.; Details in the lesson “Route Handlers and Proxy” →

X

XSS: An attack where foreign JS code runs on your page, usually through user input rendered as HTML.; Details in the lesson “Security: XSS, CSRF, CORS” →

Glossary

A

B

C

D

E

F

H

I

J

M

N

O

P

R

S

T

U

W

X

Was this page helpful?