Plain-English definitions

Showing two different versions of something (a button, a page layout) to different users to see which performs better. Half the visitors see Version A, half see Version B, and you measure which gets more clicks or sign-ups.

Hiding complex implementation details and showing only what is necessary. Like driving a car - you use the steering wheel and pedals without needing to understand the engine internals.

Designing products so people with disabilities - visual, motor, hearing, or cognitive - can use them effectively. Includes semantic HTML, keyboard navigation, ARIA attributes, sufficient color contrast, and screen reader support. Also broadens potential audience.

Four properties that guarantee reliable database transactions. Atomicity (all or nothing), Consistency (data stays valid), Isolation (concurrent transactions don't interfere), Durability (committed data survives crashes). Relational databases like PostgreSQL are ACID-compliant.

A structural design pattern that makes incompatible interfaces work together. The adapter wraps one object and translates its interface into the one the client expects. Like a power plug adapter - same electricity, different socket shape.

The compute boundary where an agent accesses files, runs code, and produces artifacts. It may be provider-hosted, partner-hosted, self-hosted, or absent, and its ownership does not by itself determine where session data is retained or which tools are authorized.

The orchestration step that dispatches several independent work packets to separate agents or sessions. Safe fan-out happens only after dependencies, workspace ownership, required evidence, and the concurrency limit are explicit.

The runtime layer around an AI model that manages its instructions, tool loop, state, approvals, tracing, and stopping conditions. The model proposes actions; the harness decides what context and capabilities are available and how those actions are executed.

The practice of understanding an AI agent's behavior by correlating workflow traces, model and tool operations, safety decisions, resource usage, and external outcomes. It focuses on causal evidence rather than storing a transcript or trusting the agent's final status.

A provider- or application-tracked unit of agent work that can span multiple turns, events, tool calls, and recoveries under one configuration. Its identifier helps correlate execution, but it should not replace application-owned workflow state or side-effect records.

A trace span representing one invocation of an AI agent. It records the operation's timing, parent trace relationship, stable agent identity, status, and bounded metadata while model calls, plans, handoffs, and tools appear as nested or related spans.

Providing new context, constraints, corrections, or stop instructions to an agent while a task is in progress. Good steering changes the active plan explicitly and records decisions in the task's durable artifact instead of relying on scattered chat messages.

The ordered record of an agent trial, including model outputs, tool calls, observations, intermediate state, retries, and the final response. A trajectory explains how an outcome was reached and is also called a trace or transcript in many evaluation systems.

A managed credential container attached to an agent session so approved integrations can authenticate without placing raw secrets in prompts or workspace files. Vault attachment still requires narrow scopes, explicit tool admission, rotation, and audit evidence.

AI-assisted code review in which a reviewer can reason across a change, repository instructions, tests, and approved read-only tools instead of analyzing isolated lines only. The reviewer can propose findings, but an accountable owner still validates the evidence and controls merge authority.

A multi-step process where an AI model autonomously plans, executes sub-tasks using tools, evaluates intermediate results, and iterates until a goal is achieved. Goes beyond single-shot question-answering to completing complex, multi-stage tasks.

An iterative software development methodology emphasizing collaboration, flexibility, and delivering working software in small increments. Contrasted with Waterfall's sequential phases. Scrum and Kanban are popular Agile frameworks. The Agile Manifesto defines the core values.

An AI system that can autonomously take actions to complete goals - browsing the web, writing and running code, calling APIs, reading files - rather than just generating text responses. Agents plan multi-step tasks and use tools.

The challenge of ensuring AI systems pursue goals that genuinely match human values and intentions, rather than pursuing proxy goals with unintended consequences. A central concern in AI safety research as models become more capable and autonomous.

Systematic, unfair errors in AI model outputs caused by imbalanced, unrepresentative, or prejudiced training data. A model trained on historical hiring data may perpetuate discriminatory patterns. Detecting and mitigating bias is a critical AI safety and ethics challenge.

A technique for fetching data from a server in the background without a full page reload. Now usually sends and receives JSON rather than XML. The foundation of SPAs - updating parts of a page dynamically using fetch() or XMLHttpRequest.

A step-by-step set of instructions for solving a problem or accomplishing a task. Every program is ultimately a collection of algorithms. Algorithms are evaluated on their time complexity (how fast) and space complexity (how much memory).

A set of rules that lets two software applications talk to each other. Think of it as a waiter in a restaurant - you (the client) place an order, the waiter (API) takes it to the kitchen (server), and brings back your food (data). You never need to go into the kitchen yourself.

A server that acts as a single entry point for all client requests in a microservices system. Routes requests to the correct service, handles authentication, rate limiting, request/response transformation, and aggregation of multiple service responses.

A unique secret string used to authenticate requests to an API. Sent in HTTP headers (Authorization: Bearer sk-...) or query parameters. Must be kept secret - never commit API keys to source control. Use environment variables to store them.

Assigning unique identifiers to API releases so clients can continue using a stable version while new versions are developed. Common strategies: URL versioning (/v1/users), header versioning (API-Version: 2), or query param (?version=1).

A non-human identity assigned to an installed application or integration when it creates issues, pull requests, comments, or other artifacts. App identity keeps automated actions attributable to the integration instead of presenting them as a person's direct work.

An ordered collection of values stored in a single variable, accessed by numeric index starting at 0. JavaScript arrays are dynamic - they grow as needed, can hold mixed types, and come with built-in methods like map, filter, and reduce.

A higher-order array method that returns a new array containing only elements that pass a test function. Does not mutate the original array. Paired with .map() and .reduce() as the key functional array methods in JavaScript.

A self-contained, interactive output generated by an AI model - such as a runnable code snippet, mini-app, structured document, or visualization - that exists independently of the conversation and can be previewed, executed, and reused. Popularized by Claude's Artifacts feature, where outputs render in a live sandbox alongside the chat.

Evidence showing who or what created an artifact, which inputs and decisions shaped it, and what process produced it. For agent-authored work, provenance should connect the conversation or issue, agent session, branch, checks, approvals, and final pull request.

A statement in a test that checks whether a condition is true. If the assertion fails, the test fails. Testing libraries like Vitest and Jest provide chainable assertion APIs: expect(result).toBe(42); expect(array).toHaveLength(3).

A tree representation of the syntactic structure of source code, produced by a parser. Each node represents a construct: functions, variables, operators, expressions. Linters, compilers, transpilers, and code formatters all operate on ASTs rather than raw text.

A way to write code that handles time-consuming tasks (like fetching data from the internet) without freezing the rest of the program. 'Async' marks a function as potentially slow, and 'await' tells it to pause and wait for a result before continuing.

The core innovation in transformer models that allows each token in a sequence to weigh the relevance of every other token when generating output. 'Self-attention' lets the model understand relationships like pronouns referring to nouns, regardless of distance.

Verifying who a user is - confirming their identity through credentials. Contrasted with authorization (what they're allowed to do). Methods include password, OAuth (login with Google), magic link, passkeys, and MFA (multi-factor authentication).

Determining what an authenticated user is allowed to do. Happens after authentication. Role-based access control (RBAC) is common: an 'admin' can delete users; a 'viewer' can only read. Also called access control.

Automatically adjusting the number of running server instances based on current load. Scale up when traffic spikes; scale down when it drops to save cost. Cloud providers (AWS, GCP, Azure) and container orchestration platforms (Kubernetes) support auto-scaling.

A repository rule or review setting that requests another automated review when new commits are pushed to a pull request. It helps keep findings and approvals aligned with the code that will merge, but it does not replace final-head checks or human ownership.

A JavaScript compiler (transpiler) that converts modern ES6+ and JSX code into backward-compatible JavaScript for older browsers. Though increasingly replaced by Vite/esbuild for speed, Babel remains widely used through frameworks like Create React App.

The server-side of an application - everything the user cannot directly see or interact with. This includes the database, business logic, and server. If the frontend is the storefront, the backend is the warehouse and accounting office.

A mechanism to slow down producers when consumers cannot keep up with the rate of data. In Node.js streams, backpressure prevents memory exhaustion by pausing reads until the write buffer drains. Important in real-time data pipelines.

Processing large amounts of data in groups at scheduled intervals rather than in real time. More efficient than processing records one by one. Examples: nightly billing runs, weekly report generation, bulk ML inference.

Measuring the performance of code, systems, or models under defined, reproducible conditions to compare alternatives or track improvement over time. Microbenchmarks measure individual functions; macrobenchmarks measure end-to-end system performance.

A mathematical notation describing how an algorithm's runtime or memory usage scales as input size (n) grows. O(1) is constant, O(log n) is logarithmic, O(n) is linear, O(n²) is quadratic. Used to compare algorithm efficiency independent of hardware.

A tree data structure where each node has at most two children (left and right). Binary search trees (BSTs) keep the left child smaller and right child larger, enabling O(log n) search. Balanced BSTs (like AVL trees) maintain this property after insertions.

A data type for storing large binary data - images, videos, PDFs, audio files - directly in a database or object storage. Cloud object stores (S3, Vercel Blob, Cloudflare R2) are designed specifically for blob storage at scale.

A release strategy where you keep two identical production environments (blue and green). You deploy to the inactive one, test it, then switch traffic over instantly. If something goes wrong, switching back takes seconds.

A primitive data type with only two possible values: true or false. Named after mathematician George Boole. Used in conditionals, flags, and logical operations.

Setting up a new project with all the initial configuration, dependencies, build tooling, and directory structure. CLI tools like 'create-next-app' bootstrap Next.js projects automatically. Named after 'pulling yourself up by your bootstraps'.

A pull request whose author is an application, automation account, or coding agent rather than a person. Bot authorship preserves provenance but increases the importance of independent review, final-head checks, and an accountable human merge decision.

A separate copy of your codebase where you can experiment and make changes without affecting the main working version. Once your changes are tested and approved, you merge the branch back in.

An update to a library or API that is not backward compatible - meaning existing code that uses the library will stop working without modification. A major version bump in semantic versioning signals a breaking change.

A temporary region of memory used to hold data while it is being transferred between two places. Buffers smooth out differences in speed between producers and consumers - a video buffer stores ahead-of-time frames so playback doesn't stutter if the network hiccups. In Node.js, the Buffer class handles raw binary data.

The process of transforming raw source code into an optimized, deployable output. A build step typically transpiles TypeScript, bundles modules, minifies output, and generates static assets. 'npm run build' triggers this in most JS projects.

Any file produced by a build process that is intended for deployment or distribution. Examples: a compiled binary, a Docker image, a minified JS bundle, or a ZIP archive. CI/CD pipelines store artifacts for deployment and auditing.

The process of combining many separate JavaScript files into one (or a few) optimized files for the browser to download. Fewer files means faster page loads.

The fundamental unit of digital information storage, consisting of 8 bits. Each bit is a 0 or 1. A byte can represent 256 different values (2^8). File sizes are measured in kilobytes (KB), megabytes (MB), gigabytes (GB), etc.

A faster storage layer that holds copies of frequently accessed data so future requests can be served quicker. Caches exist at many levels: CPU caches, browser caches, CDN caches, and application-level caches like Redis.

The degree to which cached content is still current and accurate. Controlled by Cache-Control headers (max-age, stale-while-revalidate). CDNs and browsers consider content 'stale' after expiry and re-fetch it from the origin server.

The process of removing or marking cached data as stale when the underlying source data changes. One of the two hard problems in computer science (along with naming things). Done via TTLs (time-to-live), event-driven purging, or versioned cache keys.

A runtime data structure that tracks function invocations. When you call a function, it's pushed onto the stack. When it returns, it's popped off. Exceeding the stack limit (infinite recursion) causes a 'Maximum call stack size exceeded' error.

A function passed as an argument to another function, to be called when that function finishes. Like leaving your number at a restaurant - they call you back when your table is ready instead of you standing there waiting.

A naming convention where the first word is lowercase and each subsequent word starts with a capital letter. The dominant convention for variables and functions in JavaScript/TypeScript. Related conventions: PascalCase (all words capitalized), snake_case, kebab-case.

Rolling out a new version of software to a small percentage of users first (e.g. 5%) before releasing it to everyone. Named after the 'canary in a coal mine' - if problems are detected early, you limit the blast radius.

A fundamental theorem stating that a distributed system can only simultaneously guarantee two of three properties: Consistency (all nodes see the same data), Availability (every request gets a response), and Partition Tolerance (the system works despite network failures). You must choose which two to optimize for.

An evaluation suite designed to measure what an AI system can do and where it still has room to improve. Capability tasks may start with low pass rates and are used to compare models, prompts, tools, or harness strategies.

A network of servers distributed around the world that delivers website content from the server closest to the user. Instead of everyone connecting to one server in New York, someone in Tokyo gets content from a Tokyo server - much faster.

A prompting technique that asks an AI to reason through a problem step-by-step before giving a final answer. Asking the model to 'think out loud' significantly improves accuracy on complex reasoning and math problems.

A file (usually CHANGELOG.md) documenting all notable changes between versions of a project - new features, bug fixes, breaking changes, and deprecations. Helps developers understand what changed between versions before upgrading.

A system that maps characters to binary values. UTF-8 is the universal web standard - it encodes every Unicode character while being backward-compatible with ASCII. Misconfigured encoding causes mojibake (garbage characters like é).

A saved snapshot of a model's weights at a specific point during training. Checkpoints let you resume training after an interruption, compare model performance at different training stages, or roll back to a better-performing earlier state.

A value computed from data using a hash function, used to verify integrity. If the data changes (corruption or tampering), the checksum changes. Package managers use checksums to verify downloaded packages haven't been tampered with.

Applying a specific commit from one branch onto another without merging the entire branch. Useful for porting a bug fix from a feature branch to main, or backporting a fix to an older release, without pulling in unrelated changes.

A piece of a larger JavaScript bundle, produced by code splitting. Instead of one massive bundle, an application is split into multiple chunks loaded on demand. The main chunk loads immediately; route-specific chunks load as users navigate.

An automated process where every code change is automatically tested (CI) and then deployed to production (CD) if all tests pass. Eliminates the manual 'deploy day' and catches bugs before users ever see them.

A resilience pattern that monitors calls to an external service and 'opens' (stops sending requests) when failures exceed a threshold, giving the failing service time to recover. The circuit gradually closes again after a cooldown period.

A blueprint for creating objects in object-oriented programming. A class defines the properties (data) and methods (behavior) that all objects created from it will have. Think of a class as the cookie cutter and objects as the cookies.

A supervised machine learning task that assigns inputs to predefined categories. Binary classification has two classes (spam/not spam); multiclass handles multiple categories (animal type). Contrasted with regression, which predicts continuous numerical values.

A text-based interface for interacting with software by typing commands, as opposed to clicking buttons in a graphical app. Developers use CLIs because they are faster, scriptable, and more powerful for repetitive tasks.

A distributed application structure where clients (browsers, mobile apps) send requests to a central server that processes them and responds. The server holds the data and business logic; clients handle the UI. The internet is fundamentally built on this model.

A function that remembers variables from its outer scope even after that outer function has finished running. It 'closes over' the variables it needs.

Delivering computing resources (servers, storage, databases, networking) over the internet on demand, billed by usage. The major providers are AWS, Google Cloud, and Azure. Eliminates the need to own and manage physical hardware.

A group of servers or nodes working together as a unified system to provide higher availability, performance, and fault tolerance. Database clusters replicate data across nodes. Kubernetes clusters run containers across many machines.

A tool that automatically reformats source code to enforce consistent style: indentation, line length, quote style, and more. Prettier is the dominant JavaScript formatter. Formatting is non-opinionated busy-work best left to automation.

A surface-level indication in source code that may signal a deeper design problem. Examples: functions that are too long, deeply nested conditionals, duplicated code, and cryptic variable names. Code smells don't break things outright but increase technical debt.

Breaking your application's JavaScript into smaller pieces that are only loaded when needed. Instead of downloading the entire app upfront, users download only what they need for the current page.

A shared AI-agent workspace where multiple people can observe the same task, contribute context, and steer the agent while it produces traceable artifacts. Participation does not automatically grant authority to start writes, approve changes, or merge the result.

A field in a database table that stores a specific attribute for all rows. Each column has a name and data type (VARCHAR, INTEGER, BOOLEAN, etc.). Normalizing a database involves deciding which attributes belong in which table's columns.

A snapshot of your changes saved to the Git history with a descriptive message. Each commit records who made the change, when, and what changed. Commits are the fundamental unit of history in Git.

The phase before execution where source code is analyzed, checked, and transformed. TypeScript's type checking happens at compile-time - errors are caught before the code runs, as opposed to runtime errors that only surface during execution.

A program that translates source code written in one language (like TypeScript or C++) into another language (usually machine code or bytecode) that a computer can execute. The entire program is translated at once before running.

An API endpoint that accepts a prompt (or messages array) and returns AI-generated text continuations. The standard interface offered by OpenAI, Anthropic, and others. Parameters like temperature and max_tokens control response randomness and length.

A reusable, self-contained piece of UI that encapsulates its own structure, styles, and logic. Modern frameworks like React and Vue are built around components. Breaking UIs into small components makes code easier to build, test, and maintain.

Reducing the size of data files for faster network transfer. Servers use gzip or Brotli to compress HTML, CSS, and JS before sending them to browsers. The browser decompresses them automatically. Can reduce file sizes by 60-80%.

The ability to handle multiple tasks by interleaving their execution, even on a single CPU core. Different from parallelism, which requires multiple CPU cores running simultaneously. JavaScript achieves concurrency through its event loop.

The maximum number of agent work packets a team chooses to run at once after considering true task independence, review capacity, shared infrastructure, rate limits, cost, and coordination overhead. It can be lower than the platform's technical session limit.

A programming construct that executes different code depending on whether a condition evaluates to true or false. if/else, switch, and the ternary operator (condition ? a : b) are the common forms. The basic building block of program logic.

Managing infrastructure and application configuration in version-controlled code files rather than through GUIs or manual settings. Makes environments reproducible, enables reviews and rollbacks, and eliminates 'configuration drift' between environments.

A security problem where a privileged service is tricked into using its authority on behalf of a caller that lacks that permission. Clear resource audiences, per-service credentials, and authorization checks help prevent the deputy from acting outside the caller's rights.

Anthropic's approach to training AI systems to follow a set of written principles, enabling the model to critique and revise its own outputs for safety and helpfulness. Reduces dependence on human feedback for every edge case.

A service or function that reads and processes messages from a message queue or event stream. Paired with a producer that writes messages. Consumers can be scaled independently from producers to handle varying throughput.

A lightweight, self-contained package that includes everything an application needs to run: its code, runtime, system tools, and settings. Containers run the same way on any machine, eliminating the 'it works on my computer' problem.

A product policy that prevents specified files from being used through supported AI context paths. Coverage depends on the client and mode; it is not a general filesystem access-control rule.

The HTTP mechanism where a client and server agree on the best format for a response. The client declares what it accepts via Accept headers (Accept: application/json, text/html); the server responds in the best matching format. Also applies to language (Accept-Language) and encoding (Accept-Encoding).

An HTTP header that specifies the media type (MIME type) of data in a request or response body. Tells the receiver how to parse the data. application/json, text/html, multipart/form-data, and image/png are common values.

The discipline of designing, curating, and structuring the full information payload sent to an LLM to maximize response quality. Goes beyond prompt crafting to include managing retrieved documents, conversation history, tool outputs, and system instructions within the constraints of the context window.

The maximum amount of text (measured in tokens) an AI model can 'see' and reason about at one time. Think of it as the model's working memory - information outside the window is forgotten. Larger windows let you feed in more documents, code, or conversation history.

A practice where code changes are automatically built, tested, and kept in a deployable state at all times. Distinct from Continuous Deployment (where every passing commit auto-deploys to production) - Continuous Delivery still gates the final prod deployment on a human approval.

Ongoing, automated collection and analysis of metrics, logs, traces, and alerts from production systems. Enables rapid detection of performance degradation, errors, and security incidents. Tools include Datadog, Grafana, and AWS CloudWatch.

A design philosophy that reduces the number of decisions developers need to make by providing sensible defaults. Developers only configure what deviates from convention. Rails famously popularized this approach. Next.js's file-system routing is convention-over-configuration.

A workflow that converts decisions from a team conversation into a bounded implementation brief, then carries that brief into a repository change and pull request without losing scope, provenance, or review requirements.

Small pieces of data stored in the browser by a website and automatically sent back with every subsequent request to that site. Used for session management, personalization, and tracking. Security flags like HttpOnly and Secure control access.

An optimization where a resource is shared until a write occurs, at which point a private copy is made. Used in file systems, databases, and memory management. Reduces unnecessary copying while maintaining isolation when mutations occur.

Google's set of real-world user experience metrics: LCP (Largest Contentful Paint - load speed), INP (Interaction to Next Paint - responsiveness), and CLS (Cumulative Layout Shift - visual stability). Together they measure the quality of user experience and influence SEO rankings.

A browser security feature that controls which websites can request data from another website's server. For example, it prevents a malicious site from silently making requests to your bank's API using your logged-in session.

An automatic browser check before certain cross-origin requests. The browser sends an OPTIONS request asking the server if the real request (with its method and headers) is permitted. The server responds with allowed methods and headers. If it passes, the actual request is sent. Only triggered for non-simple requests.

The degree of interdependence between software modules. Tight coupling means changing one module requires changing others. Loose coupling is preferred - modules can evolve independently. Dependency injection and interfaces are tools for reducing coupling.

An architectural pattern that separates read operations (queries) from write operations (commands) into distinct models and data paths. The query side is optimized for fast reads; the command side handles writes and emits domain events. Often paired with Event Sourcing for systems with complex business logic.

A time-based task scheduler in Unix-like systems for running scripts at specified intervals. The cron syntax defines when: '0 * * * *' runs every hour. Used for database backups, sending digest emails, or refreshing cached data.

Software that works across multiple operating systems or device types (Windows, macOS, Linux, iOS, Android) without requiring separate code. Electron, React Native, and Tauri are frameworks for building cross-platform apps from a single codebase.

A model evaluation technique that splits data into k folds - training on k-1 folds and testing on the remaining one, repeated k times. Averages results across all folds for a more reliable performance estimate than a single train/test split.

The four basic operations you can perform on data stored in a database. Almost every application is fundamentally doing some combination of these four things.

The science of securing information through encoding so that only intended recipients can read it. Modern cryptography underpins HTTPS, password storage, digital signatures, and end-to-end encryption. Key concepts: symmetric encryption, public-key cryptography, and hash functions.

A browser security mechanism delivered via an HTTP response header that tells the browser which sources of content (scripts, styles, images, fonts) are trusted. Blocks the execution of injected scripts, dramatically reducing the impact of XSS attacks. A strict CSP is one of the most effective XSS mitigations available.

An attack that tricks an authenticated user's browser into sending an unintended request to a website where they are logged in. Prevented with CSRF tokens (unique values in forms the server validates) and the SameSite cookie attribute.

A CSS file where all class and animation names are locally scoped by default - the build tool transforms class names into unique hashes so there are no global naming collisions. Lets you write simple, flat CSS without worrying about selector conflicts across components.

A functional programming technique that transforms a function taking multiple arguments into a series of functions each taking a single argument. Enables partial application - pre-filling some arguments and returning a new function for the rest.

A reusable function in React that starts with 'use' and extracts shared stateful logic from components. Composing custom hooks keeps components clean and logic reusable. Examples: useLocalStorage, useDebounce, useFetch.

A code metric measuring the number of independent paths through a function. Each branch point (if, for, while, case, &&, ||) adds one to the count. Higher complexity means harder to test and understand. A score above 10 typically signals a function needs to be broken up.

Automatically synchronizing data between the data model and the UI. Two-way binding (Angular) keeps both in sync simultaneously. One-way data flow (React) flows data down from parent to child, with events flowing back up - more predictable.

Moving, transforming, or updating data in a database, typically when the schema changes. Migrations are run as ordered scripts that alter the database structure. Tools like Prisma Migrate and Flyway manage migration history.

A way of organizing and storing data in memory to enable efficient access and modification. Choosing the right data structure for a problem dramatically affects performance. Common structures include arrays, linked lists, trees, and hash maps.

Creating a data structure that allows the database to find rows matching a query much faster, without scanning the entire table. Like a book's index - instead of reading every page, you look up the term and jump to the page. Trade-off: indexes speed up reads but slow down writes.

Organizing database tables to reduce data redundancy and improve data integrity by following a series of normal forms (1NF, 2NF, 3NF). The goal is to store each piece of information in only one place.

Populating a database with initial or sample data, usually during development or testing setup. Seed scripts create realistic test records so developers can work with the app without manually entering data every time.

A sequence of database operations treated as an atomic unit - either all succeed or all fail together. Transactions guarantee the ACID properties. Essential for operations like transferring money, where you must debit one account and credit another as one unit.

A structured collection of data used to train, validate, or test a machine learning model. Quality, diversity, and size of the dataset are the most important factors in model performance. Curating a good dataset is often harder than building the model.

Code that exists in a codebase but is never called or reached during execution. Wastes space, confuses developers, and can hide bugs. Tree-shaking removes dead code from bundles. Linters can flag unused variables and imports.

A situation where two or more processes are each waiting for a resource held by the other, so none can proceed. Classic example: Thread A holds Lock 1 and waits for Lock 2; Thread B holds Lock 2 and waits for Lock 1. Both wait forever. Prevented by always acquiring locks in a consistent order.

A technique that delays executing a function until after a user has stopped triggering it for a set time. Used to prevent a search bar from firing an API request on every single keystroke - it waits until the user pauses typing.

A programming paradigm where you describe *what* you want, not *how* to achieve it. SQL ('SELECT users WHERE age > 18'), React JSX, and CSS are declarative. The runtime figures out the implementation. Contrasted with imperative code that specifies every step of the procedure.

A function that wraps another function or class to add or modify behavior without changing the original code. Common in TypeScript, Python, and frameworks like Angular. A clean way to apply cross-cutting concerns like logging or validation.

A subset of machine learning using neural networks with many layers (deep networks) to automatically learn complex representations from raw data. Powers modern AI breakthroughs in image recognition, speech processing, and language models.

A JavaScript/TypeScript module export that doesn't need to be imported by a specific name - the importer can call it whatever they like. Contrasted with named exports, which must be imported with their exact name (or aliased).

The repository and usually the default branch an integration selects when a request does not name an explicit target. Defaults reduce repetition but can send agent work to the wrong project or branch when shared channel settings change.

External code (a library or package) that your project relies on to function. When you install a package, it becomes a dependency. Projects typically have dozens to hundreds of dependencies managed by a package manager.

A directed graph showing how packages and modules depend on each other. Build tools use it to determine build order and what to re-bundle after a change. Package managers use it to detect version conflicts and circular dependencies.

A design pattern where a class receives the objects it needs (dependencies) from outside rather than creating them itself. Makes code more flexible and easier to test because you can swap out real dependencies for fake ones during testing.

The process of releasing a version of software to a target environment - development, staging, or production. Modern deployments are automated through CI/CD pipelines and can be as simple as a git push to a platform like Vercel.

State that is computed from other state values rather than stored independently. In React, prefer computing derived values during render instead of storing them in separate useState hooks. Avoids synchronization bugs and keeps state minimal.

A reusable, proven solution to a common software design problem. Not actual code - more like a blueprint or recipe. Examples include Singleton (one instance), Observer (event listeners), and Factory (object creation).

A JavaScript/TypeScript syntax for unpacking values from arrays or properties from objects into distinct variables. Makes code more readable and concise. Commonly used in function parameters to pull out specific values.

A local or hosted setup configured specifically for writing and testing code, separate from staging and production. Includes IDE, local dev server, test database, and environment variables. Reproducible dev environments (via Docker or devcontainers) prevent 'works on my machine' issues.

A comparison between two versions of a file or codebase showing what was added (green), removed (red), or unchanged. Git produces diffs between commits. Code review tools show diffs of changed lines in a pull request.

An algorithm that efficiently computes the differences between two data structures. React's reconciler uses a diffing algorithm to compare old and new virtual DOM trees and apply only the minimal necessary DOM updates.

A TypeScript pattern that uses a shared literal property (the discriminant) to narrow union types in conditionals. When you check the discriminant, TypeScript narrows the type to the correct variant automatically.

A system where components run on multiple networked computers and coordinate by passing messages to achieve a common goal. Examples include microservices, databases with replication, and blockchain networks. Hard to build due to network failures and consistency challenges.

Tracking a request as it propagates through multiple services in a distributed system, recording timing and errors at each hop. Produces a 'trace' with spans showing end-to-end latency and where time is spent. OpenTelemetry, Jaeger, and Zipkin support distributed tracing.

The internet's phone book. When you type 'google.com', DNS translates that human-readable name into an IP address like '142.250.80.46' that computers use to find each other.

The process of translating a human-readable domain name (example.com) into an IP address. Your device checks a local cache, then your router, then a recursive resolver, then authoritative DNS servers. Add --dns flag to curl to diagnose issues.

A platform for building, shipping, and running applications in containers. Docker ensures your app works identically in development, testing, and production by packaging all its dependencies together.

Written explanations of code, APIs, and systems aimed at helping developers understand, use, and maintain them. Includes README files, API references, architecture diagrams, and inline code comments. Often the difference between adoption and abandonment of a library.

The browser's in-memory tree representation of an HTML page. JavaScript interacts with the DOM to read and update page content dynamically. Direct DOM manipulation is slow; frameworks like React use a virtual DOM to minimize it.

A coding principle that says every piece of knowledge or logic should only exist in one place. If you find yourself copying and pasting the same code block, it should probably be a reusable function.

A mini-language designed for a narrow, specific domain rather than general-purpose programming. SQL is a DSL for querying databases. CSS is a DSL for styling. Regex is a DSL for pattern matching. DSLs trade expressiveness for ease in their domain.

A dynamic typing approach where an object's suitability is determined by whether it has the required properties and methods, not its declared type. 'If it walks like a duck and quacks like a duck, it is a duck.' JavaScript uses duck typing.

A workflow design that persists progress outside the running process so work can resume after a crash, timeout, redeploy, or long human wait. Durable systems checkpoint state and make repeated steps safe instead of assuming one uninterrupted run.

Loading a JavaScript module at runtime using import() instead of at the top of a file. Returns a Promise. Enables code splitting - loading heavy components only when needed, reducing initial bundle size.

Evaluating expressions as soon as they are bound to a variable. The default in JavaScript and most languages. Contrasted with lazy evaluation, where expressions are only computed when their value is first accessed. Lazy evaluation enables infinite sequences.

Loading all related data upfront rather than deferring it until needed. In ORMs, eagerly loading associations avoids the N+1 query problem by fetching related records in one query instead of issuing a query per record.

The official language specification that JavaScript is based on, maintained by Ecma International. New versions add features: ES6 (2015) brought classes, arrow functions, and modules. Browsers implement the spec; transpilers let you use new features in old environments.

An unusual input or situation at the extreme boundaries of a system that can cause unexpected behavior. Good testing covers not just the 'happy path' but edge cases like empty inputs, maximum values, null, special characters, and concurrent requests.

Serverless code that runs on servers distributed around the world, as close to the user as possible. Unlike a normal server in one location, edge functions execute in the nearest data center, reducing latency significantly.

A way of representing text, images, or other data as lists of numbers (vectors) that capture their meaning. Similar concepts get similar numbers, allowing AI systems to find related content through math rather than keyword matching.

Triggering a named event that registered listeners can respond to. In Node.js EventEmitter, emitter.emit('data', payload) fires all listeners for 'data'. In Vue, components emit events up to parents with $emit. Part of event-driven programming.

Bundling data (variables) and the methods that operate on that data within a single unit (a class), and hiding internal details from the outside world. Like a capsule that protects its contents.

Tests that simulate real user interactions through the full application stack - browser, frontend, API, and database - to verify complete user journeys work correctly. Playwright and Cypress are the leading E2E frameworks. E2E tests catch integration bugs that unit and integration tests miss, but are slower and more brittle.

A specific URL where an API receives and processes requests. Each endpoint corresponds to a resource or action. For example, GET /users returns a list of users, and POST /users creates a new one.

A distinct object or concept in a domain model that has a unique identity and data stored about it. In databases, an entity maps to a table. In domain-driven design, entities are objects with a lifecycle and identity (like a User or Order).

The measure of randomness or unpredictability in data used for cryptographic operations. High entropy is necessary for strong encryption keys, session tokens, and password salts. Low entropy makes values predictable and easier to attack.

The file or function where a program starts execution. In browsers, the main JS bundle is the entry point. In Next.js, app/layout.tsx and individual page.tsx files serve as entry points. Bundlers trace all imports starting from the entry point.

A set of named constant values representing a fixed collection of options. Enums make code more readable and type-safe by replacing magic strings or numbers with descriptive names.

A variable stored outside your code (on the server or in a config file) that holds sensitive or environment-specific settings like API keys, database passwords, or server URLs. Keeps secrets out of your source code.

One complete pass through the entire training dataset during model training. Training for multiple epochs repeatedly exposes the model to all training examples. Too few epochs leads to underfitting; too many leads to overfitting.

A React component that catches JavaScript errors in its child component tree and displays a fallback UI instead of crashing the entire page. Defined using the static getDerivedStateFromError lifecycle method in a class component.

The official JavaScript module system using 'import' and 'export' statements. Replaced the older CommonJS (require/module.exports) system. ESM enables tree-shaking and runs natively in modern browsers.

An HTTP response header containing a unique identifier for a specific version of a resource. On subsequent requests, the client sends the ETag back via If-None-Match; the server returns 304 Not Modified if unchanged, saving bandwidth.

Leakage that lets a tested AI system access evaluation tasks, answers, grader logic, or artifacts from other trials, causing scores to overstate real capability. Contamination can come from training data, browsing, repository history, logs, caches, or shared environment state.

The infrastructure that provisions test environments, runs an AI system against evaluation tasks, captures traces and outcomes, invokes graders, and aggregates results. It is separate from the agent harness being tested and must keep trials isolated and reproducible.

An object that allows you to subscribe to named events and emit them. The backbone of Node.js I/O - streams, servers, and processes all extend EventEmitter. The publish-subscribe pattern in miniature.

The mechanism in JavaScript that allows the language to handle multiple tasks even though it can only do one thing at a time. It continuously checks if there are tasks waiting (like network responses) and processes them in order.

An architectural pattern where all changes to application state are stored as an ordered sequence of events rather than the current state. To reconstruct state, replay the events. Provides a full audit log and enables time-travel debugging.

A design pattern where services communicate by emitting and reacting to events rather than making direct calls. Producers emit events to a message bus; consumers subscribe and react independently. Promotes loose coupling and scalability.

A consistency model in distributed systems where, given no new updates, all replicas will eventually converge to the same value. Allows high availability at the cost of momentary inconsistencies. Used by many NoSQL databases and CDNs.

An event that disrupts the normal flow of a program's execution. Languages use try/catch blocks to handle exceptions gracefully rather than crashing. Unhandled exceptions typically terminate the process.

The enforced separation between an agent's decision-making runtime and the environment where commands, code, or UI actions run. A strong boundary limits files, processes, network access, identity, and credentials independently of the model's instructions.

The environment in which JavaScript code is evaluated. Contains the scope chain, variable bindings, and the value of 'this'. The global execution context runs first; function calls create new contexts pushed onto the call stack.

The ability to understand and interpret why an AI model produced a specific output. Critical in high-stakes domains like healthcare, finance, and hiring. Attention visualization, SHAP values, and LIME are techniques for explaining model decisions.

A retry strategy where the delay between retries increases exponentially (e.g., 1s, 2s, 4s, 8s...) to avoid overwhelming a recovering service. Often includes jitter (random variance) to prevent thundering herds when many clients retry simultaneously.

Any piece of code that evaluates to a value. 2 + 2, user.name, and callFunction() are all expressions. Contrasted with statements (which perform actions but don't produce values). JSX is special syntax that compiles to function call expressions.

A structural design pattern providing a simplified, unified interface to a complex subsystem. The facade hides the complexity behind an easy-to-use class, shielding clients from intricate interactions between many objects.

A design principle where a system immediately reports any error conditions rather than attempting to continue in an invalid state. Catching errors early at the source makes debugging dramatically easier than tracking a problem that propagated silently.

A design principle where a system defaults to a safe, conservative state when a failure occurs. Rather than crashing or behaving unpredictably, a fail-safe system denies access or disables features gracefully when something goes wrong.

A control that denies the governed operation when its authorization or configuration cannot be evaluated safely, rather than treating an error as permission.

The controlled phase that collects parallel agent outputs, reviews their evidence, combines accepted changes in dependency order, and verifies the resulting head as one system. Separate branch success does not replace fan-in testing.

A short-lived Git branch created to develop a single feature or fix in isolation from the main branch. Once complete, it's merged back via a pull request. Enables parallel development without developers blocking each other.

A toggle that lets you turn features on or off without deploying new code. You can ship code to production but hide it behind a flag, enabling it only for specific users or when you are ready to launch.

Giving an AI model a few examples of the task you want it to perform before asking it to do the task itself. Like showing a new employee how to fill out a form by demonstrating 2-3 completed examples before handing them a blank one.

In GraphQL, the process by which each field in a query response is fetched by a corresponding resolver function. Resolvers can fetch from a database, call a service, or compute a derived value. Only requested fields are resolved.

Transferring files from a client to a server, typically via multipart/form-data HTTP requests. Servers must validate file type and size, store files securely, and often upload to object storage (S3, Cloudflare R2) rather than the server's local disk.

Further training a pre-trained AI model on a smaller, specialized dataset to make it better at a specific task. Like hiring an expert chef (base model) and then giving them extra training on your restaurant's specific menu.

In a language where functions are 'first-class citizens', they can be stored in variables, passed as arguments, returned from other functions, and stored in data structures - just like any other value. JavaScript fully supports first-class functions.

A test that produces different results (pass or fail) on successive runs without any code changes. Usually caused by timing issues, random data, test order dependence, or unresolved async operations. Flaky tests erode trust in the test suite.

A data type for representing numbers with a decimal point, stored in binary floating-point format. Famous for imprecision: in JavaScript, 0.1 + 0.2 !== 0.3 due to binary representation limits. Use integer cents (not dollars) for financial calculations.

Forcing buffered data to be written to its destination immediately rather than waiting for the buffer to fill. Important for real-time logging, streaming responses, and ensuring data is persisted before a crash. Node.js writable streams have a flush method.

A Git push that overwrites the remote branch history with local history, discarding commits on the remote. Necessary after rebasing but dangerous on shared branches - it rewrites history other developers have already pulled.

A column in one database table that references the primary key of another table, establishing a link between them. Enforces referential integrity - you can't create an order for a user ID that doesn't exist in the users table.

A personal copy of someone else's repository on a platform like GitHub, used to experiment or propose changes without affecting the original. The standard workflow for contributing to open source: fork → branch → change → pull request back to original.

A large AI model trained on broad, diverse data that can be adapted for many different downstream tasks through fine-tuning or prompting. GPT-4, Claude, Gemini, and Llama are foundation models. The 'base' others build on top of.

A React wrapper (<> </> or <React.Fragment>) that groups multiple elements without adding extra DOM nodes. Useful when a component must return multiple elements but you don't want to add a meaningless wrapper <div>.

A pre-built collection of tools, libraries, and conventions that provides a skeleton for building applications. Unlike a library (which you call), a framework calls your code (inversion of control). Next.js, Django, and Rails are frameworks.

Everything in an application that the user directly sees and interacts with - the buttons, text, images, and layouts. Built primarily with HTML, CSS, and JavaScript. If the backend is the engine, the frontend is the car body and dashboard.

Development spanning both the frontend (what users see) and the backend (server, database, APIs). A full-stack developer can build an entire application independently. Next.js is a full-stack framework allowing server and client code to coexist.

The ability of an LLM to invoke predefined functions (tools) based on a user prompt. You describe available functions; the model decides when to call one and with what arguments. Enables AI agents to interact with APIs, databases, and the real world.

A React component defined as a plain JavaScript function that receives props and returns JSX. The modern standard since React Hooks (v16.8). Simpler, more testable, and more composable than the older class component approach.

A programming paradigm treating computation as the evaluation of mathematical functions. Key principles: pure functions (no side effects), immutability, and first-class functions. JavaScript supports a functional style alongside OOP.

A search technique that finds results approximately matching a query, tolerating typos, transpositions, and partial matches. Returns results ranked by similarity score rather than requiring exact string matches. Fuse.js is a popular JavaScript fuzzy search library.

An automatic memory management process where the runtime periodically finds and frees memory that is no longer being used by the program. Prevents memory leaks without the programmer manually tracking every allocation.

A shared OpenTelemetry vocabulary for describing generative-AI operations in traces, metrics, and events. The conventions define names and attributes for model inference, agents, workflows, plans, retrieval, memory, and tool execution so telemetry from different libraries can be analyzed consistently.

A function that can pause its execution (using 'yield') and later be resumed, producing a sequence of values on demand. Unlike regular functions, generators don't run to completion - they hand control back to the caller with each yield.

A way to write reusable code that works with multiple types without sacrificing type safety. You define a placeholder type that gets filled in at usage time. Avoids duplicating nearly identical logic for different types.

A version control system that tracks every change ever made to your code, allowing you to go back to any previous state, see who changed what, and collaborate with others without overwriting each other's work.

Applying a specific commit from one branch onto another branch without merging the entire branch history. Useful for pulling a single bug fix from a feature branch into main, or backporting patches to older release branches.

Downloading a full copy of a remote repository - all files, history, and branches - to your local machine. The starting point for contributing to any project. 'git clone <url>' creates a local repo connected to the remote as 'origin'.

A branching strategy using dedicated branches: main (production), develop (integration), feature/*, release/*, and hotfix/*. Provides structure for teams managing explicit versioned releases. Trunk-based development is a simpler alternative for continuous deployment.

Custom scripts that Git runs automatically before or after events like commit, push, and merge. Pre-commit hooks run linters or tests before a commit is saved. Used to enforce code standards and prevent broken code from being committed.

Temporarily saving uncommitted changes to a stack so you can switch branches with a clean working directory, then restore them later. 'git stash' shelves changes; 'git stash pop' restores and removes the most recent stash.

The outermost scope in a JavaScript program where variables and functions are accessible everywhere. In browsers, the global object is 'window'; in Node.js it's 'global'. Polluting global scope with variables is an anti-pattern causing hard-to-trace bugs.

Application data that is accessible from any component, not confined to a local scope. While convenient, uncontrolled global state causes bugs and hard-to-follow data flow. Managed via tools like Zustand, Redux, or React Context.

The model architecture and naming convention used for OpenAI's language models. 'Generative' (produces text), 'Pre-trained' (trained on large corpus first), 'Transformer' (the attention-based architecture). GPT-4 powers ChatGPT.

Designing applications so that if a feature fails or is unsupported, the core functionality still works - just with reduced capability. The opposite is failing catastrophically. Related to progressive enhancement, which starts from a base and layers up.

Allowing a server to finish processing active requests before shutting down, rather than terminating immediately and dropping in-progress work. Production servers listen for SIGTERM signals and wait for open connections to drain.

A data structure of nodes (vertices) and edges connecting them. Unlike trees, graphs can have cycles and edges in any direction. Directed graphs have one-way edges; undirected have two-way. Used to model social networks, road maps, dependency trees, and state machines.

An alternative to REST APIs where the client specifies exactly what data it needs, rather than getting a fixed response from the server. Eliminates over-fetching (getting more data than needed) and under-fetching (needing to make multiple requests).

Connecting an AI model's outputs to factual, verifiable, real-world information to reduce hallucinations. RAG (Retrieval-Augmented Generation) is the primary grounding technique - retrieving and injecting real documents before the model generates a response.

A high-performance Remote Procedure Call framework using Protocol Buffers for fast binary serialization. Compared to REST (text/JSON), gRPC is faster and strongly typed. Widely used for internal microservice-to-microservice communication.

An early return at the beginning of a function that handles edge cases and invalid inputs, avoiding deeply nested conditionals. Also called early return or bouncer pattern. Makes the 'happy path' visible at a glance.

Technical constraints and filters applied to AI systems to prevent generation of harmful, off-topic, or policy-violating content. Can be input filters (block harmful prompts), output filters (block harmful responses), or model-level alignment training.

When an AI model confidently states something that is factually incorrect or completely made up. The model generates plausible-sounding text based on patterns, not verified facts, so it can fabricate URLs, citations, or code that does not work.

The default scenario in a use case where everything works as expected with valid inputs and no errors. Testing only the happy path is insufficient - edge cases, error states, and invalid inputs must also be tested.

Permanently and physically removing a record from a database. Once hard deleted, the data is gone (unless recovered from backups). Contrasted with soft delete, which marks the record as deleted but keeps the data for auditing or recovery.

A one-way function converting any input into a fixed-size string. Passwords are stored as hashes so even if a database is breached, the original passwords are not exposed. The same input always produces the same hash; you cannot reverse a hash.

A REST constraint where API responses include links to related actions and resources, enabling clients to discover API capabilities dynamically. A response for /orders/123 might include links to /orders/123/cancel and /orders/123/items.

A web browser without a graphical UI, controlled programmatically. Used for automated testing (Playwright, Puppeteer), web scraping, and server-side screenshot generation. Runs the full browser engine without rendering to a screen.

A Content Management System that decouples the content backend from the frontend presentation layer. Content is managed via an admin UI and delivered via APIs, letting developers build the frontend in any framework. Contentful, Sanity, and Strapi are examples.

A region of memory used for dynamic memory allocation - objects created at runtime are stored here. Unlike the stack (fixed-size, automatically managed), heap memory must be explicitly allocated and freed, or managed by a garbage collector.

A system design approach ensuring minimal downtime by eliminating single points of failure through redundancy and failover. An HA database runs on multiple nodes; if one fails, another takes over. Usually expressed as a percentage uptime (e.g. 99.99% = 52 minutes downtime/year).

A function that either takes one or more functions as arguments, or returns a function as its result. Array methods like .map(), .filter(), and .reduce() are higher-order functions. Core to functional programming in JavaScript.

A development feature that updates only the changed parts of an app in the browser without a full page reload. When you save a CSS or JS file, you see the change instantly without losing your current app state.

A React pattern where a function takes a component and returns a new enhanced component. HOCs add cross-cutting behavior (authentication, logging, theming) to any component without modifying it. Mostly replaced by hooks, but still common in older codebases and some libraries.

JavaScript's behavior of moving variable and function declarations to the top of their scope before code runs. This means you can call a function before it appears in the file, but can also cause confusing bugs with 'var' variables.

A function in React (prefixed with 'use') that lets functional components tap into state, lifecycle, and other React features. Introduced in React 16.8 to avoid the complexity of class components. useState, useEffect, and custom hooks are examples.

The code path that executes most frequently in a program. Optimizing hot paths has the most impact on overall performance. Profiling tools identify hot paths by measuring where the program spends the most time.

The communication rules used to transfer data between a browser and a web server. HTTPS is the secure version - it encrypts the data in transit so no one in the middle can read or tamper with it. The padlock icon in your browser means HTTPS is active.

Key-value metadata attached to an HTTP request or response, providing context like content format, auth tokens, caching rules, and CORS policies. Headers travel with every request but are invisible to end users.

A three-digit code returned by a server indicating the result of an HTTP request. 2xx = success (200 OK, 201 Created), 3xx = redirect, 4xx = client error (400 Bad Request, 401 Unauthorized, 404 Not Found), 5xx = server error (500 Internal Server Error).

A workflow pattern that pauses automated execution so a person can review context, approve or reject an action, provide missing information, or correct the plan. Effective HITL gates happen before the consequential action, not only after it completes.

Using multiple rendering strategies within the same application - some pages rendered server-side, others statically generated, and some client-side. Next.js is built for this: each route can independently choose the right rendering model.

The process of making a server-rendered HTML page interactive by attaching JavaScript event listeners to it in the browser. The page appears visually immediately (from HTML), then 'hydrates' a moment later when JavaScript loads and makes it clickable.

An error in server-rendered React apps where the HTML generated on the server differs from what React renders on the client during hydration. Causes React to throw a warning and re-render the entire subtree. Common causes: rendering random values, dates, or browser-only APIs during SSR.

A configuration setting for a machine learning model or training process that is set before training begins, not learned from data. Examples: learning rate, batch size, number of layers, dropout rate. Hyperparameter tuning is finding the best combination.

Internationalization (i18n - 18 letters between 'i' and 'n') is designing software so it can be adapted for different languages and regions. Localization (l10n) is the actual adaptation for a specific locale - translating strings, formatting dates/currencies, and handling text direction. next-intl and react-i18next bring this to React apps.

A software application that provides a complete set of tools for writing code in one place: a text editor, debugger, file browser, and terminal. VS Code, Cursor, and JetBrains products are examples.

An operation that produces the same result no matter how many times it is applied. GET and DELETE HTTP methods are idempotent. Designing APIs to be idempotent prevents bugs when requests are accidentally retried.

Code written in the natural, conventional style of a language or framework - following community patterns, using built-in features as intended, and avoiding unnecessary complexity. Idiomatic code is readable to any experienced practitioner of that technology.

A function that is defined and called at the same time. Before ES modules, IIFEs were the standard way to create a private scope and avoid polluting the global namespace. Today you see them primarily in build output and legacy code.

Techniques that reduce image file size and serve the most appropriate format and resolution per device. Next.js's <Image> component automates this - converting to WebP, serving responsive sizes, and lazy-loading below-the-fold images.

The property of data that cannot be changed after it is created. Instead of modifying existing data, you create new copies with the changes. Immutable data is predictable, easier to reason about, and safe to share across threads.

A deployment model where servers are never modified in place - when an update is needed, new servers (or containers) are deployed and old ones are terminated. Eliminates configuration drift and makes rollbacks trivial: just redeploy the previous image.

Automatic type conversion performed by a language without explicit instruction. JavaScript is notorious for coercion: {} + [] === 0, '5' - 1 === 4. Can cause surprising bugs. TypeScript strict mode and === (strict equality) help prevent coercion pitfalls.

A database that stores all data in RAM rather than on disk, enabling extremely fast reads and writes. Often used for caching, session storage, and real-time leaderboards. Redis is the most popular. Data is volatile without persistence configuration.

A TypeScript syntax that describes objects with dynamic, unknown keys of a known type. Allows indexing an object with any key of a specified type while enforcing the value type.

A browser-based NoSQL database for persisting large amounts of structured data client-side. Unlike localStorage (string key-value only), IndexedDB supports complex objects, indexes, and transactions. Used by PWAs for offline data storage.

Information that reaches an AI model through an intermediary instead of a direct source-file read, such as editor-provided type information, diagnostics, or tool output.

How fast a deployed AI model generates outputs, typically measured in tokens per second or time-to-first-token (TTFT). Faster inference improves user experience in real-time applications. Influenced by model size, hardware, quantization, and batching strategies.

Managing and provisioning infrastructure (servers, networks, databases) through machine-readable configuration files rather than manual processes. Terraform, Pulumi, and AWS CloudFormation are IaC tools. Infrastructure becomes versionable and reproducible.

A mechanism in OOP where a class (subclass) acquires the properties and methods of another class (superclass). Enables code reuse and establishes an 'is-a' relationship. Overuse of deep inheritance hierarchies is considered an anti-pattern.

A SQL operation that returns only rows that have matching values in both joined tables. Rows without a match in either table are excluded. The most common join type - use LEFT JOIN when you want all rows from the left table even without matches.

Checking that data provided by users or external systems meets expected rules before processing or storing it. Prevents injection attacks, data corruption, and unexpected crashes. Always validate at the boundary; never trust external input.

A fine-tuning technique that trains a base language model on examples of human instructions paired with ideal responses, making it better at following directions rather than just predicting text. InstructGPT and Claude's helpfulness come from instruction tuning.

The accountable person or designated parent agent that receives parallel outputs, enforces integration order, resolves conflicts, runs combined verification, and controls publication. Human repository ownership still governs final acceptance and merge authority.

A test that verifies multiple components or services work correctly together. Broader than unit tests (which test in isolation), integration tests catch issues at the seams - like a service correctly calling a database or an API returning the right HTTP status.

In TypeScript, a contract that defines the shape an object must conform to - specifying which properties and methods it must have and their types. Like a job description - it says what skills are required, not who the person is.

The 'I' in SOLID: clients should not be forced to depend on interfaces they don't use. Large interfaces should be split into smaller, topic-specific ones. A class that only needs to read data shouldn't be forced to implement write methods.

The ability of a system to describe its own capabilities. GraphQL APIs support introspection queries that return the full schema - enabling code generation, tooling, and documentation. Similarly, runtime type introspection lets programs inspect their own types.

A design principle where the flow of control in a program is inverted - instead of your code calling a framework, the framework calls your code. You provide hooks/callbacks/handlers, and the framework decides when to invoke them. It's why frameworks (which control flow) differ fundamentally from libraries (which you call).

Code that can run both on the server and in the browser without modification. Next.js components can render server-side for SEO/performance then hydrate client-side. Requires avoiding browser-only or server-only APIs in shared modules.

A Next.js feature that lets you rebuild individual static pages in the background after deployment, without rebuilding the entire site. Pages are served instantly from cache and automatically updated at set intervals.

Repeating a block of code for each element in a sequence or until a condition is met. for loops, forEach, and for...of are iteration constructs. Functional methods like map and filter iterate internally without explicit loop syntax.

An object that lets you traverse through a collection element by element, exposing a .next() method that returns each value in sequence. JavaScript's for...of loop works on any iterable (arrays, strings, Maps) using the iterator protocol.

The contract an object must implement to be iterable in JavaScript: a Symbol.iterator method that returns an object with a next() method, which returns { value, done }. Arrays, strings, and Maps are built-in iterables.

Compiling code at runtime, just before it is executed, rather than ahead of time. JIT compilers analyze which code runs frequently and optimize it on the fly. V8 (Chrome's JS engine) uses JIT to make JavaScript fast.

A SQL operation that combines rows from two or more tables based on a related column. INNER JOIN returns matching rows. LEFT JOIN returns all rows from the left table. Understanding JOINs is essential for working with relational databases.

A markup language for annotating JavaScript source code with structured comments, and a tool for generating HTML documentation from them. // @param, @returns, and @type annotations can also give type hints to editors for JavaScript files that aren't using TypeScript.

A lightweight text format for storing and exchanging data between systems. It uses human-readable key-value pairs and is the most common format APIs use to send and receive data.

A compact, self-contained token used to securely transmit information between parties. Commonly used for authentication - after you log in, the server gives you a JWT that you send with future requests to prove who you are.

A long-lived token used to obtain new short-lived access tokens without requiring the user to re-authenticate. Access tokens expire quickly (15 minutes) for security; refresh tokens (7-30 days) let the app silently get new access tokens.

A naming convention where words are separated by hyphens. Used for CSS class names, file names, and URL slugs. Cannot be used for JavaScript variable names (hyphens are parsed as subtraction). my-component.tsx and .btn-primary are examples.

A fundamental data association concept where a unique key maps to a value. The basis of JavaScript objects, Python dictionaries, hash maps, and key-value databases. The key is used to look up the value in O(1) time.

A simple database that stores data as pairs: a unique key maps to a value. The value can be anything - a string, number, or JSON blob. Extremely fast for lookups. Redis and DynamoDB can operate as key-value stores.

The date after which an AI model has no knowledge of new events because its training data ended there. Asking a model with a 2024 cutoff about a 2025 election will get speculation or refusal. RAG and tool use let models access post-cutoff information.

An open-source platform that automates deploying, scaling, and managing containerized applications. It groups containers into logical units (pods), distributes them across machines, restarts failed containers, and scales them up/down based on load.

An anonymous, inline function typically used for short callbacks. In JavaScript, arrow functions (=>) are the modern lambda syntax. They are concise and do not bind their own 'this', making them ideal for callbacks.

The time it takes for a request to travel from the client to the server and back. Measured in milliseconds. High latency makes applications feel slow. CDNs, edge functions, and keeping servers close to users all reduce latency.

The compressed internal representation a neural network learns from training data. Similar concepts cluster together in latent space - 'king - man + woman ≈ queen'. Embeddings are vectors in latent space. Understanding it unlocks techniques like semantic search.

Delaying the loading of resources (images, components, scripts) until they are actually needed. Images below the fold only load when the user scrolls down to them, improving initial page load speed.

A scope system where a function's accessible variables are determined by its location in the source code, not where it's called from. Closures work because of lexical scope - inner functions can always see variables from their enclosing function.

A collection of reusable code you call from your own application to perform specific tasks. Unlike a framework (which controls flow), a library is a tool you reach for when needed. React is technically a library; Next.js is a framework.

A data structure where each element (node) contains a value and a pointer to the next node. Efficient inserts/deletes at any position without shifting elements (unlike arrays). Used in queues, implementing undo history, and memory allocators.

Automatically analyzing code for potential errors, style violations, and bad practices before it runs. Like spell-check but for code - a linter (e.g. ESLint) flags issues as you type.

A periodic health check in container orchestration (Kubernetes) that determines if a running container is still healthy. If a liveness probe fails, Kubernetes restarts the container. Readiness probes separately check if a container is ready to receive traffic.

An AI model trained on massive amounts of text data that can understand and generate human language. The technology behind ChatGPT, Claude, and Gemini. They predict the most likely next word/token based on patterns learned from training data.

An evaluation method that uses a language model to score another model or agent against a rubric. It is useful for semantic qualities that code cannot measure directly, but it should be calibrated against human judgment and allowed to abstain when evidence is insufficient.

A device or service that distributes incoming network traffic across multiple backend servers to prevent any single server from being overwhelmed. Improves availability and throughput. Common algorithms include round-robin and least-connections.

A file (like package-lock.json or pnpm-lock.yaml) that records the exact versions of all installed dependencies and their sub-dependencies. Ensures every developer and every CI run installs the exact same packages, preventing 'works on my machine' bugs.

A technique where the client sends a request and the server holds it open until new data is available (or a timeout), then responds. The client immediately sends another request. Simulates real-time updates without WebSockets. Less efficient but works everywhere HTTP does.

A cache eviction policy that removes the least recently accessed items when the cache is full. Keeps frequently accessed items in memory. Commonly implemented with a hash map + doubly linked list for O(1) get and put operations.

A subset of AI where systems learn patterns from data to make predictions or decisions without being explicitly programmed for each scenario. Training a model means feeding it labeled examples until it can generalize to new, unseen data.

A provider-operated runtime layer that coordinates model calls, context management, tools, sessions, and recovery for an agent. The provider can operate the harness while the adopting application remains responsible for user authority, business rules, data policy, and release decisions.

A configuration file that describes an application, package, or deployment to the system reading it. A Web App Manifest tells browsers how to install a PWA. A Kubernetes manifest describes how to deploy a container.

A programming model for processing large datasets across a distributed cluster. The 'map' step processes each record and emits key-value pairs. The 'reduce' step aggregates all values per key. Popularized by Google; powers Hadoop and big data processing.

A policy admitting only matching Model Context Protocol servers. Admission identifies permitted integrations, but does not by itself authorize every operation or data source exposed by them.

Caching the result of a function call so that if the same inputs are used again, the cached result is returned instead of recomputing. Speeds up expensive calculations that are called repeatedly.

When a program allocates memory for data but never frees it after the data is no longer needed. Over time this causes the application to use more and more memory until it slows down or crashes.

Combining the changes from one Git branch into another. The moment when code written in isolation (a feature branch) is incorporated into the main codebase.

When two branches have changed the same lines of the same file differently, and Git cannot automatically decide which version to keep. A developer must manually review and choose the correct version.

An asynchronous communication mechanism where producers write messages to a queue and consumers read and process them independently. Decouples systems, handles traffic spikes, and enables retry logic. RabbitMQ, SQS, and Kafka are popular choices.

An architectural approach extending microservices concepts to the frontend - splitting a large SPA into independently deployable frontend pieces, each owned by a different team. Reduces coordination costs for large organizations. Module Federation enables this in Webpack.

An architectural approach where an application is built as many small, independent services that each handle one specific function and communicate over APIs. The opposite is a monolith. Netflix uses hundreds of microservices.

Code that runs between a request coming in and a response going out. Think of it as a security checkpoint at an airport - every request passes through it before and/or after the main handler. Used for logging, auth, rate-limiting, etc.

A versioned script that alters a database schema - adding/removing columns, creating tables, or transforming data. Migrations are run in sequence and tracked so the schema history is reproducible. Roll forward with 'migrate up'; revert with 'migrate down'.

The bounded period between a deprecation announcement and the effective retirement or shutdown of the affected model or interface. Teams use it to inventory dependencies, test replacements, roll out safely, and eliminate old traffic.

Removing all unnecessary characters from code (whitespace, comments, long variable names) without changing functionality. Reduces file sizes significantly, making web pages load faster.

A way to compose behavior into a class or object from multiple sources without classical inheritance. Mixins 'mix in' methods from one object into another. In TypeScript, they're implemented by copying properties onto a class. Tailwind CSS uses the term for utility class composition.

A fake version of a dependency used in testing to isolate the unit under test. Mocks simulate the behavior of real objects like databases or APIs, letting you test logic without slow or expensive external calls.

A library that creates and manages fake implementations of dependencies for testing. Vitest and Jest include built-in mocking. Allows asserting that a function was called, how many times, and with what arguments.

A workload-specific set of observable requirements an AI model must satisfy, including task outcomes, response schemas, tool behavior, safety rules, latency, cost, and failure handling. It lets teams test replacement compatibility without assuming newer means equivalent.

A standardized documentation document for an AI model that describes its intended use cases, architecture, training data, performance benchmarks, limitations, and known biases. Introduced by Google researchers to promote model transparency and accountability. Most models published on Hugging Face include a model card.

An open standard created by Anthropic that lets AI models connect to external tools, databases, and APIs through a unified interface. MCP servers expose capabilities (tools, resources, prompts) that any MCP-compatible AI client can discover and use.

A provider notice that an AI model, alias, or API behavior is no longer recommended and is moving toward removal. A deprecated endpoint may continue working during its migration window, but new dependencies should not be added to it.

Training a smaller 'student' model to mimic the behavior of a larger, more capable 'teacher' model. Produces compact models that retain most of the teacher's capabilities at a fraction of the compute cost. Used to deploy powerful models on resource-constrained hardware.

Systematically assessing how well an AI model performs on a task using defined metrics and evaluation datasets. For LLMs, evals measure accuracy, safety, helpfulness, and instruction-following. Running evals before and after changes prevents regressions.

An explicit rule for selecting a substitute model when the preferred one is unavailable or fails. A safe policy limits eligible models, verifies policy and behavior compatibility, defines triggers, and prevents a retired identifier from remaining as a hidden fallback.

The provider-defined states an AI model passes through from release to removal, such as preview, active, legacy, deprecated, retired, or shut down. The names and guarantees vary by provider, so each state must be interpreted from current official documentation.

The point when an AI model or endpoint is no longer available on a provider surface. Requests to a retired or shut-down identifier fail, even if application code, prompts, or policies still reference it.

A Webpack 5 feature enabling multiple separately built JavaScript applications to dynamically share modules at runtime. Powers micro-frontend architectures where each team deploys independently but the browser assembles a unified app.

A design pattern from functional programming that wraps a value in a context and provides chainable operations (flatMap/bind) that handle that context automatically. Promises are monadic - they wrap an async value and chain .then() operations through it.

Dynamically modifying or extending existing code - a class, module, or function - at runtime without altering the original source. Common in testing (replacing a real API call with a fake) and quick hotfixes. Risky in production code: patches are invisible, can break on upgrades, and create subtle bugs.

An application where all parts (frontend, backend, database logic) are built and deployed as a single unit. Simpler to start with but can become hard to scale and maintain as the app grows.

Keeping all related projects (frontend, backend, shared libraries) in a single Git repository rather than separate repos. Makes it easier to share code and make coordinated changes across projects.

An AI model capable of processing and generating multiple types of data - text, images, audio, and video - within a single model. GPT-4o and Claude 3+ are multimodal LLMs that can analyze images and respond in text.

A large language model extended to handle multiple input and output modalities beyond text - including images, audio, video, and code. GPT-4o and Claude 3+ can analyze images, transcribe audio, and interpret charts alongside text.

Changing a value or data structure in place rather than creating a new copy. Mutation can cause subtle bugs in React (state must not be mutated directly) and functional code. Libraries like Immer help write mutation-style code that produces immutable results.

A browser API that watches for changes to the DOM and fires a callback when they occur. Used to react to dynamic content changes in third-party widgets, implement lazy loading, or observe layout shifts.

A design pattern that separates an application into three parts: Model (data and business logic), View (what the user sees), and Controller (handles input and connects Model to View). Used in frameworks like Rails, Django, and Laravel.

A container that holds a set of identifiers (variables, functions, classes), preventing naming collisions. In TypeScript, namespaces organize code. In CSS, naming conventions like BEM serve as pseudo-namespaces.

A visualization of sequential HTTP requests over time, showing when each request starts and finishes. A deep waterfall (many requests chained, each waiting for the previous) indicates performance problems. Parallelizing or combining requests eliminates waterfalls.

A computational model loosely inspired by the brain, consisting of layers of interconnected nodes (neurons) that transform inputs through learned weights and activation functions. The foundation of deep learning and modern AI.

A React framework built by Vercel that adds file-based routing, server-side rendering, static site generation, and API routes. The go-to choice for production React apps - handles the hard infrastructure decisions so you can focus on building features.

A high-performance open-source web server and reverse proxy. Nginx efficiently handles thousands of concurrent connections and is widely used to serve static files, proxy requests to application servers, and terminate SSL.

The branch of AI focused on enabling computers to understand, generate, and manipulate human language. NLP powers spell checkers, translation, sentiment analysis, and the language understanding in LLMs.

A random, single-use value used in cryptographic protocols and security headers to prevent replay attacks. A Content Security Policy (CSP) nonce allows specific inline scripts to run while blocking injected ones. Each request gets a new nonce.

A category of databases that store data in formats other than traditional rows and columns (tables). Examples include document stores (MongoDB), key-value stores (Redis), and graph databases. Often more flexible and scalable for certain use cases.

The default package manager for JavaScript and Node.js. It lets you install, share, and manage third-party code libraries (packages) that your project depends on. Over 2 million packages are available in the npm registry.

Special values representing the absence of a value. In JavaScript, 'null' is an intentional absence (you set it), while 'undefined' means a variable has been declared but not assigned. TypeScript's strict mode helps prevent null-related bugs.

A JavaScript and TypeScript operator that returns the right-hand value only when the left-hand value is null or undefined - not just any falsy value. Unlike the || fallback operator, ?? won't trigger on 0, false, or '' when those are valid values.

An open standard for authorization that lets users grant third-party applications access to their account without sharing their password. When you click 'Login with Google,' your app uses OAuth to ask Google for permission on your behalf.

A collection of key-value pairs representing a real-world entity. In JavaScript, nearly everything is an object. Objects group related data and behavior together. The fundamental building block of OOP.

A performance pattern that pre-allocates a set of reusable objects instead of creating and destroying them on demand. Used in game engines, database connection pools, and thread pools. Reduces garbage collection pressure.

The ability to understand a system's internal state by examining its external outputs. The three pillars are logs (what happened), metrics (how much/often), and traces (the path a request took through services). Essential for debugging production issues.

A pervasive logic bug where a loop iterates one too many or one too few times, or an index is off by one. Often stems from confusion about whether bounds are inclusive or exclusive (0-indexed vs 1-indexed). One of the most common bugs in software, cited in the classic quip: 'There are two hard problems in CS: naming things, cache invalidation, and off-by-one errors.'

Providing a single example to an AI model before asking it to perform a task. A middle ground between zero-shot (no examples) and few-shot (multiple examples). Even one example dramatically improves output consistency for structured tasks.

A programming paradigm that organizes code around 'objects' - bundles of data (properties) and behavior (methods) that represent real-world concepts. A 'Car' object might have 'color' and 'speed' properties and 'accelerate()' and 'brake()' methods.

Software whose source code is publicly available for anyone to view, use, modify, and distribute under a license. The foundation of modern software development - almost every project depends on open-source libraries. React, Linux, and VS Code are open source.

The 'O' in SOLID: software entities should be open for extension but closed for modification. Add new behavior by extending (creating new classes/functions) rather than changing existing, tested code. Prevents regressions when adding features.

A concurrency control strategy that assumes conflicts are rare. When updating, a version number is checked - if it's changed since you read it, another user updated first and your write is rejected. Avoids locking rows for the entire operation.

Updating the interface immediately assuming an operation will succeed, then rolling back if it fails. Makes apps feel snappy - when you like a post, the count increments instantly without waiting for the server to confirm.

A JavaScript and TypeScript operator that short-circuits and returns undefined instead of throwing when accessing a property on a null or undefined value. Eliminates verbose null checks when reading deeply nested properties.

Automatically managing, scaling, and coordinating multiple containers or services. Kubernetes is the leading orchestration platform - it ensures your containers are running, restarts them if they crash, and scales them up under high traffic.

A tool that lets you interact with a database using your programming language instead of writing raw SQL queries. Instead of 'SELECT * FROM users WHERE id = 1', you write User.findById(1). Prisma and Drizzle are popular JavaScript ORMs.

An evaluator that scores the observable end state produced by an agent instead of trusting its final message. Outcome graders commonly inspect files, database rows, API state, tests, or other artifacts that prove whether the task actually succeeded.

When an AI model learns the training data too specifically - memorizing noise and edge cases rather than generalizing patterns. An overfitted model performs well on training data but poorly on new data. Prevented with dropout, regularization, and cross-validation.

A tool that automates downloading, installing, updating, and removing software libraries your project depends on. npm, pnpm, and yarn are popular JavaScript package managers; pip is Python's.

The manifest file for a Node.js project. Records the project name, version, scripts (build, test, dev), dependencies, and devDependencies. The 'scripts' section is a task runner - 'npm run build' executes whatever script is registered under 'build'.

Splitting a large dataset into discrete pages to avoid sending thousands of records at once. The server returns a limited batch (e.g. 20 items) plus metadata like total count and a cursor for the next page. Essential for performance and UX.

An agile technique where two developers work together at one workstation - one 'driver' writes code while the 'navigator' reviews in real time, then they switch. Produces fewer bugs and spreads knowledge across the team.

A parameter is a variable in a function definition that acts as a placeholder. An argument is the actual value passed when calling the function. In function greet(name), 'name' is the parameter. Calling greet('Ryan') passes 'Ryan' as the argument.

A tool or code component that reads structured input (text, tokens) and converts it into a data structure like an AST (Abstract Syntax Tree). Compilers, linters, and MDX processors all begin with a parsing step.

A shorthand import path configured in tsconfig.json or bundler config that replaces long relative paths. '@/components/Button' is cleaner than '../../../../components/Button'. Next.js configures '@' as an alias for the src directory by default.

The actual data content carried in an HTTP request or response body. The 'payload' is what you care about - not the headers or status codes, but the JSON, HTML, or binary data being transferred.

A simulated cyberattack on a system, performed by ethical hackers, to discover vulnerabilities before real attackers do. Pen tests can be black-box (no prior knowledge), white-box (full knowledge), or grey-box (partial knowledge).

The ability of data to outlive the process that created it - surviving restarts, crashes, and shutdowns. In-memory data is not persistent. Databases, files, and localStorage provide persistence.

A concurrency control strategy that assumes conflicts are common. Locks a database row for the duration of a transaction, preventing other operations from reading or writing it. Prevents conflicts but reduces throughput; use when conflicts are genuinely likely.

An automated sequence of stages (install → lint → test → build → deploy) that runs every time code is pushed. Each stage must pass before the next begins. Pipelines are defined as code (GitHub Actions YAML, Jenkinsfile) and are the backbone of CI/CD. A broken pipeline blocks the team until fixed.

A piece of software that adds specific functionality to an existing program without changing the program itself. Plugins extend tools like Webpack, ESLint, Vite, or VS Code following a defined API, keeping the core program lean.

An audit description of which clients, modes, identities, and data paths actually enforce a policy. It distinguishes a configured rule from verified support on each interface.

Code that provides a feature that a browser does not natively support, by replicating it in JavaScript. Allows developers to use modern features while still supporting older browsers.

The ability of different objects to respond to the same method call in different ways. A 'Shape' class might have a draw() method, but Circle and Rectangle each implement it differently. Enables writing code that works on supertype references.

A numerical endpoint (0–65535) on a device where a specific service listens for network connections. Port 80 is HTTP, 443 is HTTPS, 3000 is a common dev server, 5432 is PostgreSQL. IP address gets you to the computer; port number gets you to the service.

A technique in transformer models that injects information about each token's position in the sequence, since self-attention is inherently order-agnostic. Without positional encoding, 'dog bites man' and 'man bites dog' would be indistinguishable.

A blameless analysis conducted after a production incident documenting what happened, the timeline, root causes, contributing factors, and action items to prevent recurrence. Blameless culture focuses on systemic improvements, not individual fault.

The initial, large-scale training phase where a foundation model learns general language understanding and world knowledge from a vast text corpus. Pre-training is expensive (millions of dollars) and done once. Fine-tuning and instruction tuning follow.

Proactively loading resources predicted to be needed soon, before they're actually requested. Next.js automatically prefetches linked pages when they appear in the viewport. Reduces perceived navigation time by pre-loading data in the background.

Generating HTML for a page at build time or request time so the browser receives ready-to-display markup instead of an empty shell that JavaScript must populate. SSG and SSR are both forms of prerendering. Improves First Contentful Paint and SEO because content is immediately in the HTML.

A column (or set of columns) in a database table that uniquely identifies each row. Every row must have a unique, non-null primary key. Typically an auto-incrementing integer or a UUID. The foundation of relational database design.

A modern TypeScript ORM providing type-safe database access with an auto-generated query builder. You define your schema in the Prisma schema file and get a fully typed client - if your query has a type error, TypeScript catches it at compile time.

A web design strategy starting with a baseline of core functionality accessible to all users, then layering enhanced experiences for those with better browsers or faster connections. The opposite of graceful degradation (which starts from full and degrades).

An object representing the eventual result (or failure) of an asynchronous operation. A Promise is either pending, fulfilled (with a value), or rejected (with an error). async/await is syntactic sugar built on top of Promises.

A provider-level optimization that stores the processed state of a repeated prompt prefix - such as a system prompt or a large reference document - so subsequent requests reusing that prefix skip recomputation. Dramatically reduces latency and API cost for applications that send the same large context with every request.

The practice of crafting and optimizing the text instructions you give to an AI model to get better, more accurate, or more useful outputs. Choosing the right wording, context, and format dramatically affects AI response quality.

A security attack that embeds hidden instructions in user input (or retrieved documents) to manipulate an AI model's behavior, bypassing its system prompt and safety guidelines. A critical concern for any application that feeds external data into an LLM.

JavaScript's native inheritance model where objects inherit directly from other objects via a 'prototype chain', rather than from classes. Every object has a hidden [[Prototype]] link; property lookups walk the chain until found or the chain ends at null. ES6 'class' syntax is syntactic sugar over prototypal inheritance.

An intermediary that sits between a client and server, forwarding requests on the client's behalf. Forward proxies hide clients; reverse proxies (like Nginx) hide servers and handle routing, SSL termination, and load balancing.

A messaging pattern where publishers emit events to a channel without knowing who will receive them, and subscribers that need those events register interest without knowing who publishes. Decouples producers and consumers completely.

A request for your code changes to be reviewed and merged into the main codebase. Before merging a branch, you open a PR so teammates can review your code, leave comments, and approve or request changes.

A web app enhanced with native app-like capabilities: installable on a home screen, working offline via service workers, and receiving push notifications. Built with standard web technologies but behaves like a native mobile app.

Reducing an AI model's numerical precision from 32-bit floats to 8-bit or 4-bit integers to dramatically decrease memory usage and increase inference speed with minimal accuracy loss. Enables running large models on consumer hardware.

Key-value pairs added to a URL after a ? to pass additional information to the server. Used for filtering, sorting, pagination, and search. Unlike route parameters (/users/:id), query params are optional and don't change the route structure.

A data structure following First-In-First-Out (FIFO) order - items are added to the back and removed from the front, like a checkout line. Used in BFS graph traversal, task scheduling, print queues, and message-passing systems.

A bug where the behavior of a system depends on the unpredictable timing of multiple operations. Two processes 'race' to access the same resource, and the result differs depending on which one finishes first.

A database-level concurrency bug where two simultaneous transactions read the same value, both decide to update based on it, and one overwrites the other's write. Classic example: two requests both read a balance of $100, both deduct $50, and both write $50 instead of $0.

A technique that improves AI responses by first searching a knowledge base for relevant documents, then feeding those documents into the AI's prompt as context. Reduces hallucinations by grounding responses in real information.

Restricting how many requests a client can make to a server within a given time window. Protects APIs from abuse, brute-force attacks, and accidental overload. Returns HTTP 429 (Too Many Requests) when the limit is exceeded.

An authorization model where permissions are granted to roles (Admin, Editor, Viewer), and users are assigned roles rather than individual permissions. Simplifies permission management at scale - update a role's permissions to affect all users with that role.

A React architecture where components render exclusively on the server and send HTML (not JavaScript) to the browser. RSCs have zero client-side bundle impact and can directly access databases, file systems, and secrets. Introduced in React 18 and integral to Next.js App Router - components are Server Components by default unless marked 'use client'.

A programming paradigm centered on data streams and the propagation of change. Instead of imperatively pulling values, reactive code subscribes to streams of values that push updates. RxJS and signals are reactive paradigms in the JavaScript ecosystem.

A copy of a primary database that receives a continuous stream of updates and handles read queries. Offloads read traffic from the primary, which handles writes. Essential for scaling read-heavy applications without upgrading hardware.

An LLM that generates an extended internal chain-of-thought before producing a final answer, allowing it to work through complex multi-step problems with greater accuracy. OpenAI's o1/o3 series and Claude's extended thinking mode are reasoning models. The trade-off is higher latency and cost compared to standard models.

Re-applying your branch's commits on top of a different base commit, effectively rewriting history to create a cleaner, linear timeline. An alternative to merging that results in a tidier commit history.

A technique where a function calls itself to solve a smaller instance of the same problem. Every recursive function needs a base case to stop. Classic uses include traversing trees, implementing quicksort, and computing factorials.

Systematically probing an AI system for failure modes, unsafe behaviors, and exploitable vulnerabilities by adversarially attacking it before public release. Red teams attempt jailbreaks, prompt injections, and edge-case inputs to surface weaknesses so they can be addressed in alignment training or guardrails.

An open-source in-memory data store used as a database, cache, and message broker. Blazing fast because all data lives in RAM. Commonly used for caching query results, storing sessions, rate limiting, and pub/sub messaging.

A higher-order function that iterates over a collection and accumulates all elements into a single value using a callback. array.reduce((acc, curr) => acc + curr, 0) sums all numbers. The most powerful and general of the functional array methods.

Restructuring existing code to improve its internal structure without changing its external behavior. Making it cleaner, faster, or easier to maintain - not adding features or fixing bugs.

A pattern syntax for matching, searching, and manipulating strings. Regex can validate email formats, extract data, replace text, and much more. Powerful but terse - complex patterns can be hard to read.

An evaluation suite that protects AI behavior the product already depends on. Its tasks should pass at a high reliability level, and confirmed production failures are commonly added after their fixes so the same behavior does not silently return.

A test that verifies a previously fixed bug has not reappeared (regressed). Often added immediately after fixing a bug to codify the expected behavior. Comprehensive regression suites prevent the common pattern of fixing one thing and breaking another.

A database that organizes data into tables (relations) with rows and columns, and allows tables to be linked via foreign keys. Data integrity is enforced with constraints. PostgreSQL, MySQL, and SQLite are popular relational databases.

A pre-release version of software believed to be production-ready, distributed for final testing. If no critical bugs are found, the RC becomes the official release. Software labeled 'v2.0.0-rc.1' is one step before the stable release.

A React pattern where a component receives a function as a prop and calls it to determine what to render. The component handles the logic; the caller controls the output. Like HOCs, render props share stateful logic between components and have mostly been superseded by hooks.

The sequence of steps a browser performs to convert HTML, CSS, and JavaScript into the pixels displayed on screen: parsing → DOM/CSSOM construction → layout → paint → compositing. Understanding this pipeline is key to optimizing rendering performance.

A design pattern that abstracts data access behind an interface, decoupling business logic from the specific storage mechanism. Swap a PostgreSQL repository for a MongoDB one without changing any business code.

A structured explanation for closing a review comment, such as Addressed, Won't fix, or Incorrect. The reason should point to the change, evidence, accepted risk, or false assumption that supports the decision.

Designing web interfaces to adapt their layout and content based on screen size and device type. Implemented with CSS media queries, flexible grids, and fluid images. A mobile-first approach designs for small screens first, then enhances for larger ones.

A set of conventions for building web APIs using standard HTTP methods: GET (read), POST (create), PUT (update), DELETE (remove). Most web APIs follow REST principles. Each URL represents a resource (e.g. /users/123).

Code that automatically re-attempts a failed operation a configurable number of times before giving up. Should be used with exponential backoff and only for idempotent operations. Prevents transient errors (network blips) from becoming user-visible failures.

A server that sits in front of backend servers, forwarding client requests to them. Hides internal server topology, handles SSL termination, load balancing, caching, and compression. Nginx and Cloudflare act as reverse proxies.

The evidence-backed decision process for accepting, rejecting, deferring, or requesting more proof for a review finding. Adjudication records why a comment was resolved instead of treating a closed thread as proof that the risk disappeared.

The explicit limit on repository files, instructions, external data, and tools available to an automated reviewer. A good boundary supplies enough evidence to judge the change while excluding secrets, unrelated data, mutating capabilities, and untrusted authority claims.

A setting or policy that controls how much reasoning and analysis an automated reviewer applies to a change. Teams should select the level from change complexity, sensitivity, and system impact rather than diff size alone.

A training technique where human raters evaluate model responses, and those ratings are used as a reward signal to further train the model to produce more preferred outputs. Central to making LLMs like ChatGPT and Claude helpful and safe.

Reverting a deployment or database change back to a previous working state after something breaks in production. Having a rollback plan is considered essential before any major release.

A systematic process for identifying the fundamental, underlying reason a problem occurred rather than just addressing symptoms. The '5 Whys' technique (asking 'why' repeatedly) is a common RCA method. Essential for preventing incidents from recurring.

A URL path that maps to a specific page, resource, or handler in an application. In Next.js, creating a file at app/dashboard/page.tsx automatically creates the /dashboard route. Route parameters (like /users/[id]) allow dynamic URLs.

A single entry in a database table, representing one instance of the entity the table models. A 'users' table has one row per user. Also called a 'record' or 'tuple'. SQL SELECT queries return sets of rows.

A protocol allowing a program to call a function in another process or machine as if it were a local function call, hiding the network transport. gRPC is the modern, widely-adopted RPC framework. Contrasted with REST, which is resource-centric.

The environment in which a program executes. Node.js is a JavaScript runtime for servers. The browser is the JavaScript runtime for web pages. The runtime provides APIs the language otherwise would not have.

An error that occurs while the program is executing, as opposed to a compile-time error caught before execution. TypeErrors ('Cannot read property of undefined'), RangeErrors, and network failures are all runtime errors. TypeScript reduces but cannot eliminate all runtime errors.

Random data added to a password before hashing to prevent attackers from using precomputed tables (rainbow tables) to crack passwords. Every user gets a unique salt, so identical passwords hash to different values.

An isolated, restricted environment for executing untrusted or experimental code safely, preventing it from affecting the host system or accessing sensitive resources. Browser iframes, virtual machines, and containers all provide sandboxing.

Cleaning user input to remove or escape potentially malicious content before processing or displaying it. Prevents XSS attacks by stripping script tags from user-submitted HTML, and SQL injection by escaping special characters.

A system's ability to handle increased load - more users, more data, or more requests - by adding resources. Vertical scaling adds more power to existing machines. Horizontal scaling adds more machines. Well-designed systems scale horizontally.

A formal definition of the structure, types, and constraints of data. A database schema defines tables and columns. A JSON schema validates API payloads. A Zod schema enforces TypeScript types at runtime. Schemas are contracts for data shape.

The region of code where a variable or function is accessible. JavaScript has global, function, and block scope (let/const). Understanding scope is essential to avoid bugs like accidentally overwriting a variable in an outer scope.

The uncontrolled expansion of a project's features and requirements beyond what was originally agreed. Adds time and complexity without corresponding planning. Prevents scope creep with clear requirements, change control processes, and iterative delivery.

A pre-packaged set of tools, libraries, and documentation that makes it easier to build applications for a specific platform or service. Stripe's SDK, for example, provides ready-made functions for processing payments.

Writing software according to security best practices to prevent vulnerabilities. Key practices: validate all inputs, use parameterized queries, never trust user data, keep dependencies updated, use HTTPS, and apply the principle of least privilege.

Using HTML elements that convey the meaning of their content, not just its appearance. <article>, <nav>, <header>, <main>, and <section> communicate structure to browsers, screen readers, and search engines. Improves accessibility and SEO.

A versioning scheme using three numbers: MAJOR.MINOR.PATCH (e.g. 2.4.1). MAJOR changes break backward compatibility. MINOR adds new features safely. PATCH fixes bugs. Helps developers know if an update is safe to apply.

Converting a data structure or object into a format that can be stored or transmitted (like JSON or binary), then reconstructed later. Deserialization is the reverse. Every API request/response involves serialization. JSON.stringify and JSON.parse are JavaScript's serializer/deserializer.

A Next.js feature (React Server Components) allowing you to define async server-side functions that can be called directly from client components, without manually building an API endpoint. Marked with 'use server'.

A cloud model where you write functions and the cloud provider handles all server management, scaling, and infrastructure. You pay only when your function runs. There are still servers - you just do not manage them.

A non-human identity used by applications and services to authenticate and be authorized for specific resources. Unlike user accounts, service accounts are created for machine-to-machine communication and should follow least-privilege principles.

An infrastructure layer for handling microservice-to-service communication, providing features like load balancing, service discovery, circuit breaking, mutual TLS, and distributed tracing - without changing application code. Istio and Linkerd are popular service meshes.

A JavaScript script that runs in the browser background, separate from the web page. Powers offline mode, background sync, and push notifications for PWAs. Acts as a programmable proxy between the browser and the network.

A server-side mechanism for tracking a user's authenticated state across multiple HTTP requests. After login, the server creates a session record and sends the session ID as a cookie. Subsequent requests include the cookie, identifying the user.

A structured update emitted during an agent session, such as a lifecycle change, generated item, tool activity, or terminal result. Consumers use ordered, correlated events to update durable application records and recover from interrupted streams.

A collection of beautifully designed, accessible, and customizable React components built on Radix UI primitives and styled with Tailwind CSS. Unlike a traditional component library, you copy components into your own project, owning the code completely.

A copy that duplicates only the top-level structure, sharing references to nested objects. Changing a nested property in the copy also changes the original. The spread operator {...obj} creates a shallow copy. Use structuredClone() for deep copies.

Horizontally partitioning data across multiple database instances (shards) to improve scalability. Each shard holds a subset of the data - e.g. users A-M on shard 1, N-Z on shard 2. Increases write throughput but complicates queries that span shards.

Any observable change a function makes outside its own scope - modifying global state, writing to a file, making API calls, logging to console. Pure functions have no side effects. React's useEffect hook is explicitly for managing side effects.

A reactive primitive for managing state popularized by SolidJS and spreading to other frameworks. A signal stores a value and automatically tracks which computations depend on it, re-running only those when the value changes - more efficient than React's re-rendering model.

A design pattern ensuring only one instance of a class exists throughout the application's lifetime, with a global access point. Used for database connections, configuration objects, or loggers. Can make testing difficult due to shared global state.

A formal commitment between a service provider and customer defining expected performance standards - uptime percentage, response time, and support response times - plus remedies (service credits) if the standards aren't met.

Low-quality, undifferentiated AI-generated content produced at volume without editorial judgment, curation, or genuine expertise. Characterized by confident-sounding text that is generic, shallow, or inaccurate. As the marginal cost of AI generation approaches zero, slop increasingly pollutes search results, social feeds, and inboxes.

Self-executing code stored on a blockchain that automatically runs when predefined conditions are met. Eliminates the need for intermediaries in agreements. Written in Solidity (Ethereum) or similar languages. Immutable once deployed.

A test that renders a component, saves the output as a reference 'snapshot', and compares future renders against it. If the output changes unexpectedly, the test fails. Quick way to detect unintended UI regressions.

Marking a database record as deleted (with a 'deleted_at' timestamp or 'is_deleted' flag) without physically removing it. Preserves data for auditing, compliance, and recovery. Requires all queries to filter out soft-deleted records.

Five principles of object-oriented design: Single Responsibility (one class, one job), Open/Closed (open for extension, closed for modification), Liskov Substitution, Interface Segregation, and Dependency Inversion. A guide to writing maintainable code.

A file that maps minified, bundled production code back to the original source code. When an error occurs in production, source maps let developer tools show you the original readable code location instead of minified gibberish.

A web app that loads a single HTML page and dynamically updates its content without full page reloads, creating a fast, app-like experience. Gmail and Figma are SPAs. Navigation feels instant because only data is fetched, not entire pages.

The ... syntax in JavaScript that expands an iterable (array, object) into individual elements. Used to merge arrays, clone objects, and pass variable arguments to functions. Foundational to immutable state updates in React.

A fixed-length development cycle (typically 1-2 weeks) in Agile/Scrum methodology. The team commits to a set of work items (user stories) at the start of the sprint and aims to deliver working software by the end.

The standard language for interacting with relational databases (tables with rows and columns). Used to query, insert, update, and delete data. PostgreSQL and MySQL are popular SQL databases.

A security attack where malicious SQL code is inserted into input fields to manipulate a database. Example: entering ' OR 1=1 as a username to bypass login. Prevented by using parameterized queries or ORMs that never concatenate user input into SQL strings.

A lightweight, serverless, file-based relational database embedded directly into applications. No separate server process required - the entire database is a single .db file. Perfect for development, mobile apps, edge deployments, and small-scale production.

A browser API and HTTP protocol for the server to push a stream of events to the client over a single long-lived HTTP connection. Unlike WebSockets (bidirectional), SSE is one-way: server to client only. Simpler to implement and works over standard HTTP/2. Widely used for streaming LLM responses token-by-token.

Generating all HTML pages at build time rather than on each request. Pages are pre-built and served instantly from a CDN. Very fast for content that does not change frequently, like a blog.

A cryptographic protocol for securely accessing and managing remote systems over an unsecured network. SSH replaces telnet and FTP with encrypted communication. Used daily by developers to access servers, deploy code, and manage infrastructure.

Generating the HTML for a page on the server for each request, before sending it to the browser. Results in faster first-page loads (the browser gets content immediately) and better SEO compared to client-side rendering.

A data structure following Last-In-First-Out (LIFO) order - items are pushed onto the top and popped from the top. Like a stack of plates. Used for undo history, expression parsing, DFS traversal, and - fundamentally - the call stack that tracks function invocations in every program.

A pre-production environment that mirrors production as closely as possible, used for final testing before releases. Running smoke tests on staging catches issues that slipped through dev/CI. 'Works in staging' is the last line of defense before prod.

Data that represents the current condition of a component or application - it can change over time in response to user actions or events. When state changes in React, the component re-renders. State is the engine of interactive UIs.

A model with a finite number of states and defined rules for transitioning between them based on events. Prevents illegal state transitions and makes complex UIs predictable. XState is a popular JavaScript state machine library.

Examining code without executing it to detect bugs, security vulnerabilities, style violations, and anti-patterns. Linters (ESLint), type checkers (TypeScript), and security scanners all perform static analysis. Catches issues before code runs.

A type system where variable types are verified at compile time rather than at runtime. TypeScript adds static typing to JavaScript. Catches type mismatches early, enables editor autocomplete, and serves as inline documentation.

An open-source tool for building UI components in isolation, outside the main application. You write 'stories' that render a component in different states (empty, loading, error, filled). Makes it easy to develop, document, and visually test components independently of the app.

A sequence of data elements made available over time rather than all at once. File reading, network connections, and video are streams. Node.js Streams and the WHATWG Streams API provide standard interfaces. LLM APIs stream tokens as they're generated.

A data type representing a sequence of characters. In JavaScript, strings are immutable primitives - operations like .toUpperCase() return a new string rather than modifying the original. Template literals and the String API provide rich manipulation capabilities.

Configuring an LLM to return responses in a specific data format like JSON, rather than free-form text. Enables reliable parsing and integration with code. OpenAI and Anthropic APIs support this via JSON mode or tool/function call responses.

A minimal, hardcoded implementation of a function or service used in testing. Unlike mocks (which verify interactions), stubs just return predetermined data. Used to stand in for database calls or external APIs in unit tests.

A SQL query nested inside another query, used to compute intermediate results. The outer query uses the subquery's result as a filter condition or a value. Correlated subqueries reference the outer query and execute once per row - often replaced by JOINs for performance.

An XML-based format for describing 2D vector graphics. Unlike raster images (PNG, JPG), SVGs scale to any size without losing quality. Used for logos, icons, charts, and illustrations on the web. Can be styled with CSS and animated with JavaScript.

An open-source framework for designing, documenting, and testing REST APIs. An OpenAPI spec file describes all endpoints, request/response shapes, and auth requirements in YAML or JSON. Swagger UI generates interactive documentation from the spec.

A HTTP caching strategy (and the React data-fetching library built on it) that immediately serves a cached (stale) response while simultaneously fetching a fresh update in the background. The user sees data instantly; it updates quietly when new data arrives. Named after the HTTP Cache-Control directive of the same name.

A unique, primitive JavaScript value guaranteed never to conflict with any other value, created with Symbol(). Used as object property keys that are invisible to for...in loops and JSON.stringify. Well-known symbols (Symbol.iterator, Symbol.toPrimitive) let you customize built-in language behaviors.

Artificially generated data used to train, fine-tune, or evaluate AI models. Produced by another AI, programmatic rules, or simulations to supplement scarce real-world data, avoid privacy issues, or create rare scenarios that don't occur naturally in the wild. The quality of synthetic data directly determines the quality of models trained on it.

A hidden instruction given to an AI at the start of a conversation that sets its persona, rules, and context. It defines how the AI should behave for every message that follows. You do not see it, but it strongly shapes every response.

A utility-first CSS framework where you style elements by applying small, single-purpose class names directly in HTML/JSX. Instead of writing custom CSS, you compose classes like 'flex', 'p-4', 'text-lg', 'bg-blue-500'. Paired with shadcn/ui for rapid UI development.

The property that lets a work packet proceed from stable inputs, own a distinct output, and be reviewed without waiting for another packet's unaccepted result. Hidden shared contracts or overlapping writes make tasks dependent even when they run in separate workspaces.

A tool that automates sequences of development tasks: building, testing, linting, compiling assets, and deploying. npm scripts (in package.json), Makefile, and Turborepo all serve as task runners. Orchestrates the build pipeline.

A reliable, connection-oriented network protocol that ensures data arrives in order and without errors. Establishes a connection with a three-way handshake (SYN-SYN/ACK-ACK). HTTP/HTTPS run on top of TCP. Slower but reliable vs. UDP (faster but no guarantees).

A development practice where you write the test for a feature before writing the code that makes it pass. Red (failing test) -> Green (passing code) -> Refactor. Forces you to think about requirements before implementation.

The accumulated cost of shortcuts, quick fixes, and poor decisions made during development. Like financial debt, it accrues 'interest' over time - the longer bad code exists, the harder and more expensive it becomes to fix.

Automated collection and transmission of performance data, error reports, and usage metrics from a running production system. Provides visibility into application health and user behavior. OpenTelemetry is the emerging standard for cross-platform telemetry collection.

The number of distinct values an observability attribute or metric label can produce. Unbounded values such as prompts, user IDs, URLs, or run IDs create high cardinality, which increases storage and query cost and can overwhelm a metrics backend.

A parameter controlling the randomness of an LLM's outputs. Temperature 0 makes responses deterministic (always chooses the most likely token). Higher values (0.7-1.0) increase creativity and variety. Use low temperature for factual tasks, higher for creative writing.

A JavaScript string type delimited by backticks (`) that supports embedded expressions with ${} and multi-line strings without escape characters. Replaced string concatenation in modern JavaScript.

A multidimensional array used to represent data in machine learning computations. A scalar is a 0-D tensor, a vector is 1-D, a matrix is 2-D. Neural networks pass tensors through layers of transformations. TensorFlow and PyTorch are named after tensors.

A text-based interface for running commands and interacting with the operating system. The shell (bash, zsh, PowerShell) interprets commands. Developers use the terminal for running builds, managing git, installing packages, and SSH.

The percentage of code lines, branches, or statements exercised by automated tests. 100% coverage doesn't guarantee quality, but low coverage indicates untested business logic. Tools like Istanbul/NYC generate coverage reports alongside test runs.

A fixed, known state used as a baseline for tests. Fixtures set up the context before a test runs - seeding a database with specific records, creating mock files, or pre-configuring objects - ensuring predictable, repeatable test conditions.

This is a test to see if the live updates are working

Limiting how often a function can run to a maximum of once per time interval. Unlike debounce (which waits for inactivity), throttle ensures a function fires at a steady rate. Used for scroll event handlers or resize listeners.

The amount of work a system can process in a given time period - requests per second, transactions per minute, or bytes per second. High throughput and low latency are both desirable but sometimes involve trade-offs in system design.

A measure of how an algorithm's execution time grows relative to input size, expressed in Big O notation. O(1) is constant, O(log n) is logarithmic, O(n) is linear, O(n²) is quadratic. Choosing the right algorithm matters enormously at scale.

A maximum wait time for an operation. If the operation doesn't complete within the timeout, it's abandoned and an error is returned. Essential for resilience - without timeouts, a slow downstream service can tie up all threads and cascade failure.

The cryptographic protocol that powers HTTPS, encrypting data sent between your browser and a web server so it cannot be intercepted or read by third parties. SSL is the older, deprecated predecessor to TLS.

The unit AI language models use to process text. A token is roughly 3-4 characters or about 0.75 words. 'Hello world' is about 2-3 tokens. Models have limits on total tokens per request (context window), and are often priced per token.

An authorization control that limits an access token to its intended resource or service. The receiving service validates the audience so a token issued for one API cannot be replayed against another.

The component that splits text into tokens before feeding it to an LLM. Different models use different tokenizers (BPE, WordPiece). The same text tokenized differently affects token count, pricing, and context window usage. Tiktoken is OpenAI's tokenizer library.

Metadata that describes expected tool behavior, such as whether a call is read-only, destructive, idempotent, or open to external systems. Annotations help a host choose controls, but they are hints and must not be trusted as enforcement on their own.

The set of tools exposed for an AI model to select. Availability is distinct from permission to execute a particular call: a visible tool can still require approval or be denied.

A trace span that captures one agent-triggered tool execution, including duration, tool identity, parent operation, terminal status, and error type. Arguments and results should be omitted or redacted by default because they may contain code, credentials, personal data, or customer content.

The identifiers and flags propagated between processes or services so spans created in different components belong to the same distributed trace. W3C Trace Context standardizes the traceparent and tracestate HTTP headers used for interoperable propagation.

Removing or transforming sensitive data before trace data leaves the application or trusted collector. Effective redaction covers prompts, model outputs, tool arguments, tool results, headers, baggage, errors, and diagnostic fields rather than relying on deletion after export.

The neural network architecture behind all modern LLMs, introduced in the 2017 'Attention Is All You Need' paper. Processes entire input sequences in parallel using self-attention mechanisms, which let each token attend to all other tokens.

A dependency of one of your dependencies - a package you don't import directly but rely on indirectly. npm and pnpm install the entire transitive dependency tree. Security scanners check transitive dependencies for known vulnerabilities.

Converting source code from one language (or version) into another. TypeScript is transpiled to JavaScript. Modern JavaScript is transpiled to older JavaScript for browser compatibility. Unlike compilation, the output is still human-readable code.

A hierarchical data structure where each node has a parent (except the root) and zero or more children. The DOM is a tree. File systems are trees. Binary search trees enable fast lookups. Graphs generalize trees by allowing cycles.

Visiting every node in a tree in a specific order. Depth-first search (DFS) dives deep before backtracking; breadth-first search (BFS) processes level by level. React's reconciler traverses the component tree; file system utilities traverse directory trees.

Removing unused code (dead code) from the final bundle during the build process. If you import a utility library but only use 2 of its 100 functions, tree-shaking ensures only those 2 functions are included in the output.

A branching strategy where all developers commit to a single main branch ('trunk') continuously, keeping it always in a deployable state. Short-lived feature branches (ideally under a day) are merged frequently. Reduces merge conflict pain and enables true continuous integration.

In JavaScript, every value is inherently truthy or falsy when evaluated in a boolean context. The six falsy values are: false, 0, '' (empty string), null, undefined, and NaN. Everything else - including empty arrays and objects - is truthy. Used in if conditions and logical operators.

A fixed-length, ordered array where each position has a known type. TypeScript tuples let you express that 'the first element is a string and the second is a number'. Unlike regular arrays (all same type, any length), tuples enforce both length and per-position types.

An authentication method requiring users to provide two distinct verification factors: something they know (password), something they have (phone/TOTP app), or something they are (biometric). Significantly harder to compromise than passwords alone.

A TypeScript declaration using the 'type' keyword to give a name to any type - primitives, unions, intersections, tuples, or objects. More flexible than interfaces (can express union types) but interfaces support declaration merging. In practice, use 'type' for everything except when you need the merging behavior.

JavaScript automatically converting a value from one type to another during an operation. Implicit coercion is silent and a common source of bugs: '5' + 3 yields '53' (string concatenation), but '5' - 3 yields 2 (numeric subtraction). Using === instead of == avoids coercion in comparisons.

A runtime check in TypeScript that narrows (refines) the type of a variable within a conditional block. Telling TypeScript 'at this point, this variable is definitely of this specific type'. Written with typeof, instanceof, or user-defined type guard functions.

A compiler's ability to automatically deduce the type of a variable from its value without you explicitly writing the type. In TypeScript, writing 'const x = 5' automatically infers that x is a number.

TypeScript's ability to refine a variable's type to a more specific subtype within a conditional block based on runtime checks. After an 'if (typeof x === "string")' check, TypeScript knows x is a string in that block. Eliminates the need for type casts.

A property of a programming language or codebase that prevents type errors at compile time rather than runtime. TypeScript adds type safety to JavaScript by catching mismatches (like passing a string where a number is expected) before the code runs.

A superset of JavaScript developed by Microsoft that adds optional static types, interfaces, enums, and compile-time type checking. TypeScript code compiles down to plain JavaScript. Catches type errors during development, before they become runtime bugs.

A standardized notation for visualizing software architecture and design. UML diagrams include class diagrams (relationships between classes), sequence diagrams (interactions over time), and state diagrams. Useful for documenting system design.

When an ML model is too simple to capture the underlying patterns in training data, resulting in poor accuracy on both training and new data. The opposite of overfitting. Fixed by using a more complex model, more features, or more training data.

A TypeScript type allowing a value to be one of several possible types, written with the | operator. Enables precise modeling of values that can vary: a function that accepts string | number, or an API response that is Success | Error.

A test that verifies a single, isolated piece of functionality - a function or a class method - in complete isolation from its dependencies. Fast to run, easy to pinpoint failures. The base of the testing pyramid.

In software, 'upstream' refers to the original project or environment a change originates from; 'downstream' refers to where it flows. In git, the remote is your upstream. In microservices, if Service A calls Service B, B is upstream to A.

The percentage of time a system is operational and accessible to users. '99.9% uptime' (three nines) means ~8.7 hours of downtime per year; '99.99%' (four nines) means ~52 minutes. SLAs (Service Level Agreements) formally commit to uptime targets.

The address used to access a specific resource on the internet. Anatomy: protocol (https://), domain (example.com), path (/users/42), query string (?tab=profile), fragment (#section). Every page, image, and API endpoint has a URL.

A React hook for running side effects in functional components - data fetching, subscriptions, timers, and DOM manipulation. Effect runs after render. The dependency array controls when it re-runs. Return a cleanup function to prevent memory leaks.

An informal, plain-language description of a software feature from the perspective of an end user. Format: 'As a [role], I want [goal] so that [benefit].' User stories keep development focused on user value rather than technical implementation details.

The most fundamental React hook, adding local state to a functional component. Returns a state value and a setter function. Calling the setter with a new value triggers a re-render with the updated state.

Built-in TypeScript types that transform other types. Partial<T> makes all properties optional. Required<T> makes all required. Readonly<T> prevents mutation. Pick<T, K> selects properties. Omit<T, K> excludes properties. Eliminates repetitive type boilerplate.

A 128-bit identifier designed to be unique across all systems and time without coordination. Used as database primary keys and IDs so records from different sources can be merged without collisions. Looks like: '550e8400-e29b-41d4-a716-446655440000'.

A formal, declarative definition of the rules data must satisfy - types, required fields, length limits, regex patterns. Zod and Yup let you define schemas in code and get both runtime validation and TypeScript types derived automatically.

A named container for storing a value that can be referenced and changed in code. In JavaScript, 'const' declares immutable binding, 'let' allows reassignment, and 'var' has function scope (avoid in modern code). Variable names should describe what they hold.

When a variable declared in an inner scope has the same name as one in an outer scope, 'shadowing' the outer variable within that scope. The inner variable takes precedence locally. Can cause confusing bugs when the shadowing is unintentional.

A system that records every change made to files over time, allowing you to recall specific versions, compare changes, and collaborate with others. Git is the most widely used VCS.

A database optimized for storing and searching embeddings (numerical representations of data). Enables semantic search - finding content by meaning rather than exact keywords. Pinecone, Weaviate, and pgvector are popular options.

Finding the most semantically similar items to a query by computing the distance between their vector embeddings. Unlike keyword search (exact matching), vector search understands meaning - 'dog' and 'puppy' are close in vector space. The backbone of RAG systems.

Log output that includes detailed information about every operation - useful for deep debugging but too noisy for production. Most logging frameworks support log levels (DEBUG, INFO, WARN, ERROR) so verbosity can be tuned per environment.

An informal term for a programming workflow where a developer describes what they want in natural language to an AI assistant and iterates on the generated output, often without writing code directly. Prioritizes rapid prototyping and flow over deep understanding of the generated implementation.

The visible area of a web page in the user's browser window. The viewport meta tag controls how mobile browsers scale pages. CSS viewport units (vw, vh) size elements relative to the viewport. Responsive design adapts layout to different viewport sizes.

A lightweight JavaScript representation of the real DOM kept in memory. When state changes, React computes the minimal diff between the old and new virtual DOM and applies only those changes to the real DOM - far more efficient than re-rendering everything.

Software that emulates a complete computer system, allowing multiple operating systems to run on a single physical host. VMs are heavier than containers (each has its own OS kernel) but provide stronger isolation. VMware, VirtualBox, and cloud VMs are examples.

A next-generation frontend build tool offering near-instant dev server startup and fast HMR by leveraging native ES modules. When building for production, Vite bundles with Rollup. Much faster than Webpack for most projects.

A fast JavaScript unit testing framework that reuses your Vite configuration, making setup nearly zero-config for Vite-based projects. Compatible with Jest's API (describe, it, expect) so most Jest tests migrate without changes. Near-instant test runs thanks to Vite's native ESM and esbuild.

A TypeScript type indicating a function returns no meaningful value (returns undefined). Distinct from 'never' (function never returns - it throws or loops forever) and 'undefined' (the absence of a value).

A binary instruction format that runs in the browser at near-native speed. Enables languages like C++, Rust, and Go to run on the web. Used for performance-critical apps like video editing, CAD tools, and games in the browser.

A sequential software development approach where each phase (requirements → design → implementation → testing → deployment) must fully complete before the next begins. Contrasted with Agile's iterative approach. Suitable for projects with well-defined, stable requirements.

A reference to an object that does not prevent the garbage collector from reclaiming it. JavaScript's WeakMap and WeakSet hold weak references - if an object has no other references, it can be garbage collected even if it's in a WeakMap.

A suite of browser APIs for creating reusable, encapsulated HTML elements that work in any framework. Consist of Custom Elements, Shadow DOM (style isolation), and HTML Templates. Let you build framework-agnostic UI widgets.

A browser API that lets JavaScript run in a background thread, completely separate from the main UI thread. Because the main thread handles rendering, heavy computation on it freezes the UI. Web Workers move that work off-screen so the page stays responsive.

A reverse API call - instead of your app polling a service for updates, the service calls your URL when an event occurs. GitHub can POST to your server on every commit. Stripe POSTs on every payment event. Webhooks are event-driven and efficient.

A communication protocol that provides a full-duplex, persistent connection between client and server. Unlike HTTP (request-response), WebSockets allow the server to push data to the client at any time. Used for chat apps, live dashboards, and multiplayer games.

Testing that examines the internal code structure, logic, and implementation. Testers need to understand the code. Contrasted with black-box testing (testing only external behavior). Unit tests are typically white-box; end-to-end tests are typically black-box.

A way to run CPU-intensive JavaScript tasks in a background thread without blocking the main event loop. Node.js Worker Threads and browser Web Workers provide true parallelism for heavy computation like image processing or cryptography.

An explicit assignment of writable files, packages, services, or contracts to one worker during parallel development. Isolation prevents direct file collisions; ownership also prevents independent branches from making incompatible semantic changes.

A logging technique used by databases where changes are written to a log file before being applied to the main storage. Enables crash recovery (replay the log), replication, and point-in-time restore. PostgreSQL's WAL is central to its reliability guarantees.

A security attack that injects malicious scripts into web pages viewed by other users. If an app renders user input as raw HTML, an attacker can inject <script> tags that steal session cookies or redirect users. Prevented by escaping output and using Content Security Policy.

A human-readable data serialization format commonly used for configuration files. More readable than JSON (no quotes required, supports comments). Used by Docker Compose, GitHub Actions, Kubernetes manifests, and many other DevOps tools.

A provider data-control mode in which eligible API content is not retained beyond the processing needed to serve the request. Eligibility is product- and endpoint-specific, so using a self-hosted compute environment does not automatically make a managed API workflow zero-retention.

A security model based on the principle 'never trust, always verify'. Every access request - whether from inside or outside the network - must be authenticated and authorized. Assumes breach is inevitable and limits the blast radius by enforcing least-privilege access.

Asking an AI to perform a task with no prior examples - just a direct instruction. It relies entirely on knowledge from training. Works well for common tasks but few-shot prompting often produces better results for specialized needs.

A TypeScript-first schema declaration and validation library. You define a schema once and get both runtime validation and static TypeScript types for free. Extremely popular for validating API inputs, form data, and environment variables.