Frontend

A11y is a nerdy shorthand for 'Accessibility' — there are 11 letters between the A and the Y.

APNs is Apple's postal service for push notifications. Your server sends a notification to Apple, Apple delivers it to the iPhone.

ARIA stands for Accessible Rich Internet Applications.

Above the fold is everything you see before scrolling — like a newspaper's front page headline. It's prime real estate.

Accessibility (a11y) is making your website usable by everyone — including people using screen readers, keyboard-only navigation, or who have low vision.

Ajax is the technique of loading data from a server in the background without refreshing the whole page.

Alpine.js is like jQuery had a baby with Vue, and that baby was really into minimalism.

CSS Anchor Positioning lets you position an element relative to another element anywhere on the page — without JavaScript.

Angular is Google's JavaScript framework — the strict, opinionated one that comes with everything pre-decided.

React Native's Animated API lets you create smooth animations that can run on the native thread.

Ant Design is the enterprise component library from Alibaba that has a component for everything your PM could ever dream up.

An App Bundle (AAB) is Android's smarter app format that lets Google Play build optimized APKs for each device.

An App Clip is a tiny piece of your iOS app that loads instantly when you scan a QR code or tap an NFC tag.

App Links are Android's version of Universal Links — they let regular web URLs open your Android app.

App Router is Next.js's new routing system that uses the app/ directory and embraces React Server Components.

App signing is like putting your digital signature on your app to prove it's really from you and hasn't been tampered with.

Apple's marketplace where you download apps — and where Apple takes a 30% cut of everything.

App Store Connect is Apple's portal where you submit your app and wait nervously for their review team to approve it.

Arrow functions are a shorter way to write functions in JavaScript. Instead of writing 'function(x) { return x * 2 }' you write '(x) => x * 2'.

The aspect-ratio property tells an element to keep its proportions, like a photo that stays rectangular no matter how you resize it.

Astro is the 'ship zero JavaScript by default' framework.

Astro Islands are like oases of interactivity in a desert of static HTML. Most of your page is plain HTML (fast, no JS), and only the parts that need to be

Async/await is syntactic sugar that makes Promises look like normal, readable code. Instead of chaining .then().then().

Atomic CSS is the idea that every CSS class should do exactly one thing. Instead of .card-header, you have .p-4 .font-bold .text-blue-500.

Autoprefixer is the robot that adds -webkit-, -moz-, and all those annoying vendor prefixes to your CSS so you don't have to.

Babel is the universal translator for JavaScript.

Below the Fold is everything on a webpage you have to scroll down to see. Content here can load lazily since users won't see it immediately.

A bento grid is a layout inspired by Japanese bento boxes — neatly arranged sections of different sizes that fit together perfectly.

Binding is connecting your data to your HTML so they stay in sync.

Biome is one tool that replaces both ESLint AND Prettier.

Bootstrap is the OG CSS framework — add a class and get a pre-styled button, grid, modal, or navbar.

The box model is how CSS thinks about every element on a page — as a box with four layers: content, padding, border, and margin.

The Bridge is React Native's translator between JavaScript and native code.

Imagine your code is a pile of LEGO instructions split across 50 tiny papers.

A bundle analyzer is like an X-ray for your JavaScript suitcase.

How big your JavaScript file is after everything is smooshed together. Every npm package you install makes it bigger. That 'tiny' date library? 70KB.

A bundler is the robot that smashes all your separate JavaScript files, CSS, images, and random imports into one (or a few) neat packages that the browser...

CLS measures how much your page randomly jumps around while loading.

CSR means the browser downloads a mostly-empty HTML page plus a big JavaScript bundle, then builds the full page in the browser.

CSS is the makeup and wardrobe for your HTML skeleton. It decides what color everything is, how big things are, and where stuff goes on the page.

CSS animations let you make things move, spin, fade, and bounce using only CSS — no JavaScript needed.

clamp() is CSS's way of saying 'be this size, but never smaller than this and never bigger than that.

CSS contain builds an invisible fence around an element and tells the browser 'changes inside this fence don't affect anything outside.

CSS Grid is the two-dimensional layout system — rows AND columns at the same time. Think of it like a spreadsheet you can put your whole website into.

The :has() selector is CSS's long-awaited 'parent selector.

Logical properties replace left/right with start/end so your CSS works in any text direction — left-to-right, right-to-left, even vertical.

CSS Modules are like giving every CSS class a unique ID badge so they never clash with each other.

CSS Nesting finally brings the one feature everyone used Sass for directly into plain CSS.

CSS Subgrid lets a grid child inherit the grid tracks from its parent, so nested elements can align to the outer grid.

CSS Transform lets you rotate, scale, skew, and move elements without messing up the page layout.

CSS transitions are the smooth operators of web design.

CSS Variables (officially called Custom Properties) let you store values in CSS and reuse them everywhere.

CSS-in-JS is the controversial philosophy of writing your styles in JavaScript instead of CSS files. Fans love the co-location and dynamic styling.

A callback is just a function you pass to another function, saying 'when you're done, call this.

The Canvas API gives you a blank rectangle and says 'draw whatever you want with code.' It's like MS Paint but controlled by JavaScript.

Capacitor wraps your web app in a native shell and gives it access to device features like the camera, GPS, and push notifications.

Cascade layers let you group CSS rules into named layers and control the order they apply.

Chakra UI is like ordering a meal kit instead of cooking from scratch.

Chart.js is the 'I just need a chart and I need it now' library. Hand it some data, pick a chart type, and boom — you've got a beautiful, animated chart.

Chromatic takes screenshots of your UI components and yells at you when something changes unexpectedly.

CSS clamp() sets a value that's fluid between a minimum and maximum. clamp(1rem, 2.5vw, 2rem) means 'at least 1rem, ideally 2.

The Clipboard API lets your website read from and write to the user's clipboard — copy and paste, but controlled by code.

A closure is when a function remembers the variables from the scope it was created in, even after that scope is gone.

Code signing proves that your code is genuinely from you and nobody tampered with it between your computer and the user's device.

Instead of sending the user one massive JavaScript file for your entire app, code splitting lets you break it into chunks and only send what's needed for t...

CodePush was Microsoft's OTA update service for React Native that let you push JS fixes directly to phones.

CodeSandbox is the playground where you can spin up a React, Vue, or Next.js project in seconds without installing anything. It's like a sandbox at a playg

CSS color functions let you mix, lighten, darken, and adjust colors right in your stylesheet.

CSS color-scheme tells the browser whether your page supports light mode, dark mode, or both.

A component is a self-contained LEGO brick for your UI.

A Component Library is a box of pre-built LEGO pieces for your UI — buttons, modals, dropdowns, all ready to snap together. Instead of building a date pick

Composables are Vue's version of React hooks — reusable functions that bundle reactive state and logic together.

Compositing is the final step where the browser assembles all the painted layers into the image you see on screen, like stacking transparent sheets in a pr...

The console is the JavaScript developer's best friend and worst habit. You use console.log() to print values for debugging.

CSS contain tells the browser 'this element is self-contained — changes inside it won't affect the outside layout.

Container Queries are the CSS feature we begged for years. Instead of 'how wide is the screen?' they ask 'how wide is my parent container?

Container queries are like media queries, but instead of checking the window size, they check the size of the parent container. Finally.

Content Collections in Astro are like filing cabinets for your markdown content — each cabinet has strict rules about what goes in it. You define a schema,

Content-visibility: auto tells the browser 'don't bother rendering stuff that's off-screen.

Core Web Vitals are the three most important Web Vitals that Google actually uses as ranking signals.

Critical CSS is like packing only what you need for the first 5 minutes of your trip in your carry-on.

Custom Elements let you define your own HTML tags that the browser recognizes as first-class citizens. Want a <fancy-tooltip> tag?

D3.js turns data into beautiful, interactive visualizations. It's absurdly powerful and has a learning curve shaped like a cliff.

The DOM is a live map of your webpage that JavaScript can read and edit. When the browser loads your HTML it turns it into a big tree of objects.

DaisyUI is Tailwind CSS on easy mode. Instead of writing 15 utility classes for a button, you just say 'btn btn-primary' and it looks great.

The feature every user demands and every developer underestimates. 'Just make the background dark' they said. It'll be easy, they said.

A dark pattern is a UI design trick that manipulates users into doing things they didn't intend — like hiding the unsubscribe button, making the 'accept co...

A dead click is when a user clicks something that looks clickable but does absolutely nothing. No handler, no loading state, no error.

Making a function wait until you STOP doing something before it fires. Like a search bar that waits until you stop typing before actually searching.

Debouncing is like a patient elevator that waits a few seconds after the last person presses the button before closing its doors.

Deep linking is when a URL opens a specific screen inside your app instead of just the home page.

A LEGO set for your UI — a collection of reusable components, colors, typography, and rules that keep your entire app looking consistent.

Design tokens are the atoms of your design system — the tiny named values like colors, spacing, and font sizes that everything else is built from.

Design tokens are the single source of truth for your design decisions — colors, spacing, fonts — stored as variables that work everywhere.

Destructuring lets you unpack values from arrays or objects into variables in one clean line. Instead of writing 'const name = user.name; const age = user.

DevTools is the built-in developer panel in every major browser (press F12 or right-click → Inspect).

The <dialog> element is HTML's built-in modal component. It handles focus trapping, the Escape key, backdrop styling, and top-layer rendering natively.

Directives are special HTML attributes that tell Vue (or Angular) to do something special with an element.

EAS Build is Expo's cloud build service that compiles your React Native app into real iOS and Android binaries without you needing Xcode or Android Studio...

EAS Submit automatically uploads your app binaries to the App Store and Play Store. No more manual uploading through web portals.

ESLint is the code cop that reads your JavaScript and yells at you when you do something wrong or inconsistent.

Easing functions control the speed curve of an animation — do you start fast and slow down? Accelerate then decelerate? Bounce at the end?

Electron bundles Chromium and Node.js to let you build desktop apps with web tech. VS Code, Slack, Discord — all Electron. The catch?

Emotion is CSS-in-JS that gives you two flavors: the styled-components-like syntax AND a css prop for inline styles.

Error Boundaries are like safety nets in a circus.

An error click is a click that triggers an error (JS exception, network failure).

JavaScript can only do one thing at a time (single-threaded), but the Event Loop is the trick that makes it seem like it can multitask.

Expo is the easy button for React Native.

Expo Router brings file-based routing to React Native — just like Next.js does for web. Create a file, get a route.

FCM is Google's delivery service for push notifications to Android (and iOS too).

FID measured how long it took for the browser to react after you first clicked something.

FOIT is when your browser hides all the text until the custom font loads, like a magician making your content vanish. 'Ta-da! Your heading is...

FOUT is when your page shows up in boring system fonts and then — SURPRISE — swaps to the fancy custom font a second later.

Falsy values are the six (well, seven) values in JavaScript that evaluate to false in a boolean context: false, 0, empty string, null, undefined, and NaN.

The favicon is that tiny little icon in your browser tab next to the page title.

Feature Detection checks if a browser supports a feature before trying to use it.

Fetch is the modern, built-in JavaScript way to make HTTP requests to APIs. You tell it a URL, it goes and gets the data, and you handle the response.

The design tool that every designer uses and every developer has a love-hate relationship with.

Figma to Code is the dream of turning designer mockups into actual working code automatically.

File-Based Routing means your folder structure IS your routing. Create pages/about.vue and you get /about.

Fine-grained reactivity means the framework knows EXACTLY which tiny piece of the UI needs to update when data changes — no diffing, no re-rendering the wh...

First Paint is the moment your browser stops showing a blank white screen and puts literally anything on it.

Flexbox is a CSS layout system that makes positioning elements in a row or column stupidly easy.

Flipper is Meta's debugging Swiss Army knife for mobile apps.

Flutter is Google's way of saying 'write once, run everywhere' and actually meaning it.

Downloading an entire font family is like ordering the complete encyclopedia when you only need Volume F.

Framer Motion makes animations in React embarrassingly easy. Want a div to slide in? Just say 'animate this from here to there' and it handles the physics.

A framework is like a pre-built house structure — the walls, floors, and roof are done, you just decorate it your way.

Framework churn is the constant rate at which new JavaScript frameworks appear, become fashionable, and get replaced. It's what causes framework fatigue.

Framework fatigue is the exhaustion of watching the JavaScript ecosystem ship a new meta-framework every 18 months. You just learned Next.

Frontend middleware runs BEFORE a page renders — it can redirect you, check your auth, rewrite URLs, or add headers.

GPU acceleration is when the browser offloads rendering work to your graphics card instead of making the CPU do everything.

GSAP (GreenSock Animation Platform) is the animation library that professional agencies use for those jaw-dropping website animations.

Gatsby is the overachiever that pre-builds your entire website into static HTML at build time, then sprinkles React on top for interactivity.

The Geolocation API tells your website where the user is in the real world — latitude, longitude, the works.

Gesture Handler replaces React Native's janky touch system with one that runs on the native thread.

Android's app store — like Apple's App Store but with fewer rejections and more malware.

Google Play Console is where you upload your Android app and manage its life on the Play Store.

Graceful degradation is building the fancy version first, then making sure it doesn't completely break in older or limited environments.

HMR stands for Hot Module Replacement. It's the dev server trick that updates your browser in real time without a full refresh.

HTML is like the skeleton of a webpage. You write tags like <h1> and <p> and the browser builds the bones of your site from them.

HTMX lets you build interactive web apps by adding special attributes to regular HTML — no JavaScript framework needed.

Headless UI is a component library that gives you all the behavior (keyboard navigation, focus management, accessibility) but zero styling.

Hermes is Meta's custom JavaScript engine built specifically for React Native.

Hoisting is JavaScript's weird quirk where variable and function declarations are mentally 'moved' to the top of their scope before code runs.

Hooks are special functions in React that let function components use superpowers like state and lifecycle that used to be class-only.

HMR is the magic that makes your browser update instantly when you save a file — without refreshing the whole page and losing your app state.

Hydration is when a server-rendered HTML page comes alive in the browser.

INP measures how snappy your website feels every time you interact with it — not just the first click, but every button press, dropdown open, and form subm...

ISR is the best of both SSG and SSR. Pages are pre-built statically but can automatically rebuild themselves in the background after a set time.

Sending a full-size photo to your website is like shipping a grand piano when someone asked for a music box.

In-app purchases let users buy stuff inside your app — subscriptions, extra lives, premium features.

IndexedDB is a full-on database living inside your browser.

Infinite Scroll loads more content as you scroll down, like a bottomless pit of data. Social media feeds use it to keep you scrolling forever.

Instant Apps are Android's version of 'try before you install.

Intersection Observer watches elements and tells you when they enter or leave the viewport. It's the bouncer checking if components are visible.

Ionic gives you a library of mobile-looking UI components so your web app can cosplay as a native app.

Island architecture is like building a static HTML beach with small islands of interactive JavaScript sprinkled on top.

Islands architecture is shipping a static HTML page with small 'islands' of interactive JavaScript.

Islands Architecture treats your page like an ocean of static HTML with little islands of interactivity.

JSX is a JavaScript syntax extension that lets you write HTML-like code directly inside your JavaScript.

JavaScript is what makes websites actually DO stuff. HTML is the bones, CSS is the skin, and JavaScript is the muscles and brain.

Jotai treats state like individual atoms that you can combine like molecular chemistry.

Keyframes are like the storyboard for a CSS animation.

LCP measures how long it takes for the biggest thing on your page to appear. Usually it's a hero image or a big headline.

Layer Promotion is when the browser puts an element on its own compositor layer, like giving it a VIP pass.

Layouts are wrapper components that persist across page navigations — things like headers, sidebars, and footers that don't change when you switch pages.

Layouts are like the floor plan of your website.

The left-pad incident is when one developer unpublished an 11-line npm package and broke the entire internet in 2016.

A library is a collection of tools you can use whenever you want, however you want. You're in charge.

The lifecycle is a component's life story — it's born (mounted), lives and updates (updates), then dies (unmounted).

Lighthouse is Google's report card for your website. It grades you on speed, accessibility, SEO, and best practices.

Lit is Google's way of saying 'Web Components don't have to be painful.

LocalStorage is a simple key-value storage built into every browser that persists even after you close the tab.

Long Tasks are any JavaScript tasks that take more than 50ms and block the main thread.

The Long Tasks API is a snitch that tells you whenever JavaScript hogs the main thread for more than 50 milliseconds.

Lottie plays After Effects animations on the web as tiny JSON files instead of heavy GIFs or videos.

MDX is what happens when Markdown and JSX have a baby — you can write your blog post in Markdown but drop in interactive React components wherever you want

An MPA is the old-school way — every link click loads a completely new HTML page from the server. Think Wikipedia. Each page is its own thing.

MSW (Mock Service Worker) intercepts your API calls at the network level and returns fake data, like a polite man-in-the-middle attack on yourself.

Mantine is the component library that seems to have a component for literally everything.

Markdoc is Stripe's documentation framework that's like MDX's more disciplined cousin. Instead of letting you go wild with JSX, it uses a tag-based syntax

Material UI (MUI) brings Google's Material Design to React.

A media query is a CSS if-statement based on screen conditions. 'If the screen is narrower than 768px, apply these styles.

Teaching your code to remember answers it already calculated. If someone asks 'what's 47 × 83?' and you worked it out once, you write down the answer.

Meta tags are invisible HTML tags that sit in your page's head and tell search engines and social media platforms about your page.

Metro is React Native's module bundler — it takes all your JavaScript files, smooshes them together, and serves them to your app.

Minification is the full process of squishing your code files as small as possible before sending them to users.

Minification is when your code goes on a diet.

MobX is state management for people who think Redux is too much work.

Mobile first means you design for the smallest screen first, then add styles as screens get bigger.

Mutation Observer is the surveillance camera for your DOM.

NPM install pray is the ritual of running `npm install`, closing your eyes, and hoping nothing breaks. Will there be peer dependency conflicts?

A native bridge is the translator between your JavaScript world and the native platform APIs.

Native modules are escape hatches that let you write actual Swift/Kotlin code when your cross-platform framework can't do something.

Next.js is React's big sibling that adds superpowers like SSR, SSG, file-based routing, and API routes.

Next.js Middleware is like a bouncer that intercepts every request before it reaches your page. It runs at the edge (close to the user) and can redirect, r

The node_modules black hole is the abyss that forms when you run `npm install`. What starts as 5 dependencies becomes 500 nested packages totaling 400MB.

The Notification API lets websites show native system notifications — those little pop-ups in the corner of your screen.

Nuxt is Vue on steroids. It's a meta-framework that adds SSR, SSG, file-based routing, auto-imports, and a full deployment pipeline on top of Vue.

Nuxt UI is a gorgeous component library built specifically for Nuxt apps, powered by Tailwind CSS and Headless UI.

Open Graph is the reason your link previews look nice when you paste them in iMessage, Slack, or Twitter. Without it, you just get a bare URL.

Optimistic UI means updating the interface BEFORE the server confirms the action succeeded. Click 'Like'? The heart turns red immediately.

OTA updates let you push JavaScript changes directly to users' phones without going through the App Store review process.

A PWA is a website that pretends to be an app.

Pages Router is the OG Next.js routing system where you put files in the pages/ directory and they become routes. Simple, proven, and still works fine.

Paint Timing is your browser's diary of when it drew stuff on screen. 'Dear diary, at 1.2 seconds I painted the first pixel. At 1.

Parallax is when background elements scroll slower than foreground elements, creating a fake sense of depth.

Parallax scrolling makes background images move slower than foreground content as you scroll, creating a fake 3D effect.

Parcel is the zero-config bundler that just works. No webpack.config.js, no rollup plugins, nothing.

Partial Hydration is the art of only making interactive the parts of your page that actually need to be interactive. Why hydrate a static paragraph?

Partial prerendering serves a static shell instantly and streams in the dynamic parts. Best of both worlds: static-like TTFB plus dynamic data. Next.

Percy is a visual testing platform that screenshots your pages across different browsers and screen sizes, then highlights any visual differences between b...

A performance budget is like a calorie limit for your website.

Petite Vue is Vue's little sibling at just 6KB — it's designed for sprinkling interactivity on server-rendered HTML, just like Alpine.js.

Pinia is Vue's official state management that replaced Vuex and made everyone sigh with relief. No more mutations vs actions confusion.

Spending hours moving things 1 pixel left, 2 pixels up, changing that border from #eee to #e5e5e5.

A polyfill is a piece of code that teaches old browsers new tricks. Browser doesn't support Promise? Here's a polyfill that fakes it.

The Popover API is a native HTML feature that lets you create popovers, tooltips, and menus without any JavaScript.

React Portals let you teleport a component's HTML output to a completely different part of the DOM while keeping it logically in the same place in your com...

PostCSS is a CSS processor that does... whatever its plugins tell it to do. It's like an empty pipeline where you plug in transformations. Autoprefixer?

Preact is React after a juice cleanse. It does almost everything React does but in 3KB instead of 40KB.

Loading stuff before the user needs it. When someone hovers over a link, you start downloading that page's data so it loads instantly when they click.

Telling the browser 'hey, you're gonna need this file SOON, start downloading it NOW.

Prettier is an opinionated code formatter that automatically reformats your code to look consistent. Single quotes or double quotes? 2 spaces or 4?

ProGuard is Android's code shrinker that removes unused code, renames everything to single letters, and makes your APK smaller.

Progressive enhancement means building a web page that works for everyone at its most basic level, then layering on fancy features for browsers that suppor...

A PWA is a website that put on a trench coat and convinced your phone it's a real app.

A Promise is JavaScript's way of saying 'I'll give you a value eventually — it's not ready yet, but I promise.

Props are how you pass information INTO a component, like giving a coffee machine its settings.

Every object in JavaScript secretly has a parent object called its prototype.

Push notifications are those little messages that pop up on your phone even when the app is closed.

Qwik is the ultimate procrastinator framework, and that's a compliment. It loads absolutely nothing until you actually interact with something.

React Server Components are React's way of saying 'what if some components just... ran on the server and never bothered the browser?' It's like a restauran

Rspack is a Rust-powered replacement for Webpack that builds your project insanely fast. Imagine replacing your bicycle chain with a jet engine.

Radix UI gives you components that work perfectly but look like nothing.

A rage click is when a frustrated user clicks the same button five times rapidly because nothing happened. It's your UX screaming.

React is a JavaScript library from Meta for building UIs out of components.

React Context is like a family group chat for your components.

React Hook Form is the form library that said 'what if we just... didn't re-render the whole form on every keystroke?

React Native lets you build iPhone and Android apps using React and JavaScript. It's like React put on a disguise and snuck into the App Store.

React Navigation handles all the screen-to-screen transitions in your React Native app — stack navigation, tab bars, drawers, the works.

React Portals are teleportation devices for your components. Need a modal that renders in document.body but still lives in your component tree? Portal it.

React Query takes all that messy useEffect-fetch-loading-error-state code and replaces it with one beautiful hook.

React Server Components run on the server and send zero JavaScript to the browser.

React Three Fiber lets you build Three.js 3D scenes using React components.

Reactive means your data and your UI are connected — when the data changes, the screen updates automatically, like magic.

Reactivity is the system that makes your UI automatically keep up with your data.

Reanimated is React Native's animation library on steroids.

Recharts is Chart.js's React-native cousin — built with React components so your charts feel like natural citizens of your React app.

Recoil was Meta's experiment in atomic state management for React. It lets you create atoms and selectors that feel native to React's concurrent features.

Redux is the granddaddy of React state management that makes you write three files to update one number. Actions, reducers, dispatchers, oh my!

Redux Toolkit is Redux's apology letter.

A reflow is when the browser recalculates the size and position of everything on the page because you changed one element's layout.

Remix is the framework that reminds you the web already had solutions before we broke everything with SPAs.

A repaint is when the browser redraws pixels because you changed something visual like a color or shadow.

Resize Observer tells you when an element changes size. Not the window, the actual element.

Responsive design means your website looks good on EVERY screen size — from a tiny phone to a giant 4K monitor.

Responsive design flows like water — it adjusts smoothly to any screen size. Adaptive design has fixed breakpoints — it snaps between pre-designed layouts.

Resumability is Qwik's approach to avoiding hydration entirely.

Rollup is the bundler you use when you're building a library rather than an app.

SCSS is the syntax of Sass that looks like regular CSS but with superpowers added.

SEO is the art of convincing Google to rank your website higher than your competitors.

A SPA is a website that loads ONE HTML page and then never does a full page reload again.

SSG builds all your pages ahead of time — before anyone visits. You get a folder of plain HTML files that are blazing fast to serve from a CDN.

SSR means the server builds your HTML before sending it to the user's browser.

SVG animation brings vector graphics to life with smooth, scalable motion that looks sharp on any screen.

SWC is Babel written in Rust, and it's FAST. Like, 20-70x faster fast. Next.js switched to it and build times dropped dramatically.

SWR stands for 'stale-while-revalidate' and it's Vercel's answer to data fetching.

Sass is CSS with superpowers — variables, nesting, mixins, and functions that vanilla CSS didn't have for years.

Scope is about where your variables are visible. Variables defined inside a function can't be seen outside it (that's function scope).

A screen reader is software that reads your website out loud for people who can't see the screen.

CSS Scroll Snap makes scrolling lock onto specific points — like flipping through pages or snapping to cards in a carousel. No JavaScript needed.

Scroll-driven animations let you tie animations to scroll position using pure CSS — no JavaScript scroll listeners, no Intersection Observer hacks.

Semantic HTML means using the RIGHT tag for the job instead of wrapping everything in divs.

Server Actions let you write a function in your React component that magically runs on the server when called.

Server components are React components that run on the server and never ship JavaScript to the browser.

A Service Worker is a JavaScript script that runs in the background, separate from your web page.

SessionStorage is just like LocalStorage except it forgets everything when you close the browser tab.

Shadcn/ui is not a component library you install — it's a collection of beautifully designed components you COPY into your project.

Shadow DOM is like a force field around your component's internals.

A shim is a thin piece of code that makes old things work with new things (or vice versa).

Signals are reactive primitives that hold a value and automatically notify the UI when that value changes — with surgical precision.

Skeleton Loading shows gray placeholder shapes where content will appear, like a ghost version of your page.

A skeleton screen is that gray placeholder layout you see before content loads — the ghostly outlines of cards, text lines, and avatars that show you where...

Skia is the 2D graphics engine that powers Chrome, Android, and Flutter.

A slot is a placeholder in a component where a parent can inject its own custom content.

Imagine React went to the gym, got ripped, and dropped the Virtual DOM weight. Solid.

Source maps are the translation files that let your browser's DevTools show you the original, readable source code even though the browser is actually runn...

The spread operator (...) lets you unpack an array or object and spread its contents somewhere else. Need to copy an array? Spread it.

StackBlitz is a full-blown development environment that runs entirely in your browser using WebContainers. No cloud server, no VM — Node.js is literally ru

State is a component's memory — data that can change over time and causes the UI to update when it does. Think of a counter: the number is state.

Stencil is a compiler that generates standard Web Components using a React-like developer experience — JSX, decorators, reactive data.

Sticky positioning is like putting a Post-it note on a document — it scrolls with the page until it hits a certain point, then sticks there stubbornly.

Stimulus is a modest JavaScript framework that adds behavior to your HTML using data attributes.

Storybook is like a showroom for your UI components.

Streaming SSR sends HTML to the browser in chunks as it's generated, instead of waiting for the entire page to be ready.

Styled Components lets you write CSS right inside your JavaScript using tagged template literals.

Suspense is React's way of saying 'hold on, something is loading, show this placeholder instead of crashing.

Svelte is a framework that disappears at build time.

How long it takes from clicking a link to receiving the very first byte of data from the server.

Tagged Templates are template literals with a function stuck in front of them.

Tailwind is a CSS framework where instead of writing CSS files you add utility classes directly to your HTML.

Tailwind Plugins extend Tailwind with custom utilities, components, and variants. Want a text-shadow utility? An animation that doesn't exist yet?

TanStack is Tanner Linsley's empire of framework-agnostic tools.

Tanstack Router is the type-safe routing solution that looked at React Router and said 'that's cute, but what if every route, parameter, and search string

Tanstack Table is a headless table library, meaning it gives you all the brain of a data table (sorting, filtering, pagination) but none of the looks — you

Tauri lets you build desktop apps using web technologies (HTML, CSS, JavaScript) but instead of bundling a whole Chromium browser like Electron, it uses th...

A template is the HTML part of your component — the blueprint for what it looks like. In Vue you write it inside a <template> tag. In React you return JSX.

TestFlight is Apple's way of letting you share beta versions of your app with testers before it goes live.

Three.js lets you build 3D worlds in the browser — spinning products, interactive scenes, entire games.

Limiting how often a function can fire. Unlike debounce (which waits until you STOP), throttle fires at a steady rate no matter how fast you trigger it.

Time to Interactive is when your page stops being a beautiful painting you can't touch and actually starts responding to clicks.

Total Blocking Time is the sum of all the moments your browser was too busy running JavaScript to notice you desperately clicking buttons.

CSS transform lets you rotate, scale, move, and skew elements without affecting the document flow.

Tree shaking is when your bundler looks at all the code you imported but never actually used, and throws it in the trash.

In JavaScript, truthy means 'not technically true, but close enough.' The number 42 is truthy. The string 'hello' is truthy.

Turbo (from Hotwire) makes traditional server-rendered apps feel like SPAs by intercepting link clicks and form submissions to swap only the page body via...

Turbopack is Vercel's attempt at building the fastest bundler ever, written in Rust by the creator of Webpack.

A tween (short for 'in-between') smoothly transitions a value from A to B over time. Move an element from x=0 to x=100 over 500ms? That's a tween.

Two-way binding means your data and your input field are best friends who always tell each other what changed. Type in the box and the data updates.

Type coercion is JavaScript's 'helpful' habit of automatically converting types when you didn't ask it to. '5' + 3 equals '53' (string).

TypeScript is JavaScript with a strict parent watching over it.

Universal Links are Apple's way of making regular web URLs open your iOS app. If the app is installed, the link opens the app.

UnoCSS is like Tailwind on steroids.

'use server' is a React directive that marks a function as running on the server only.

Vanilla Extract is CSS-in-JS with zero runtime cost. You write styles in TypeScript files at build time, and they compile to plain CSS class names.

View Transitions API lets you animate between page states — or even between pages — with smooth crossfade, morph, and slide effects.

The View Transitions API lets you animate between page navigations with smooth, native transitions — no framework needed.

The viewport is the visible area of a webpage in the user's browser window. It changes depending on the device — small on a phone, huge on a 4K monitor.

The Virtual DOM is a lightweight copy of the real DOM that lives in memory.

Virtual Scrolling is the magician's trick for long lists. You have 10,000 items but only render the 20 visible ones.

Visx is Airbnb's collection of low-level visualization primitives for React. It's like D3 but decomposed into tiny React components.

Vite is what happens when someone got sick of waiting 30 seconds for Webpack to start.

Vue is a JavaScript framework for building interactive UIs. It's famous for being easy to pick up — HTML developers feel right at home.

Vuetify is the Material Design component library for Vue — it's like Material UI but for the Vue ecosystem.

Vuex was Vue's original state management library and it loved ceremony.

The Web Animations API lets you do CSS animations and transitions from JavaScript, with full control over playback.

Web components are custom HTML elements that you build yourself — like creating your own LEGO brick.

Web Components are the browser's native component system. Custom elements, shadow DOM, templates - no framework needed.

Web Fonts are custom fonts loaded over the internet instead of using the boring default system fonts.

Web font loading is the art of getting custom fonts to show up without your text doing a magic disappearing act or a jarring costume change mid-sentence.

The Web Share API triggers the native share sheet from a website — the same one native apps use.

Web Vitals are Google's report card for how good your website feels to use. They measure things like 'how fast does the main content load?

JavaScript normally runs on one thread, which means heavy computation freezes your UI.

Browsers run JavaScript — but JavaScript is slow for heavy tasks like video encoding or game physics.

WebContainers are the black magic that lets Node.js run inside your browser tab. It's a full operating system environment compiled to WebAssembly — you can

WebGL gives your browser direct access to the GPU for rendering 2D and 3D graphics at blazing speed.

WebGPU is the browser's modern GPU API — a replacement for WebGL that finally lets websites run compute workloads (ML, simulations, shaders) on the GPU at...

Webpack is the OG bundler — the grumpy grandpa of the JavaScript build world.

Will-change is like telling the browser 'heads up, I'm about to animate this thing.' The browser pre-allocates resources so the animation is smooth.

Windi CSS was the framework that proved on-demand CSS generation was the future — so much so that Tailwind adopted the idea as JIT mode.

CSS Writing Modes control the direction text flows — horizontal left-to-right, right-to-left, or vertical.

XState turns your app logic into a state machine diagram that your grandma could read (well, almost).

Zod is a schema declaration library that validates your data AND gives you TypeScript types for free.

Zustand is German for 'state' and it's the state management library that makes Redux look like doing your taxes.

esbuild is a bundler written in Go (not JavaScript) which means it's absolutely unhinged fast — like 10-100x faster than other bundlers.

oklch is a color format that actually makes sense to human brains.

requestAnimationFrame tells the browser 'call my function right before the next screen repaint.