Centralized state management using a single store, actions, and reducers

A React-specific hook for managing local component state and side effects

An optimized data fetching library that caches API responses in memory

A CSS-in-JS framework that dynamically updates styles based on state

What is a selector in Redux?

A function that extracts and derives specific data from the Redux store

A middleware component that validates actions before they reach the reducer

A specific CSS utility used to target Redux-connected DOM elements

A configuration object that defines the initial state of a global store

A minimalist state management library using a hooks-based API

A server-side rendering framework compatible with Next.js and Remix

A testing suite designed for auditing frontend performance metrics

A specialized bundler that optimizes JavaScript for mobile browsers

What is the React Context API?

A built-in feature to share data across components without prop drilling

A legacy class-based system for managing asynchronous component updates

A high-performance alternative to the Virtual DOM rendering engine

A routing library used to synchronize the UI with the browser URL

What is code splitting?

Dividing the application bundle to lazy-load specific components or routes

Refactoring a monolithic codebase into separate microservice repositories

The process of minifying JavaScript files to reduce total download size

Separating CSS and HTML into different files to improve cache hits

What is tree shaking?

The removal of unused exports from the final JavaScript bundle

A recursive algorithm that balances the hierarchy of the Virtual DOM

A responsive design technique for reorganizing elements on mobile

The practice of updating project dependencies to their latest versions

What is bundle analysis?

The use of tools to identify large dependencies and optimization targets

A security audit that checks for vulnerabilities in third-party packages

The process of measuring the execution time of a specific function

A method for validating that all code follows a consistent style guide

A set of core metrics (LCP, FID, CLS) used to measure user experience

The internal state values that determine if a component should re-render

A collection of standard browser APIs for managing offline data access

The technical specifications for hardware acceleration in the browser

What is LCP (Largest Contentful Paint)?

The time it takes to render the largest visible element in the viewport

The delay between the initial server request and the first byte received

The total duration required to download all critical CSS and JavaScript

The moment when the browser completes the initial parsing of the HTML

What is FID (First Input Delay)?

The time between a user interaction and the browser’s response

The speed at which a user can type text into an input field

The duration between the page request and the first pixel rendering

The latency introduced by slow network handshakes on mobile devices

What is CLS (Cumulative Layout Shift)?

A metric measuring the visual stability of a page during the loading process

The process of moving state from a child component to a parent component

The total number of CSS class changes triggered by a user interaction

A method for shifting heavy computations to a background thread

A browser hint used to fetch high-priority resources early in the lifecycle

The act of fetching assets for the next page the user is likely to visit

A technique that reduces image resolution until the full file is ready

The process of server-side data fetching before the UI is rendered

A low-priority browser hint to fetch resources for future navigation

A mechanism to force-refresh the browser cache for static assets

A method for validating API endpoints before making a real request

A compression algorithm that reduces the size of large JSON objects

What is lazy loading?

Deferring the loading of non-critical resources until they are visible

A pattern where the UI waits for all data to arrive before rendering

Reducing the complexity of a component to speed up its mounting time

The use of low-resolution placeholders while high-quality images download

What is virtual scrolling?

A technique that renders only the items currently visible in the viewport

A feature that simulates scrolling on touch devices without a scrollbar

The process of animating elements based on the current scroll position

A method for synchronizing the scroll position between two separate tabs

What is memoization in React?

Caching the results of expensive computations or component renders

Managing the history of state changes to allow for time-travel debugging

An optimization that converts all CSS into inline styles at runtime

The automatic deletion of old state values to free up system memory

What is the useCallback hook?

A hook that memoizes function references to prevent child re-renders

A utility for executing a function only once when a component mounts

A specialized hook for managing asynchronous data fetching results

An API used to register global event listeners for the window object

What is the useReducer hook?

A hook for managing complex state through actions and a reducer function

A performance hook that reduces the number of renders for large lists

An API that merges multiple state objects into a single global value

A tool for minifying state objects before sending them to an API

A state management library that uses a graph-based atom architecture

A browser extension for recording user interactions during QA tests

An animation engine that uses spring physics for smooth UI transitions

A layout system designed specifically for building dashboard interfaces

A minimalist state management library focused on atomic state units

A CSS framework that focuses on zero-runtime utility class generation

A tool for generating static documentation from TypeScript interfaces

A specialized bundler used to manage micro-frontend architectures

What is render optimization?

Reducing wasted work by using memoization, keys, and batching

Increasing the refresh rate of the browser to achieve 120fps UI

The manual manipulation of the DOM to bypass the Virtual DOM layer

A build process that converts React components into static HTML files

What is hydration in SSR?

The process of attaching event listeners to server-rendered HTML markup

A technique for pre-loading image assets before the server sends data

The automatic removal of unused CSS from the server-side output

The method for synchronizing local state with a persistent database

What is critical CSS?

Inline styles required for the first paint of the visible viewport

The base reset stylesheet that ensures consistent cross-browser UI

A set of global variables used to define the primary theme colors

A CSS-in-JS pattern that treats every component as an independent module

What is the RAIL model?

A performance framework focusing on Response, Animation, Idle, and Load

A software development lifecycle for managing agile frontend teams

An architectural pattern for building React Apps with Independent Logic

A set of encryption standards used to secure real-time data streams

What is INP (Interaction to Next Paint)?

A metric measuring the time from an interaction to the next visual update

The total duration of all animations triggered by a single user click

A technical requirement for serving images in the next-generation AVIF format

The frequency at which a browser re-paints the background during a scroll

What are Web Workers?

A feature for running scripts in a separate background thread from the UI

Automated bots that crawl web pages to collect metadata for SEO

A specialized team of developers responsible for production maintenance

An API for managing push notifications and offline caching in browsers

What is component composition?

A pattern of building complex UIs by combining small, focused components

The process of merging two different CSS frameworks into a single build

A method for translating component names into localized languages

The automatic conversion of React code into browser-native Web Components

What is the render prop pattern?

A technique for sharing code by passing a function as a component prop

A performance setting that determines the priority of a component render

A method for documenting the expected data types for component properties

A specific CSS property that allows one element to inherit another’s style

What is a higher-order component (HOC)?

A function that takes a component and returns a new enhanced component

A React component that must be rendered at the top level of the tree

A specialized build tool that converts ES6 code into older JS versions

A security feature that prevents a component from being rendered twice

What is an error boundary in React?

A class component that catches JavaScript errors in its child component tree

A validation function that checks for missing props before a render occurs

A network layer that intercepts and handles failed API requests automatically

A browser security setting that prevents a script from accessing the DOM

Quizzes

Prev in FrontendAdvanced CSS: Layouts, Modern Features & Performance Next in FrontendAstro: Building Fast Web Experiences

Frontend Performance

Advanced Frontend Patterns: State Management & Performance

Mohammad Abu Mattar20 QuestionsIntermediatePublished: 17 Mar, 2026

Markdown for AI