Glossary

A CSS functional pseudo-class that selects an element when a condition about its descendants or internal structure is true.

A functional selector that groups multiple selector options into one rule while keeping the highest specificity among the arguments.

A functional selector that excludes one or more matching cases from a broader rule.

A functional selector that groups selector options but always contributes zero specificity.

Family of HTTP status codes that normally indicates a successful request.

Family of HTTP status codes that usually indicates a client-side problem with the request.

Family of HTTP status codes that usually indicates a server-side failure.

Shortened form of a term marked up with `abbr`, often expanded through a `title` attribute.

Header that tells the server which response formats the client can handle.

Interface pattern that lets the user expand and collapse sections of content to reduce visual noise.

Approach for sending asynchronous HTTP requests so parts of a page can update without a full reload.

Finite sequence of clear ordered steps used to solve a problem or transform an input into an output.

Alternative description provided through the `alt` attribute of an image so its meaning is still available without sight or without the file loading.

HTML link element written with `a`, often used with `href` to create navigation targets.

A modern CSS positioning model that lets one element align itself to another named element without manual JavaScript coordinate calculations.

The CSS setting that defines which segment of a scroll or view timeline should drive an animation.

Set of rules and endpoints that allows one system to communicate with another.

Strategy for evolving an API without breaking clients that depend on older behavior.

Accessibility attribute system that helps describe custom interface behavior to assistive technologies when native HTML is not enough.

Structure that stores several related values in one ordered list.

The proportional relationship between an element's width and height, often used to keep media blocks visually consistent.

A CSS function that reads an attribute value from the HTML and injects it into generated content.

Extra information written inside an opening HTML tag to define details such as destination, type or description.

HTML media element used to embed playable sound content in a page.

A Grid repetition mode that collapses empty tracks and lets occupied ones stretch when extra space is available.

A build tool that adds the vendor prefixes still required by the browsers you support, based on your target configuration.

A CSS effect that processes the pixels behind an element, often used for frosted-glass panels and translucent overlays.

A property that controls how far the background is painted, for example inside the padding box or across the border box.

One of the stacked background declarations in CSS, where the first layer is painted on top and later layers sit underneath.

Block Element Modifier. Naming methodology for writing more predictable CSS classes.

The part of an HTML document that contains the visible and interactive content of the page.

Browser Object Model. Collection of browser-specific objects such as `window`, `history` and `location`.

Data type that can represent only two states: true or false.

A frontend framework that provides a responsive grid, utility classes and ready-made interface components for building web layouts quickly.

A CSS feature that paints an element border using an image, SVG or gradient sliced into corners and edges.

The `border-image` parameter that controls how the source graphic is cut before being mapped onto the element border.

A CSS property that adds one or more shadows to an element using offset, blur, spread and color values.

Screen width threshold where a responsive layout changes its rules.

Didactic connection between general programming fundamentals and their direct application in JavaScript.

The shared configuration used by frontend tools to define which browsers and versions a project targets.

Phase of event propagation where an event moves from the target element back up through its ancestors.

A CSS math function used to combine compatible units in a single computed value.

Preferred URL declared for a page when multiple similar URLs might exist.

Phase of event propagation where an event travels from higher ancestors down toward the target element.

A reusable UI block that groups media, text and actions into one self-contained preview or information unit.

The browser's conflict-resolution system for deciding which CSS rule wins when several affect the same element.

An ordered CSS layer declared with `@layer` that lets architecture determine priority before specificity is considered.

A CSS interaction technique that uses a hidden checkbox or radio input plus selectors such as `:checked` to toggle visible UI state without JavaScript.

A repeated Grid-based surface made of alternating cells, often used for technical or decorative backgrounds.

The intensity or purity of a color in models such as OKLCH, separate from its lightness and hue.

A CSS function that keeps a value fluid between a minimum and a maximum limit.

A selector that starts with a dot and targets all elements sharing a class name.

Function that keeps access to variables from its lexical scope even after that outer scope has finished executing.

An input type detected by media queries that usually represents touch interaction and benefits from larger tap targets.

Optimization technique that breaks a large JavaScript bundle into smaller chunks loaded on demand.

Use of color choices and relationships inside a visual system.

A coordinated set of colors selected to work together across the interface and often exported as reusable tokens.

A browser hint exposed by the `color-scheme` property that tells the user agent whether the interface is designed for light, dark or both themes.

A curated set of reusable interface components that helps teams build products with more consistency and less duplicated styling work.

Way of analyzing complex problems through decomposition, patterns, abstraction and reproducible steps.

Structure that lets a program choose one path or another depending on whether a condition is met.

A CSS function such as `if()` that chooses one value or another according to a logical condition.

A gradient that rotates around a center point, useful for rings, charts and expressive circular effects.

A CSS property that provides a placeholder size for content whose real rendering work is being deferred.

A CSS feature that lets a component adapt to the size of its own container instead of the global viewport.

The CSS property that turns an element into a queryable container for its descendants.

A CSS length unit such as `cqi` or `cqw` that is measured relative to the size of a query container.

A CSS optimization feature that lets the browser skip layout and paint work for off-screen content until it gets close to the viewport.

Header that describes the format of the request or response body.

Small piece of data stored by the browser and often used for sessions, preferences or tracking.

A group of user-focused metrics that measure loading, visual stability and interaction quality.

The axis perpendicular to the main axis in Flexbox, used by properties such as `align-items`.

Cascading Style Sheets. Language used to style and visually organize web pages.

A group of CSS mechanisms that limit how much layout, paint or size calculation work an element can affect outside its own boundaries.

A CSS technique that controls which parts of an element remain visible by applying a mask image or gradient.

A styling approach where class names are scoped locally to a component file so styles do not leak globally by default.

A native CSS feature that allows related selectors to be written inside a parent rule, reducing repetition and grouping component logic more clearly.

A baseline stylesheet that removes or reduces browser default styles so the project starts from a more controlled foundation.

A block made of a selector plus one or more declarations that define how matching elements should look.

The part of a CSS rule that decides which HTML elements the declarations apply to.

A geometric form built with CSS properties such as borders, gradients, border radius or transforms instead of using an image asset.

An intentionally selected collection of references, tools and practice sites organized so developers can find the right learning or debugging source faster.

A CSS variable declared with a `--name` syntax and consumed with `var(--name)`.

A theme variable such as background, surface or text color that changes between light and dark contexts.

Classification that tells the program what kind of value it is handling and how that value should be interpreted.

Element that provides suggested values for an input without forcing the user into a closed selection.

Pattern that delays a function call until activity stops for a defined amount of time.

Process of finding, understanding and fixing errors in a program by observing what actually happens during execution.

List created with `dl` to pair terms with their explanations.

HTTP method commonly used to remove a resource on the server.

A reusable named value that represents a design decision such as color, spacing, radius or typography.

Named design variables for things like color, typography, spacing and border radius.

An interface pattern where hidden content is revealed on demand through a trigger such as a button, summary or toggle control.

Declaration that tells the browser to interpret the document using modern HTML standards mode.

The normal order and spatial behavior the browser uses to lay out elements before special positioning or layout rules alter it.

Document Object Model. The browser representation of the HTML document as a tree of nodes that JavaScript can read and modify.

A filter function that creates a shadow from the visible shape of an element instead of from its rectangular box.

The speed pattern of a transition or animation, expressed with keywords such as `ease` or with a custom `cubic-bezier()` curve.

A complete HTML unit made of a tag and, when applicable, its content and closing tag.

A reusable shadow variable that represents one depth level in an interface, such as a base card state or a hover state.

Specific URL where an API exposes a resource or an operation.

Pattern where a parent element handles events for its children through bubbling.

Mechanism that coordinates the call stack, task queue and microtask queue in JavaScript runtimes.

Retry strategy where the waiting time grows after each failed attempt.

Minimal framework for building web servers and APIs with Node.js.

Combination of values, variables and operators that produces an evaluable result.

A conditional CSS query built with `@supports` that checks whether the browser understands a feature before applying related styles.

A block inside a repeating layout pattern that is intentionally given more size or emphasis than its neighbors.

Modern browser API used to make HTTP requests from JavaScript.

Form element used to group related controls into one semantic block.

The initial size of a flex item before free space is distributed or items are shrunk.

A Flexbox property that decides whether items stay on one line or wrap onto multiple lines when space runs out.

CSS layout model designed to distribute space and align items inside one dimension efficiently.

A layout approach that adapts continuously to available space instead of relying on fixed widths and too many rigid breakpoints.

A type sizing approach that scales smoothly across screen sizes, often using `clamp()` instead of abrupt jumps between breakpoints.

HTML structure used to collect and submit data entered by the user.

Browser API that reads form fields and builds a data structure ready to send or transform.

Part of web development that runs in the browser and includes structure, styling and user-facing behavior.

Reusable block of code that groups a specific task and can receive input data to produce a result.

A visual arrangement system for groups of images or media items, usually designed to balance consistency, scanning speed and rhythm.

Attribute that can be used on many HTML elements, such as `id`, `class`, `title`, `hidden` or `data-*`.

Approach where a rich experience is built first and then degrades acceptably in less capable environments.

A reusable CSS variable that stores a gradient declaration so the same visual treatment can be reused across components.

Layout system that organizes content into rows and columns.

A rectangular section of a Grid layout that can span multiple cells and be named for easier placement.

The perceived compactness of a Grid pattern based on track count, cell size and gap.

The space between two adjacent Grid lines, forming one row or one column in the layout.

A compact mobile navigation trigger typically represented by three horizontal lines.

The document section that stores metadata such as title, charset, viewport settings and linked resources.

A structural title element such as `h1` to `h6` that defines hierarchy inside the page.

JavaScript behavior where declarations are processed before code execution reaches their line.

HyperText Markup Language. Markup language used to structure content on the web.

Numeric code returned by a server to explain the outcome of an HTTP request.

HTML element used to embed another browsing context, such as a video player or external page.

Numeric position of an element inside an array.

Loop that never reaches a real stopping condition and keeps running without ending.

An SVG embedded directly in the HTML markup so its internal shapes can be targeted with CSS and JavaScript.

Form control element used to capture user data such as text, email, numbers or passwords.

A CSS shorthand that combines `top`, `right`, `bottom` and `left` into one property.

A CSS property that allows transitions and animations to interpolate intrinsic size keywords such as `auto`.

A size value such as `auto`, `min-content` or `max-content` that depends on layout and content rather than a fixed numeric length.

Inverted Triangle CSS. Method for structuring styles from generic, low-specificity layers to specific component rules.

Each individual repetition performed by a loop during its full cycle.

Programming language used to add logic, behavior and interactivity to web pages and web applications.

Lightweight data format used to exchange structured information between applications.

Inline semantic representation of a key or shortcut, usually marked up with the `kbd` element.

Named animation steps defined with `@keyframes` that describe how properties change over time.

Text element associated with a form control so users know what information the field expects.

A shadow composed of multiple `box-shadow` layers with different blur, spread and opacity values to create more realistic depth.

Technique that delays loading code or assets until they are actually needed.

Caption-like label that names the purpose of a `fieldset` group.

A gradient that transitions colors along a straight line and is often used for buttons, backgrounds and directional overlays.

Navigational connection created in HTML so users can move to another page, resource or section.

Structured group of related items represented in HTML with list elements such as `ul`, `ol` or `dl`.

Direct value written in code, such as a string, number, array or object.

Browser storage mechanism for persisting small string-based values across sessions.

Combination of several programming concepts inside one problem so it can be solved completely.

Structure that repeats an action or block of code while a rule remains true or until a traversal is complete.

The primary direction in a Flexbox layout, determined by `flex-direction`, along which `justify-content` distributes items.

The property that defines the image or gradient used to mask the visibility of an element.

A CSS function that resolves to the largest value from the list you provide.

A CSS rule that applies styles only when a condition such as width, orientation or user preference is true.

Metadata summary that describes the page for search and preview contexts.

Information about the document that helps browsers, search engines and tools understand how the page should be handled.

Element that represents a value within a known range, such as quality, risk or battery level.

A small animated response that gives feedback during a focused user action such as hover, click or focus.

Small typographic refinements such as line length, underline offset, decoration thickness or letter spacing that improve readability.

A CSS function that resolves to the smallest value from the list you pass in.

Small but complete exercise that brings several learning pieces together into one functional, verifiable artifact.

A reusable Sass block that groups multiple declarations and can optionally accept arguments before being included in components.

A responsive strategy where small-screen styles are written as the base layer and larger layouts are added progressively.

Design approach that starts with the smallest screens and progressively enhances larger layouts.

Browser API that watches DOM changes and lets your code react to them.

Special JavaScript value that means Not a Number.

The button that opens and closes a collapsed navigation menu in responsive layouts.

The `&` symbol used in nested CSS to reference the current parent selector.

Collection of DOM nodes returned by methods such as `querySelectorAll()`.

The default layout behavior in which elements take up space and influence the placement of other elements around them.

A popular stylesheet that preserves useful browser defaults while smoothing common inconsistencies across rendering engines.

Value used intentionally to show that there is currently no data or that a value is empty on purpose.

Structure that groups several related properties to represent one entity or real-world thing.

A navigation pattern where the menu lives outside the visible screen and slides in when activated.

Pagination model where the client requests items using an offset and a limit.

A modern CSS color space based on Lightness, Chroma and Hue, designed to behave more consistently with human perception.

Object-Oriented CSS. Methodology that encourages reusable styling patterns and separation of structure from skin.

Symbol or keyword that performs an operation on one or more values.

A variable-font axis that adjusts letterforms for better readability at different rendered sizes.

List created with `ol` when the sequence of the items matters.

Observable result that a program returns after processing the input.

A visual layer placed on top of media or content to reveal extra information, controls or emphasis.

Technique that divides large result sets into smaller pages instead of loading everything at once.

A block of text represented with the `p` element, usually used for one coherent idea or reading unit.

Name a function uses to represent the data it receives when it runs.

A Sass file meant to be imported into other Sass files so styles can be split into smaller, organized modules.

HTTP method commonly used to apply a partial update to an existing resource.

The repeated visual cadence created by varying size, spacing or emphasis across a layout pattern.

A CSS property that controls how strong the illusion of depth looks in 3D transformed elements.

A Grid shorthand that combines `align-items` and `justify-items` to align content inside each grid area.

Code that adds support for a modern feature in environments that do not implement it natively.

A browser API for showing and hiding lightweight overlays such as menus, panels or floating UI without building every behavior from scratch.

The CSS relationship created when an overlay points to a named anchor element with `position-anchor`.

The nearest ancestor with a non-static `position` value, used as the reference point for absolutely positioned descendants.

The reference box an absolutely positioned element uses to calculate where it should appear.

A CSS processing tool that transforms stylesheets during the build step through a plugin-based pipeline.

A PostCSS plugin bundle that lets you use modern CSS features and converts them into a more compatible output based on your target environment.

The `transform-style` value that allows child elements to keep their 3D position instead of being flattened.

Method on the event object that stops the browser's default action for that event.

Transformation or set of rules that a program applies to an input in order to produce an output.

Set of instructions that a machine can execute to perform a specific task.

Element that represents how much of a task has been completed, usually marked up with `progress`.

A strategy that starts from a solid, broadly compatible base and adds richer features only when the environment supports them.

Object that represents the future completion or failure of an asynchronous operation.

Named piece of data that belongs to an object.

The act of defining a custom property with `@property` so the browser knows its type, inheritance behavior and initial value.

JavaScript object that intercepts operations on another object, such as reading or writing properties.

A virtual CSS-generated element such as `::before` or `::after` that lets you add decorative boxes without changing the HTML.

Human-readable structured description of a solution before writing it in a real programming language.

HTTP method commonly used to replace or fully update a resource.

Bug that appears when the final result depends on which asynchronous operation finishes first.

The modern media query syntax that expresses comparisons like `(width >= 768px)` or `(600px <= width <= 1024px)` more directly.

Restriction that limits how many requests or actions can happen in a given period.

A user preference exposed through `prefers-reduced-data` that suggests lighter assets and fewer bandwidth-heavy enhancements.

A user preference exposed through `prefers-reduced-motion` that signals the interface should minimize animation and transitions.

A selector pattern that styles an element according to its relationship with descendants or nearby structure rather than only matching the element directly.

HTTP metadata sent with a request to describe how it should be processed.

Design approach where the interface adapts cleanly to different screen sizes and devices.

A table styled to remain usable on smaller screens through patterns such as horizontal scrolling or stacked rows.

API style that organizes resources and operations around HTTP methods such as GET, POST, PUT and DELETE.

Practice of repeating a failed request when the error may be temporary.

Value that a function sends back when it finishes so the rest of the program can reuse it.

A CSS value that resets a property back to the value it would have had before the current layer applied its override.

CSS preprocessor that adds features such as variables, nesting and reusable logic.

A script loading strategy that downloads in parallel and runs as soon as it is ready, without preserving order.

A script loading strategy that downloads in parallel but runs after HTML parsing finishes, preserving order.

A CSS feature that lets scroll containers snap their content to defined positions, making sliders and horizontal galleries feel more controlled on touch devices.

A timeline whose progress comes from the scroll position of a container instead of from elapsed time.

A support check written with `@supports selector(...)` to detect whether a browser understands a specific selector.

Use of HTML elements according to their meaning and role instead of choosing them only for appearance.

Process of converting data structures into a format that can be stored or transmitted.

Parent Grid rows or columns that are reused by child components through `subgrid` so multiple modules follow the same guides.

A lateral navigation pattern that keeps section links visible beside the main content, often used in documentation, dashboards or long lessons.

Scalable and Modular Architecture for CSS. System for organizing styles into clear categories.

Single Page Application. A web app that updates content dynamically without doing a full page reload on every interaction.

Distribution of space between and inside interface elements.

An isolated layering context that controls how `z-index` works among a set of elements.

A page-layout pattern where the footer stays at the bottom of the viewport on short pages without overlapping content.

A header that remains visible near the top edge of the viewport while the page scrolls, usually through `position: sticky`.

The offset value, such as `top: 0`, at which a sticky element stops scrolling normally and starts sticking.

Method on the event object that prevents an event from continuing its propagation through the DOM.

Restricted JavaScript mode that catches certain mistakes earlier and disables some risky legacy behaviors.

An SVG stroke setting that defines the visible dash pattern along a path and is often paired with animation for draw effects.

Machine-readable metadata, often provided with JSON-LD, that helps describe what the page content represents.

A container query that reacts to a style value, such as a custom property, instead of reacting only to size.

A Grid feature that lets a child grid inherit the row or column tracks of its parent for tighter alignment across nested components.

HTML structure used to represent data organized in rows and columns.

Short label that explains what a table represents as a whole.

Header cell marked up with `th` to describe a row or column in a table.

The markup syntax used to define an HTML element, usually with an opening form and often a closing form.

Utility-first CSS framework for building custom interfaces quickly with small reusable classes.

Temporal Dead Zone. Period in which a `let` or `const` variable exists but cannot be accessed before its declaration line runs.

A CSS property that adds shadow to text, often to improve readability on images or expressive backgrounds.

A `text-wrap` value that distributes short text across lines more evenly to avoid awkward final lines.

A `text-wrap` value that improves paragraph endings by trying to avoid lonely final words.

Pattern that limits how often a function can run within a time interval.

A reduced visual preview image used inside cards, galleries or listings to represent larger content.

Maximum time the client allows an operation or request to take before treating it as failed.

Step-by-step follow-up of execution order and program state to understand how a result is produced.

The pivot point around which a transformed element rotates, scales or skews.

Build optimization that removes unused exported code from the final bundle.

System of text sizes built on consistent proportions.

A custom property whose value type has been declared explicitly, allowing validation and smoother interpolation.

Practice of choosing and organizing type to improve readability, hierarchy and tone.

Value that indicates a variable exists but does not yet hold an assigned value at that moment.

List created with `ul` when the order of the items does not matter.

API for reading and building query string parameters in a structured way.

A styling philosophy that composes interfaces from many small single-purpose utility classes instead of relying mainly on custom semantic CSS selectors.

Process of checking whether input data meets the expected rules before it is accepted or sent.

A pseudo-class such as `:valid`, `:invalid` or `:required` that reflects native HTML form validation state.

Name that represents a value or state a program needs to store, read or update later.

A font file that contains a range of styles or axes, allowing fine-grained control over weight, width, slant or optical size.

A browser-specific prefix such as `-webkit-`, `-moz-` or `-ms-` added to a property or value during a feature rollout period.

HTML media element used to embed playable video content in a page.

A scroll-linked timeline based on how a specific element enters, covers or exits the viewport or another scroll area.

A browser-managed animation between an old UI state and a new one, usually triggered when content or navigation changes.

The CSS property used to identify a specific element so it can participate independently in a view transition.

A positioning relationship in which an element stays tied to the browser viewport instead of to the document flow or a local container.

An HTML meta tag that tells mobile browsers to use the real device width so responsive layouts behave correctly.

The arrangement of shapes, layers and spacing so an interface element or illustration feels balanced and readable.

Browser-provided interface that extends JavaScript with capabilities such as networking, storage and DOM access.

Bundler that analyzes project dependencies and produces optimized files for the browser.

Intentional empty space that improves readability, rhythm and visual hierarchy.

A CSS hint that tells the browser which properties of an element are likely to change soon, so it can prepare internal optimizations in advance.