← Back to React

React Glossary

Key terms from the React course, linked to the lesson that introduces each one.

288 terms.

A

Accordions
The accordion container manages which sections are open. Each <AccordionItem> needs access to that state to render correctly. Each <AccordionTrigger> needs to update that state. All these pieces are tightly related.
Lesson 1087 — When to Use This Pattern
action
The action is the second parameter, and it's typically a plain JavaScript object that describes what happened in your application.
Lesson 756 — Action Parameter: Instruction ObjectLesson 1484 — The useActionState Signature
Action creators
Action creators are simple functions that return action objects.
Lesson 765 — Action Creators: Functions That Return Actions
Actions
Actions are functions you define inside your store that call set() internally.
Lesson 1711 — Actions Inside the Store
Analogy
Don't buy a sports car to drive two blocks to the store. If the journey is already instant, optimization is wasted effort.
Lesson 1038 — Dynamic Hook Calls in Code GeneratorsLesson 1441 — When NOT to Use useTransition
app-level error boundary
An app-level error boundary is the ultimate safety net at ground level—it catches any uncaught render error before it reaches the user as a blank white screen.
Lesson 1308 — App-Level Boundary: The Safety Net
Async code without proper waiting
A setTimeout, Promise, or API call updates state after your test ends
Lesson 2149 — act() Warnings and What They Mean
atom
In Jotai, an atom is the smallest unit of state.
Lesson 1720 — Creating Atoms with atom()
atom family
An atom family is a factory function that creates atoms on-demand based on a parameter (like an ID).
Lesson 1726 — Atom Families for Dynamic Collections
Authentication status
Nearly every component might need to know if a user is logged in
Lesson 810 — Context for Truly Global State
automatically
This function gets called automatically with the DOM node when the element mounts, and with null when it unmounts.
Lesson 720 — The Ref Callback Pattern

B

Babel
Babel is a transpiler—it converts modern JavaScript (including JSX) into older JavaScript that all browsers understand.
Lesson 54 — Webpack from Scratch
barrel
A barrel is an index.js file that re-exports everything from a folder.
Lesson 65 — Barrel Exports: index.js for Cleaner Imports
basic API
The basic API is simple: your component accepts a reducer function as a prop.
Lesson 1175 — The Basic State Reducer API
Batching
Batching is React's optimization where multiple state updates that happen close together are grouped into a single re-render.
Lesson 417 — What is Batching and Why It Matters
before
vi.mock() hooks into Vitest's module system to intercept this process—it must be called before the module you're testing imports the dependency.
Lesson 2076 — Vitest's vi.mock() Basics
Better alternatives
The standard Profiler workflow—recording interactions and filtering by commit duration—proved sufficient for most debugging
Lesson 2217 — Using the Interactions Tab (Legacy)
Better way
You call ahead while driving. Your coffee is ready when you arrive. Total: 5 minutes.
Lesson 643 — The Waterfall Problem
Blocked main thread
Blocked main thread means the UI can't respond to user input during the flush
Lesson 447 — The Performance Cost of flushSync
Blogs
Posts don't change after publishing (or change rarely enough that rebuilding is acceptable)
Lesson 1677 — SSG Trade-offs: Speed vs Freshness
BrowserRouter
BrowserRouter is the classic component-based approach.
Lesson 1844 — createBrowserRouter vs BrowserRouter
Bug Reproduction
A user reports a bug but can't explain the steps. With Redux DevTools, they export their session. You import it, hit "play," and watch the exact sequence of actions that triggered the problem—no guessing required.
Lesson 1744 — Time-Travel Debugging and Audit Requirements
Build Logs
The compiler can log which components it optimized and which it skipped. Look for warnings like "Could not optimize ComponentName due to..." in your build output.
Lesson 1510 — Debugging Compiler Output
bundle budget
A bundle budget is your performance contract: specific size thresholds that trigger action when exceeded.
Lesson 1421 — Bundle Budget Strategy: Setting Thresholds
Bundle size
The entire CSS-in-JS library ships to every user (~15-30 KB for styled-components, ~8-15 KB for Emotion).
Lesson 1931 — Performance Tradeoffs: Runtime Style Injection

C

Caching
Once fetched, data is reused across your app without refetching
Lesson 596 — Why Libraries Handle This Better
Calendars
Rows are weeks, columns are days—only visible weeks render.
Lesson 2299 — Virtualized Grids and Multi-Column Layouts
Cascading patterns
A parent component with many wide children suggests a rendering cascade where updates flow through multiple layers unnecessarily.
Lesson 2223 — Reading the Profiler Flamegraph
child components
In compound components, you have a special relationship where a parent component manages the overall state and behavior, while child components are specialized pieces that render specific parts of the UI.
Lesson 1078 — The Parent + Children Relationship
children
The children are specialized staff—the host, server, and chef.
Lesson 1078 — The Parent + Children RelationshipLesson 1338 — The Suspense Component API
Class component syntax
Class component syntax is the clearest sign:
Lesson 326 — Documentation and Tutorials: Recognizing Outdated Content
className
Best when transitions are fixed design choices
Lesson 1958 — Adding transition Property to React Components
Cleaner components
Less noise from optimization hooks means easier-to-read code
Lesson 1513 — Long-Term Impact on React Development
Cleaner URLs
/dashboard is simpler than /dashboard/home
Lesson 1836 — Index Routes: Default Child Content
cleanup function
A cleanup function is an optional function you can return from a useEffect.
Lesson 550 — What Cleanup Functions Are
Client state
Client state is fundamentally different:
Lesson 1704 — Server State vs Client State Separation
Client-side rendering
Think of it like a restaurant: Client-side rendering is ordering ingredients delivered to your home—you cook the meal yourself.
Lesson 1630 — What Server-Side Rendering Actually Means
closure
The function captures all the variables it references at that moment — this is called a closure.
Lesson 883 — Stale Closures in Memoized Functions
Co-locating
Co-locating means keeping multiple components in the same file.
Lesson 202 — Co-locating Helper Components
Co-location
Co-location means placing your context provider as close as possible to the subtree that actually needs it.
Lesson 841 — Co-locating Context with Its Consumers
Cognitive load
Cognitive load is the mental effort required to understand code.
Lesson 745 — The Cognitive Load of Many useState Calls
Cognitive overhead
Readers must understand why something is memoized
Lesson 2283 — The Trap of Memoizing Everything
Colocation
Colocation means keeping files that belong together physically close in your folder structure.
Lesson 209 — Colocating Tests and Styles with Components
Color-coded flame graphs
gray means fast, yellow/red means slow
Lesson 70 — Profiler Tab: Recording Performance Sessions
Combinations
Show banner when both isLoggedIn and hasBanner are true
Lesson 1143 — Conditional Rendering of Prop Content
commit
In React profiling terminology, a commit represents a single render pass—from the moment React starts calculating what needs to change through to when those changes are actually applied to the DOM.
Lesson 2211 — Understanding Commit Information
Comparing
The director checks if this take differs from the last one
Lesson 411 — Render Does Not Mean DOM Update
Complex child hierarchies
Deep nesting means more measurements
Lesson 1987 — Layout Animation Performance
component
The React component to render when this route matches
Lesson 1876 — Defining Routes with createRoute
component composition
This is called component composition, and it's the fundamental pattern for building React applications.
Lesson 182 — Components Can Call Other Components
Component name
The actual function or class name from your code
Lesson 68 — Components Tab: Inspecting the Component Tree
Component state
Show errorMessage prop only when hasError is true
Lesson 1143 — Conditional Rendering of Prop Content
Component-level
Component-level is for truly independent widgets that don't distract when loading separately.
Lesson 1383 — Suspense Boundary Placement Patterns
Components that didn't need the data
A component using only user.name from context still re-renders when user.preferences changes
Lesson 2322 — Measuring Context Performance Impact
Composition
Composition is like handing someone a locked suitcase—they just carry it without needing to know the contents.
Lesson 274 — Preview of Solutions: Composition
Compound Components
The consumer controls which pieces to use and their order
Lesson 1153 — What is Inversion of Control in React?
Computed totals
If you have prices in state, the sum is derived
Lesson 663 — What is Derived State?
Conditional rendering logic
If a UserProfile should only show an "Edit" button when isOwner={true}, verify that button appears in one case and is absent in the other.
Lesson 2184 — Unit Tests for Component Logic
Consumer
Consumer is how components originally accessed that value (before hooks).
Lesson 789 — The Context Object Structure
consumer-provided reducer override
In the State Reducer pattern, the consumer-provided reducer override is where the magic happens.
Lesson 1177 — Consumer-Provided Reducer Override
container
Imagine a restaurant kitchen: the container is like the chef who handles all the recipe logic, ingredient prep, and cooking decisions.
Lesson 191 — Container and Presentational ComponentsLesson 2043 — The render Function from RTL
Context
Context is XState's solution: an object that lives inside your machine, traveling alongside your finite states.
Lesson 1754 — Context: Extended State in Machines
Context's limit
No built-in selectors means you can't subscribe to part of an object without re-rendering.
Lesson 1718 — Zustand vs Context vs Redux: The Tradeoffs
controlled component
A controlled component is one where React state is the single source of truth for the component's current value.
Lesson 450 — What Makes a Component 'Controlled'
controlled text input
A controlled text input is an <input> element whose value is explicitly managed by React state.
Lesson 455 — Controlled Text Inputs
Core functionality
The main feature your app is built around (e.g., posting content, booking appointments)
Lesson 2183 — E2E Tests Cover Critical User Journeys
Core Web Vitals
Google's Core Web Vitals are three standardized metrics that capture the moments users care about most:
Lesson 2258 — Core Web Vitals: LCP, FID, CLS
createBrowserRouter
createBrowserRouter is the newer function-based approach that creates a router object before rendering.
Lesson 1844 — createBrowserRouter vs BrowserRouter
CSS Modules
CSS Modules are regular CSS files with a twist: the build tool (Webpack, Vite, etc.) transforms every class name into a unique identifier.
Lesson 1900 — What CSS Modules Are
currentTarget
currentTarget is the element you attached the handler to.
Lesson 2354 — The currentTarget vs target Distinction
custom hook
A custom hook is just a JavaScript function with two distinguishing characteristics:
Lesson 958 — What Makes a Custom Hook

D

data
The parsed GraphQL response when successful
Lesson 1823 — useQuery Hook for Data Fetching
Data fetching with Suspense
Data fetching with Suspense is the tricky part.
Lesson 1346 — The Suspense-Ready Ecosystem
Date stamps matter
Posts from 2018 or earlier are almost certainly pre-hooks. Even 2019 content might be outdated depending on the publish month (hooks released February 2019).
Lesson 326 — Documentation and Tutorials: Recognizing Outdated Content
Debouncing
Debouncing means waiting until the user stops typing for a brief moment (say, 300ms) before actually updating state.
Lesson 477 — Mitigating Cost: Debouncing State Updates
Debugging
Temporarily disable optimization to isolate whether the compiler is causing issues
Lesson 1507 — The 'use memo' Directive (Opt-Out)
Declaration merging
Declaration merging is interface's superpower.
Lesson 2330 — Props Interface vs Type Alias
dependency array
The dependency array is the optional second argument to useEffect:
Lesson 536 — What is the Dependency Array?
Depth harms clarity
/app/workspace/project/settings/billing/history is exhausting
Lesson 1842 — When to Nest vs Flatten Routes
Derived state
Derived state is any value that can be computed directly from existing props or state, rather than stored in its own separate state variable.
Lesson 663 — What is Derived State?
dirty checking
Behind the scenes, Angular used a technique called dirty checking.
Lesson 21 — Angular 1.x: Two-Way Binding and Digest Cycles
discriminated union
A discriminated union is a TypeScript pattern where you define multiple specific types, each with a unique literal value in a common property (usually type).
Lesson 762 — TypeScript: Discriminated Unions for Actions
DispatchContext
Think of a restaurant: the StateContext is the menu board that changes daily (you check it to see what's available), while DispatchContext is the ordering counter—it never moves.
Lesson 778 — Creating the Context Pair: State and Dispatch
Domain knowledge
You know a complex calculation is stable based on business logic the compiler can't understand
Lesson 1508 — Compiler vs Manual: Performance Comparison
Dot notation
Quick access, fewer properties, or when the item name adds clarity (user.email is self-documenting).
Lesson 143 — Accessing Item Data in .map()
Drilling
Drilling is like telling each person in a chain exactly what's inside so they can repack it.
Lesson 274 — Preview of Solutions: Composition
Dropdowns
A <Dropdown> manages open/closed state. The <DropdownTrigger> needs to toggle it. The <DropdownMenu> needs to read it. The <DropdownItem> components might need to close the dropdown when clicked.
Lesson 1087 — When to Use This Pattern

E

early return
An early return means checking for a condition at the start of your component and returning immediately if it's met.
Lesson 186 — Early Returns for Conditional Logic
ease
The easing function (e.g., "easeIn", "easeOut", "linear")
Lesson 1970 — The transition Prop: Controlling Animation Timing
Easier to debug
The value is right there where you can see it
Lesson 653 — The Fix: Compute During Render
Easier to reason about
The data lives next to the logic that uses it
Lesson 1680 — The Local-First Principle
effect
An effect is code that runs because something changed and needs to stay synchronized.
Lesson 657 — Events vs Effects: The Fundamental Distinction
Effects
Effects are the cleaning crew who work after service ends
Lesson 675 — Why useEffect is Wrong for Click Handlers
esbuild
esbuild is a newer transpiler written in Go, making it 10-100x faster than Babel.
Lesson 79 — The Role of Babel and Modern Transpilers
ESLint Plugin
The eslint-plugin-react-compiler shows inline warnings when code patterns prevent optimization—right in your editor as you type.
Lesson 1510 — Debugging Compiler Output
event
An event is code that runs because the user did something specific.
Lesson 657 — Events vs Effects: The Fundamental Distinction
Event handlers
Event handlers are the line cooks who respond to orders immediately
Lesson 535 — Why Effects are Often OverusedLesson 675 — Why useEffect is Wrong for Click Handlers
Every component needs interactivity
Your entire page is buttons, charts, drag-and-drop interfaces, and real-time updates
Lesson 1652 — When to Skip SSR: SPAs and Hydration-Heavy Apps
Exact strings
Exact strings are strict by default—whitespace and case must match perfectly.
Lesson 2062 — TextMatch: String, Regex, and Function

F

fallback
A React element to display during loading (spinners, skeletons, "Loading..." text)
Lesson 1338 — The Suspense Component API
Familiar API
Vitest intentionally mirrors Jest's API (describe, it, expect), so migration is straightforward. You get modern tooling without relearning fundamentals.
Lesson 2024 — Why Vitest Over Jest for Modern React
Faster parsing
The browser processes less code upfront
Lesson 1384 — What Code Splitting Is and Why It Matters
Feature-specific components
Feature-specific components are like specialized tools (a sushi rolling mat, pasta maker) that only matter for certain recipes—those stay near where you use them.
Lesson 63 — The Components Folder: Shared vs Feature-Specific
Filtered lists
You have an array in state and a search term—the filtered results are derived
Lesson 663 — What is Derived State?
Flexible ordering
The component controls layout, not insertion order
Lesson 1130 — Props as Slots: The Basic Pattern
formAction
A wrapped version of your action function that you pass to a form's action prop. This wrapper handles the state transitions automatically.
Lesson 1484 — The useActionState Signature
full E2E tests
But in React apps, pure unit tests (testing components in complete isolation) create brittle test suites that break during refactors, while full E2E tests are slow and flaky.
Lesson 2135 — The Integration Test Sweet Spot
Full failure
Full failure is appropriate for critical features (checkout forms, authentication).
Lesson 1319 — Degraded UI vs Full Failure
Function Children
The consumer decides how to transform data into UI
Lesson 1153 — What is Inversion of Control in React?
function component
A function component is simply a JavaScript function that returns JSX.
Lesson 177 — What is a Function Component?
functional update syntax
This is called functional update syntax.
Lesson 370 — Functional Update Syntax

G

generic context factory
A generic context factory is a function that takes a type parameter and returns everything you need for a fully-typed context: the provider component, the consumer hook, and proper type safety.
Lesson 2379 — Generic Context Factories
getByTestId
getByTestId is your escape hatch when semantic locators aren't practical.
Lesson 2164 — Locators: Finding Elements the Right Way
Granularity
The compiler can memoize at a finer level than you'd reasonably do by hand. It might memoize individual JSX expressions or small computation branches, which would feel excessive to write manually.
Lesson 1508 — Compiler vs Manual: Performance Comparison
guard clause
A guard clause is a condition that checks for a special case and exits early.
Lesson 128 — Early Returns for Guard Clauses

H

Hard to test
Mocking timings, race conditions, and cleanup in tests is painful.
Lesson 605 — The Problem with Manual useEffect Data Fetching
Headless
Headless is the philosophy that ties these patterns together—maximum logic reuse, zero style opinions.
Lesson 1183 — What 'Headless' Means: Logic Without Styling
High-frequency cascades
A parent component re-renders 10+ times per second, triggering expensive child tree updates
Lesson 2237 — Tracking vs Fixing: When to Act
High-frequency updates
A WebSocket connection updating every 100ms will hammer all context consumers, even those displaying static data derived from other parts of the context value.
Lesson 2257 — Comparing Context Overhead to Alternatives
Highly Interactive Apps
Think Figma, code editors, or complex dashboards. These apps are tools, not content. Users expect to wait briefly while the app loads, then enjoy zero-latency interactions. Every click, drag, and keystroke happens instantly because the entire interface is already hydrated.
Lesson 1673 — CSR Trade-offs: Interactivity vs Initial Load
Hiring and Collaboration
React developers are abundant. If you're building a team, you'll find far more candidates with React experience than Svelte or Solid. This isn't about React being "better"—it's about market reality.
Lesson 30 — Ecosystem Size as a Decision Factor
Hook order or presence
Whether useState or useReducer is used
Lesson 2115 — What Are Implementation Details?
Hot reloading
Class methods are harder to hot-swap during development without losing state
Lesson 311 — Classes Confuse Both People and Machines

I

imperative choreography
GSAP timelines (gsap.timeline()) let you script animations like a movie director: "Element A enters, waits 0.5s, then B and C animate together while A continues, pause here for user input, then resume." This imperative choreography is GSAP's superpower.
Lesson 2008 — When GSAP Beats Framer Motion: Timeline Complexity
Implementation details
Implementation details are the internal mechanics of how your component works—things like state variable names, hook calls, private functions, effect dependencies, and component structure.
Lesson 2115 — What Are Implementation Details?
index
The original index from your full data array
Lesson 1280 — The Virtual Items Array
index route
An index route is a special route that renders by default when only the parent path matches.
Lesson 1836 — Index Routes: Default Child Content
Initial load delays
The page freezes while rendering
Lesson 1277 — When Virtualization is Worth It
Initial value
The argument to useState(initialValue) replaces what you assigned in the constructor
Lesson 316 — From constructor State to useState
initialState
The starting value for your state before any action runs. This could be an empty object, null, or any initial data structure you need.
Lesson 1484 — The useActionState Signature
Inline arrow functions
Inline arrow functions are convenient when you need to pass arguments: () => handleClick(id)
Lesson 234 — Inline Arrow Functions vs Stable References
Installation
Installation is straightforward via npm or yarn:
Lesson 1769 — Installation and QueryClient Setup
interaction-based lazy loading pattern
The interaction-based lazy loading pattern means loading these components only when the user clicks, hovers, or otherwise signals intent.
Lesson 1404 — The Interaction-Based Lazy Loading Pattern
isRefetching
True whenever a fetch is happening in the background while cached data is already available
Lesson 1791 — The isRefetching Flag
It's infrequent
A component that re-renders once on route change doesn't need memoization
Lesson 2237 — Tracking vs Fixing: When to Act

K

key
A stable identifier for React's reconciliation
Lesson 1280 — The Virtual Items Array

L

layout route
A layout route is a parent route that doesn't render a specific page itself—instead, it renders shared UI (like a header or sidebar) and uses <Outlet /> to display whichever child route is currently active.
Lesson 1834 — Creating a Layout Route with Outlet
Lazy import
You wait until the exact moment the component is needed (like when a modal opens). This keeps your initial bundle minimal, but users experience a brief loading delay.
Lesson 1410 — The Prefetch/Import Timing Tradeoff
Lazy init
Lazy init is choosing expensive materials only once when you build the foundation (mount)
Lesson 393 — Lazy Init vs useMemo: Different Tools
Lifting state up
Lifting state up means hoisting state to <App>, then threading props through multiple layers that don't care about them.
Lesson 1700 — The Problem of Shared State Across Distant Components
List animations
Items move naturally when others are added/removed
Lesson 1984 — Layout Animations with layout Prop
loader
A loader is a function you attach to a route definition.
Lesson 1843 — The Data Router Paradigm Shift in v6.4
loading
Boolean indicating if the query is in-flight
Lesson 1823 — useQuery Hook for Data Fetching
Local context
Local context means wrapping only a specific subtree of components with a provider, rather than your entire application.
Lesson 817 — Local Context for Component Subtrees
Logging priority
Page errors are high-priority, widget errors are informational
Lesson 1316 — Contextual Error Messages by Location
Long-Term Stability
Companies invest heavily in React. Meta (Facebook) depends on it for their core products. This means the framework isn't going anywhere soon, reducing the risk that you'll need to rewrite your app in five years.
Lesson 30 — Ecosystem Size as a Decision Factor

M

Maintenance
Refactoring is straightforward—just follow the chain
Lesson 269 — When Drilling Isn't a Problem
Maintenance burden
Each boundary is code to write, test, and maintain. Twenty boundaries means twenty potential places for logging logic to drift out of sync.
Lesson 1312 — Avoiding Boundary Overuse
Marketing sites
Your homepage, about page, pricing page—these rarely change, and when they do, a rebuild is fine
Lesson 1677 — SSG Trade-offs: Speed vs Freshness
Measurable performance impact
The Profiler shows a commit taking >16ms (causing dropped frames)
Lesson 2237 — Tracking vs Fixing: When to Act
Memoization
Memoization is exactly this strategy applied to computation: instead of recalculating the same result every time, you cache (store) the result the first time and return the cached version when the inputs haven't changed.
Lesson 864 — What is Memoization?
memoizedState
the hook's current value (state, memo result, etc.)
Lesson 1013 — The Fiber Tree and Hook Chains
mouse tracker
A mouse tracker is the classic render prop example because mouse position is stateful logic (tracking coordinates) that's completely separate from presentation (how you display those coordinates).
Lesson 1051 — Classic Example: Mouse Position Tracker
Multiple props
Multiple props are being threaded through the same path
Lesson 809 — The Prop Drilling ThresholdLesson 1686 — The Prop Drilling Pain Threshold
Mutations
Mutations are more powerful in TanStack Query with built-in optimistic update patterns, but require more setup than SWR's simpler approach.
Lesson 1811 — Migration Considerations: SWR to TanStack Query

N

name
A string identifying this slice (e.g., "counter")
Lesson 1732 — Slices: State + Reducers + Actions Together
next
a pointer to the next hook in the chain
Lesson 1013 — The Fiber Tree and Hook Chains
No ESLint configuration file
If .eslintrc or eslint.config.js is missing, create one and extend the recommended React config
Lesson 1024 — Integration with Modern Tooling (Vite, Next.js)
No Provider
Atoms are global, shared across the whole app
Lesson 1727 — The Provider Component (When Needed)
No static optimization
Because styles are in JavaScript, build tools can't extract, deduplicate, or preload them as separate .css files.
Lesson 1931 — Performance Tradeoffs: Runtime Style Injection
No user impact
If users can't perceive the slowness, your time is better spent elsewhere
Lesson 2237 — Tracking vs Fixing: When to Act
Non-critical
The app remains useful even if this feature is temporarily down
Lesson 1310 — Feature-Level Boundaries
normalizer
Defines how whitespace/casing is normalized before matching
Lesson 2063 — Query Options: exact, normalizer, hidden

O

Observable
This is when you'd actually see changes appear in the browser
Lesson 412 — The Commit Phase: Applying Changes to the DOM
onAllReady
Every single dish is plated and ready. Nothing's in the kitchen anymore.
Lesson 1636 — The onShellReady and onAllReady Callbacks
onShellReady
The table is set, the ambiance is ready, guests can sit down. The appetizers are still cooking, but the experience can begin.
Lesson 1636 — The onShellReady and onAllReady Callbacks
Opt-in children
Opt-in children means you only install doors where they belong, making the architecture's intent obvious at a glance.
Lesson 2394 — Children: Opt-In vs Implicit
Other effects
also run after the DOM is ready
Lesson 715 — Accessing current After Mount

P

parent
Think of it like a restaurant: the parent is the restaurant manager who coordinates reservations, seating arrangements, and overall flow.
Lesson 1078 — The Parent + Children Relationship
Parent has data the content needs
A list component passing each item's data to render functions
Lesson 1149 — When Render Props Win: Dynamic Behavior
path
The URL segment for this route (like "/about" or "/users/$userId")
Lesson 1876 — Defining Routes with createRoute
Performance
Re-rendering is usually fast, but it's not free. Batching prevents unnecessary work—React only recalculates your component tree and updates the DOM once instead of multiple times.
Lesson 151 — Keys Preserve Component IdentityLesson 417 — What is Batching and Why It Matters
Performance cost
Stringifying large objects on every render is expensive
Lesson 639 — JSON.stringify as a Last Resort
Performance profiling
Measuring actual impact by comparing optimized vs unoptimized
Lesson 1507 — The 'use memo' Directive (Opt-Out)
Prefetching
Prefetching means loading chunks in advance during idle time.
Lesson 2290 — Prefetching Split Chunks
presentational component
The presentational component is like the waiter who beautifully plates and serves the food—they don't cook, they just present what they're given.
Lesson 191 — Container and Presentational Components
Preserving return-to URLs
Preserving return-to URLs means remembering their original destination and completing their interrupted trip.
Lesson 1870 — Preserving Return-To URLs
Product pages
Individual product details that are stable
Lesson 1677 — SSG Trade-offs: Speed vs Freshness
Profiler
The Profiler is a tab in React DevTools (the browser extension) that records your app's rendering behavior.
Lesson 70 — Profiler Tab: Recording Performance SessionsLesson 416 — Visualizing Renders with React DevTools Profiler
Progressive disclosure
Progressive disclosure is your friend: provide sensible defaults that work out-of-the-box, but allow power users to override specific behaviors through props or slots when needed.
Lesson 1154 — The Flexibility vs Simplicity Tradeoff
progressive enhancement
This approach is called progressive enhancement: start with something that works everywhere (basic HTML), then optionally add JavaScript for a nicer experience.
Lesson 32 — Simple Forms and Progressive EnhancementLesson 1086 — Advantages Over Monolithic ComponentsLesson 1611 — The action Prop on Forms
Progressive hydration on interaction
Progressive hydration on interaction means delaying hydration until the user actually tries to interact with that component—clicking a button, hovering, focusing an input, etc.
Lesson 1649 — Progressive Hydration: Hydrating on Interaction
Prop conditions
Render sidebar only if showSidebar prop is true
Lesson 1143 — Conditional Rendering of Prop Content
prop drilling
This tedious pattern is called prop drilling.
Lesson 787 — What is Context and Why It Exists
prop getter
A prop getter is just a function that returns an object.
Lesson 1166 — Prop Getter Basics: Returning an Object
Prop getters
Prop getters are functions that return a pre-configured object of props.
Lesson 1164 — What is the Prop Getters Pattern?
Props
Props are like instructions from a parent: "Wear this jacket today." The child doesn't get to change what jacket was chosen.
Lesson 228 — Props vs State: Who Owns the Data
Provider
Provider is a component that wraps part of your tree and supplies a value.
Lesson 789 — The Context Object Structure
pure function
A pure function is predictable: given the same inputs, it always returns the same result.
Lesson 179 — Components are Pure Functions of Props

Q

queryKey
The exact key used for this query
Lesson 1780 — Query Function Context and Signals

R

Ranked chart
A sorted list of slowest components first
Lesson 416 — Visualizing Renders with React DevTools Profiler
Rarely changing data
If props update once per user session, drilling is simpler than any state solution.
Lesson 2257 — Comparing Context Overhead to Alternatives
React DevTools Profiler
The React DevTools Profiler is your measurement tool.
Lesson 844 — Measuring Impact with React DevTools Profiler
react-virtualized
react-virtualized is the older, feature-rich library.
Lesson 2296 — React Window vs React Virtualized
react-window
react-window is the newer, lighter, and more focused library.
Lesson 2296 — React Window vs React Virtualized
ReactElement
Rarely used explicitly—it's the technical type behind JSX, but JSX.Element or ReactNode are clearer choices.
Lesson 1135 — Type Safety for Slot PropsLesson 2338 — Typing Component Return Values
ReactNode
The broadest type, accepts anything React can render: JSX elements, strings, numbers, arrays, fragments, null, undefined, and booleans. This is your go-to for most slot props.
Lesson 1135 — Type Safety for Slot PropsLesson 1145 — Type Safety with JSX Props
Readability
Multiple variables are often clearer
Lesson 384 — Performance: Object vs Multiple Variables
Receives
The initialArg (second parameter to useReducer)
Lesson 773 — init Function Signature and Arguments
recipe
A recipe is vanilla-extract's answer to runtime style variants.
Lesson 1940 — Dynamic Runtime Styles with Recipes
reconciliation
Instead, React uses a process called reconciliation — a smart comparison algorithm (also called "diffing") that looks at the old virtual DOM tree and the new virtual DOM tree side-by-side to find the minimal set of changes needed.
Lesson 13 — Reconciliation: React's Diffing AlgorithmLesson 171 — How Stable Keys Enable ReconciliationLesson 408 — The Virtual DOM (Reconciliation)
reducer
A reducer is a pure function that takes two arguments—the current state and an action object—and returns the next state.
Lesson 754 — Reducer Function: (state, action) => newState
reducers
An object where each key becomes both a reducer case AND an auto-generated action creator
Lesson 1732 — Slices: State + Reducers + Actions Together
ref
A ref is like a box that holds a mutable value in its .current property.
Lesson 398 — useRef for Mutable Current Values
Refs
Refs are like quietly updating a Post-it note on your desk.
Lesson 498 — Refs Don't Trigger Re-renders
Removing items from lists
If a list item component is removed, any state it held is gone forever.
Lesson 363 — Unmounting Destroys State
render phase
In the previous lesson, you learned that the render phase is where React calculates what needs to change by comparing the old and new virtual DOM.
Lesson 415 — Why Renders Are Usually FastLesson 428 — Render Phase: Pure CalculationLesson 429 — Commit Phase: Applying Changes to the DOMLesson 431 — Why Effects Can't Run During Render
render prop
A render prop is a function that you pass as a prop to a component, and that component calls your function to determine what it should render.
Lesson 275 — What is a Render Prop?Lesson 276 — Basic Render Prop ImplementationLesson 1042 — What is a Render Prop?
Render props
Render props are dynamic: you pass in a function that the component calls with data.
Lesson 1136 — Slots vs Render Props: The Tradeoff
Rendering
The actors perform the scene again
Lesson 411 — Render Does Not Mean DOM Update
Resetting
Resetting means clearing the error state so the component tree can try rendering again.
Lesson 1305 — Resetting Error Boundaries
Resumability
Resumability is Qwik's radical alternative: instead of re-running components on the client, Qwik serializes the entire application state (component boundaries, event listeners, closures) directly into the HTML.
Lesson 1651 — Resumability: Qwik's Alternative to Hydration
Review
Changes to page interactions are visible in Page Object diffs, not scattered across test files
Lesson 2199 — Page Objects in CI: Keeping Tests DRY
right now
Whatever value that Provider has in its value prop right now is what useContext returns to you.
Lesson 801 — useContext Returns the Current Value
route context
In TanStack Router, route context is a way to pass shared, typed data down through your route hierarchy.
Lesson 1883 — Route Context and beforeLoad
Route-level splitting
Route-level splitting means creating separate bundles for each major route in your application.
Lesson 1423 — Route-Level Splitting: The Sweet Spot
Runtime safety
Clear error messages if components are used incorrectly
Lesson 1094 — Type-Safe Context for Compound Components

S

Scenario A
A simple text counter component renders 50 times during an animation. Each render takes 0.5ms. Total time: 25ms.
Lesson 2270 — Measuring Render Count vs Render Time
Scenario B
A complex data table renders once when a user clicks "Load More". That single render takes 200ms.
Lesson 2270 — Measuring Render Count vs Render Time
Scroll lag
The list doesn't keep up with scrolling
Lesson 1277 — When Virtualization is Worth It
Self-contained
A calendar widget, chat panel, or file uploader
Lesson 1310 — Feature-Level Boundaries
Server Actions
Server Actions are optimized for mutations triggered by React components—form submissions, button clicks, or any user interaction originating from your UI.
Lesson 1609 — When to Use Server Actions vs API Routes
Server-first data flow
Server-first data flow means your data originates at the top of your tree in Server Components that run on the backend.
Lesson 1574 — The New Mental Model: Server-First Data Flow
shallow immutability
This is called shallow immutability—the reference is protected, but the nested data isn't.
Lesson 229 — Shallow Immutability: Objects and Arrays
Shared components
Shared components are like basic utensils (knives, spoons, measuring cups) that you use everywhere—they belong in a common drawer.
Lesson 63 — The Components Folder: Shared vs Feature-Specific
Shared element transitions
An image smoothly transitions from thumbnail to full-screen using layoutId
Lesson 2010 — Framer Motion for Component-Driven UI Animations
side effect
A side effect is any operation that reaches outside your component's render calculation.
Lesson 524 — What is a Side Effect?
signal
An AbortSignal for request cancellation
Lesson 1780 — Query Function Context and Signals
Simple URLs suffice
Sometimes /checkout is clearer than nesting under /store/cart/checkout
Lesson 1842 — When to Nest vs Flatten Routes
Simpler mental model
Data routers are powerful but conceptually lighter than TanStack's full type-safe approach
Lesson 1885 — When TanStack Router Fits vs React Router
single source of truth
The single source of truth is the official scorekeeper's record.
Lesson 463 — What 'Single Source of Truth' Means
size
The height (or width for horizontal lists) of this item in pixels
Lesson 1280 — The Virtual Items Array
Small in size
a few KB won't justify split overhead
Lesson 1358 — Lazy vs Eager: When Each is Right
Smaller bundle size matters
TanStack Query is lighter and has no GraphQL parser overhead
Lesson 1830 — When Apollo Fits vs TanStack Query
Source maps
Source maps are special files that map minified code back to your original source.
Lesson 1334 — Source Maps for Readable Stack Traces
Specific component types
Specific component types are the most restrictive — they enforce that a particular component is used.
Lesson 1135 — Type Safety for Slot Props
Speed perception matters
Social feeds, chat apps, collaborative tools where instant feedback is expected
Lesson 1802 — Pessimistic vs Optimistic: When to Choose
SSR
SSR is ordering a fully prepared meal—it arrives ready to eat, though you might add garnish (interactivity) after.
Lesson 1630 — What Server-Side Rendering Actually MeansLesson 1673 — CSR Trade-offs: Interactivity vs Initial Load
Stable
They don't change between renders (assuming parent and child IDs are stable)
Lesson 1249 — Composite Keys for Nested Lists
stable key
A stable key is one that never changes for a given item, no matter what happens to the list around it.
Lesson 170 — What Makes a Key 'Stable'
Stable references
Stable references are better when no arguments are needed: handleClick
Lesson 234 — Inline Arrow Functions vs Stable References
start
The absolute position (in pixels) from the top of the virtual container where this item should begin
Lesson 1280 — The Virtual Items Array
State
State is like announcing something over a loudspeaker—everyone hears it, everyone reacts, the whole room responds.
Lesson 228 — Props vs State: Who Owns the DataLesson 498 — Refs Don't Trigger Re-rendersLesson 1484 — The useActionState Signature
State domains
State domains are groups of related data that:
Lesson 839 — Identifying Independent State Domains
State persistence
A reused component keeps its local state
Lesson 151 — Keys Preserve Component Identity
StateContext
Think of a restaurant: the StateContext is the menu board that changes daily (you check it to see what's available), while DispatchContext is the ordering counter—it never moves.
Lesson 778 — Creating the Context Pair: State and Dispatch
status
a string ('pending', 'error', 'success') for more detailed states
Lesson 608 — Built-In Loading, Error, and Success States
Suspense boundary
A Suspense boundary is a dividing line in your component tree.
Lesson 1637 — Suspense Boundaries in Streaming SSR
switch statement
While you could use a chain of if-else statements, the switch statement is the standard pattern that makes reducers clean and scannable.
Lesson 760 — Switch Statement Pattern

T

Tabs
A <TabList> needs to know which tab is active. Each <Tab> needs that same information. The <TabPanel> components also need to know. Rather than passing activeTab and setActiveTab to each piece separately, Compound Components let them share this state implicitly.
Lesson 1087 — When to Use This Pattern
tagged template literals
styled-components leverages a special JavaScript feature called tagged template literals.
Lesson 1923 — styled-components Basics: Tagged Template Literals
target
target is the element that actually triggered the event.
Lesson 2354 — The currentTarget vs target Distinction
Testability
Easy to test because behavior is consistent
Lesson 230 — Props Read-Only Rule and Pure Components
Testable
Single responsibility is easier to verify
Lesson 1002 — The Cohesion Test: Does the Hook Have a Clear Purpose?
Testing
Isolated stores are simpler to test
Lesson 1717 — Multiple Stores and When to Split
theme contract
In vanilla-extract, a theme contract is like a blueprint that defines which design tokens exist (colors, spacing, typography) without initially specifying their values.
Lesson 1936 — Type-Safe Theme Contracts
They also create false positives
A component can have perfect internal state but render nothing to the user—and your detail-focused test would pass.
Lesson 2034 — Why RTL Discourages Testing Details
Time slicing
Time slicing is React's solution: instead of rendering everything in one continuous block, React breaks the work into small chunks (typically 5ms each).
Lesson 1459 — Time Slicing: Yielding Control Back to the Browser
Total duration
The cumulative time spent rendering that component across all renders
Lesson 2215 — Component Render Count and Duration Totals
Tree-shaking
Unused methods in classes are harder to detect and remove
Lesson 311 — Classes Confuse Both People and Machines
tRPC router
A tRPC router is where you define all your API endpoints (called "procedures") on the server.
Lesson 1814 — Creating a tRPC Router on the Server
Truly global state
Truly global state is data that a large portion of your component tree needs to access, regardless of where those components sit in the hierarchy.
Lesson 810 — Context for Truly Global State

U

uncontrolled components
For these cases, uncontrolled components are the perfect fit.
Lesson 507 — Simple Forms Without Real-Time Validation
uncontrolled components with submit-time reading
In these cases, uncontrolled components with submit-time reading are more appropriate than controlled components that update state on every change.
Lesson 523 — When Submit-Time Reading is Appropriate
Unique
The combination prevents collisions across all nesting levels
Lesson 1249 — Composite Keys for Nested Lists
Unmount
Unmount is when React removes the component from the screen entirely.
Lesson 296 — The Three Lifecycle Phases: Mount, Update, Unmount
useDataFromAPI
too verbose, useFetch is clearer
Lesson 983 — The useX Naming Pattern
useGSAP hook
A React-safe wrapper for GSAP code with automatic cleanup
Lesson 2001 — Installing GSAP and Basic Setup in React
useMemo
useMemo is reusing cleaned windows instead of washing them again every day (re-renders)
Lesson 393 — Lazy Init vs useMemo: Different Tools
Utility functions
Utility functions are plain JavaScript functions that perform calculations or transformations without any React features.
Lesson 970 — Custom Hooks vs Utility Functions

V

Vite Integration
If you're already using Vite (which powers modern React tooling like Create-React-App alternatives), Vitest reuses your exact Vite config. No duplicate configuration for TypeScript, path aliases, CSS modules, or environment variables. Your app code and test code are processed identically.
Lesson 2024 — Why Vitest Over Jest for Modern React
Vitest
Vitest is your test runner—it finds, executes, and reports on your tests.
Lesson 2025 — Installing Vitest and Testing Dependencies

W

Web Components
While React provides a component-based architecture through JavaScript, Web Components are built directly into browser standards.
Lesson 27 — Web Components: Standards-Based Approach
Webpack
Webpack is a module bundler—it takes all your separate JavaScript files, CSS, images, and other assets and combines them into optimized bundles that browsers can load efficiently.
Lesson 54 — Webpack from Scratch
When to annotate explicitly
If the inferred type is too broad (like string instead of a literal type), or you want to enforce a specific shape:
Lesson 2388 — Typing useMemo and useCallback
Why JSX exists
Writing nested UIs this way is brutally verbose
Lesson 76 — JSX Without a Transpiler: The Raw API
wrapper component
A wrapper component is a component whose primary job is to "wrap around" other components and add something extra — like styling, error handling, or common layout structure.
Lesson 193 — Wrapper Components for Shared BehaviorLesson 252 — Wrapper Components with Children

Y

You're already using TanStack Query
The integration is seamless and eliminates boilerplate
Lesson 1885 — When TanStack Router Fits vs React Router
You're testing integration points
The value is in how pieces work together
Lesson 2083 — When NOT to Mock: Testing Philosophy

Z

Zero-runtime
Zero-runtime means your styling solution extracts all CSS at build time and ships static .css files to the browser—no JavaScript executes at runtime to generate, inject, or manage styles.
Lesson 1933 — What Zero-Runtime Means
Zod
Zod is a TypeScript-first schema validation library.
Lesson 1225 — Schema Validation with Zod Resolver