✧ Dictionary ✧

Hiding complex implementation details behind a simpler interface. You use abstractions constantly — calling fetch() is an abstraction over HTTP networking. Good abstractions reduce cognitive load.

A set of rules and protocols that lets different software applications communicate with each other. APIs define what requests can be made, how to make them, and what responses to expect.

A statement in a test that checks whether a condition is true. If the assertion fails, the test fails. Common assertions: equals, contains, throws, toBeTruthy.

Syntax for writing asynchronous code that looks synchronous. `async` marks a function as asynchronous, `await` pauses execution until a Promise resolves.

Repetitive code that must be written to set up a framework or pattern before doing the actual work. Starter templates and code generators exist to reduce boilerplate.

Combining multiple source files and their dependencies into a smaller set of files optimized for the browser. Tools like Webpack, Vite, and esbuild handle bundling.

A function passed as an argument to another function, to be called when an operation completes. Was the primary pattern for async code before Promises.

A network of servers distributed globally that caches and serves content from the server closest to the user, reducing latency and improving load times.

CI automatically tests code when pushed to a repository. CD automatically deploys tested code to production. Together they enable rapid, reliable releases.

A function that retains access to variables from its enclosing scope even after that scope has finished executing. The foundation of data privacy and factory patterns in JavaScript.

A reusable, self-contained piece of UI that manages its own structure and behavior. In React, components are functions that return JSX describing what to render.

A browser security mechanism that restricts web pages from making requests to a different domain than the one serving the page. Servers must explicitly allow cross-origin requests via headers.

The four basic operations for managing data. Most applications are fundamentally CRUD apps — they create data, read it, update it, and delete it.

Rendering HTML in the browser using JavaScript. The server sends a minimal HTML shell and the JavaScript framework builds the page on the client.

A set of practices that combines software development (Dev) and IT operations (Ops) to shorten the development lifecycle. Emphasizes automation, monitoring, and collaboration.

A pattern where a component receives its dependencies from the outside rather than creating them internally. Makes code more testable and loosely coupled.

The system that translates human-readable domain names (like google.com) into IP addresses that computers use to identify each other on the network.

A platform for packaging applications and their dependencies into lightweight, portable containers. Containers run consistently across different environments — 'works on my machine' becomes 'works everywhere'.

A tree-like representation of an HTML document that JavaScript can manipulate. Each HTML element becomes a node in the tree. Modifying the DOM updates what the user sees.

A principle that says every piece of knowledge should have a single, authoritative representation. If you're copying and pasting code, consider extracting it into a reusable function.

A test that simulates a real user interacting with the full application, from the UI through the backend. Tools like Playwright and Cypress automate browser interactions.

Bundling data and the methods that operate on it together, while restricting direct access to some components. In practice: expose a public API, hide the internal implementation.

A specific URL path on a server that accepts requests and returns responses. Each endpoint typically handles one type of operation on one type of resource.

A named set of constants. In TypeScript, enums define a group of related values that can be numeric or string-based. Useful for representing fixed sets of options.

A variable set outside your code (in the OS or a .env file) that configures your application. Used for API keys, database URLs, and other values that change between environments.

A type parameter that lets you write reusable code that works with multiple types while preserving type safety. Think of it as a variable for types.

A query language for APIs that lets the client request exactly the data it needs, nothing more. Unlike REST, a single endpoint handles all queries.

A development feature that updates modules in the browser without a full page reload when you save changes. Preserves application state while reflecting code changes instantly.

JavaScript's behavior of moving variable and function declarations to the top of their scope during compilation. `var` declarations are hoisted (but not their values), `let` and `const` are not.

A React function that lets you use state, effects, and other React features in functional components. Built-in hooks include useState, useEffect, useRef, and useMemo.

The protocol used for transferring data on the web. Defines methods like GET (read), POST (create), PUT (update), DELETE (remove). HTTPS adds encryption via TLS.

The process where a client-side JavaScript framework attaches event listeners and interactivity to server-rendered HTML. The HTML is already visible, and hydration makes it interactive.

An operation that produces the same result no matter how many times you execute it. GET and PUT are idempotent (fetching or setting the same data repeatedly gives the same result). POST is not.

A test that verifies multiple components or modules working together correctly. Tests API endpoints, database operations, or multi-component interactions.

A TypeScript construct that defines the shape of an object — what properties it has and their types. Interfaces can be extended and implemented by classes.

A Next.js feature that lets you update static pages after build time by revalidating them at a specified interval without rebuilding the entire site.

JavaScript Object Notation — a lightweight text format for storing and exchanging data. Uses key-value pairs and arrays. The most common format for API responses.

A compact, self-contained token format for securely transmitting information between parties. Commonly used for authentication — the server creates a token on login that the client sends with subsequent requests.

A design principle that favors simplicity over complexity. The simplest solution that works is usually the best one.

Automatically analyzing code for potential errors, style violations, and suspicious patterns. ESLint is the most common linter for JavaScript/TypeScript. Catches bugs before they reach production.

Code that runs between a request and a response. Used for authentication checks, logging, error handling, and request transformation. Common in Express, Next.js, and other server frameworks.

A versioned script that changes a database schema (adding tables, columns, etc). Migrations let you evolve your database structure over time and keep changes in version control.

Removing whitespace, comments, and shortening variable names in code to reduce file size without changing functionality. Typically done automatically during a production build.

A pattern that separates an application into three parts: the Model (data and logic), the View (what the user sees), and the Controller (handles user input and updates the model).

Databases that don't use the traditional table-based relational model. Includes document stores (MongoDB), key-value stores (Redis), and graph databases (Neo4j). Good for unstructured or rapidly changing data.

An authorization framework that lets users grant third-party apps limited access to their accounts without sharing passwords. The 'Sign in with Google/GitHub' flow uses OAuth.

A technique that lets you interact with a database using objects and methods in your programming language instead of writing raw SQL queries.

The data sent in the body of an HTTP request or response. In a POST request to create a user, the payload would be the user's information (name, email, etc).

An object representing the eventual result of an asynchronous operation. A Promise is pending, then either fulfilled (resolved with a value) or rejected (failed with an error).

Short for 'properties' — the read-only data passed from a parent component to a child component. Props flow down the component tree and cannot be modified by the child.

A bug that occurs when the result depends on the timing of events — such as two async operations completing in an unexpected order. Common in concurrent code and UI state management.

Restructuring existing code without changing its external behavior. The goal is to improve readability, reduce complexity, or improve performance while keeping the same functionality.

An architectural style for building web APIs using standard HTTP methods (GET, POST, PUT, DELETE) to perform operations on resources identified by URLs.

The structure or blueprint of a database — it defines what tables exist, what columns they have, their data types, and relationships between tables.

The region of code where a variable is accessible. JavaScript has global scope, function scope (var), and block scope (let, const). Variables are looked up from inner to outer scopes.

Converting a data structure or object into a format that can be stored or transmitted, then reconstructed later. JSON.stringify() serializes an object to a JSON string.

Five design principles for maintainable code: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.

A web app that loads a single HTML page and dynamically updates content without full page reloads. React, Vue, and Angular build SPAs.

A language for managing and querying relational databases. Used to create tables, insert data, query records, update values, and delete entries.

Generating HTML at build time rather than on each request. Pages are pre-rendered and served as static files. Fast but content doesn't update without a rebuild.

Rendering HTML on the server for each request instead of in the browser. Improves initial load time and SEO. Next.js supports SSR out of the box.

Data that changes over time within a component. When state updates, the component re-renders with the new data. Managed with useState in React functional components.

A development process where you write a failing test first, then write the minimum code to make it pass, then refactor. Red-green-refactor cycle.

The implied cost of future rework caused by choosing a quick solution now instead of a better approach that would take longer. Like financial debt — it accumulates interest over time.

Converting source code from one language or version to another. TypeScript is transpiled to JavaScript. Modern JavaScript is transpiled to older versions for browser compatibility.

A bundler optimization that removes unused code from the final bundle. If you import one function from a library, tree shaking ensures only that function's code is included.

A classification that determines what operations can be performed on a value. In TypeScript, types include primitives (string, number, boolean), objects, arrays, and custom types.

A test that verifies a single function or module in isolation. Fast to run, easy to write. Tests one specific behavior with known inputs and expected outputs.

A lightweight copy of the actual DOM kept in memory. React compares the virtual DOM to the real DOM and only updates what changed, making UI updates efficient.

An automated HTTP callback triggered by an event. Instead of polling an API for updates, a webhook pushes data to your URL when something happens (payment received, PR merged, etc).

A protocol for real-time, bidirectional communication between client and server over a single persistent connection. Used for chat apps, live updates, and collaborative editing.

Don't build features until you actually need them. Premature abstraction and over-engineering waste time and add complexity.