Engineering Glossary

ACID is an acronym for the four properties that guarantee database transactions are processed reliably: Atomicity (all or nothing), Consistency (valid state to valid state), Isolation (concurrent transactions don't interfere), and Durability (committed data survives crashes).

AI code generation uses large language models (LLMs) to produce code from natural language descriptions, existing code context, or both. Tools like GitHub Copilot, Cursor, and Claude Code implement this.

AI pair programming uses AI tools (Copilot Chat, Claude, Cursor) as an interactive coding partner — asking it to explain code, suggest approaches, and generate implementations — while the human engineer retains judgment over what to accept.

AI testing uses AI tools to generate test cases, identify edge cases, review test coverage, and suggest testing strategies — augmenting human testing rather than replacing it.

Abstraction is the principle of hiding implementation complexity behind a simple interface, allowing users of your code to work at a higher level without understanding the underlying details.

Async/await is syntax for working with Promises that makes asynchronous code look and behave like synchronous code. An async function always returns a Promise; await pauses execution until the awaited Promise settles.

Backtracking is a systematic algorithm for solving constraint-satisfaction and combinatorial problems by building a solution incrementally, undoing choices that lead to invalid or suboptimal states, and trying alternatives.

Big O notation is a mathematical notation that describes how an algorithm's runtime or space requirements scale as the input size grows. It characterizes the worst-case growth rate, ignoring constants and lower-order terms.

Binary search is an algorithm that finds a target value in a sorted array in O(log n) time by repeatedly dividing the search space in half, eliminating half the remaining candidates at each step.

Breadth-First Search (BFS) is a graph traversal algorithm that explores all neighbors of a node before moving to their neighbors, visiting nodes level by level. It uses a queue and finds shortest paths in unweighted graphs.

Bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they're in the wrong order. Each pass 'bubbles' the largest unsorted element to its correct position.

CI/CD (Continuous Integration / Continuous Deployment) is a set of practices and automated pipelines that build, test, and deploy code changes automatically, reducing manual effort and catching bugs before they reach production.

CORS (Cross-Origin Resource Sharing) is a browser security mechanism that controls which origins (domain+protocol+port) can make HTTP requests to your server, preventing malicious websites from making authenticated requests on behalf of users.

CSS Flexbox (Flexible Box Layout) is a one-dimensional layout model that arranges items in a row or column, with powerful alignment and distribution controls for the space between and around items.

CSS Grid is a two-dimensional layout system that divides a container into rows and columns, letting you place items precisely in any cell or span across multiple cells, making complex page layouts straightforward.

Client-side rendering (CSR) builds the page UI entirely in the browser using JavaScript. The server sends a minimal HTML shell and a JavaScript bundle; the browser executes the JavaScript to fetch data and render the interface.

Code completion predicts and suggests the next tokens, expressions, or entire functions as you type. AI-powered completion (Copilot, Codeium, Tabnine) extends traditional autocomplete to suggest entire function bodies and code blocks.

Database sharding is a horizontal scaling technique that partitions a large database across multiple machines (shards), each holding a subset of data, enabling the database to handle more data and traffic than a single machine supports.

Depth-First Search (DFS) is a graph traversal algorithm that explores as far as possible along each branch before backtracking. It uses a stack (implicitly via recursion or explicitly) and visits O(V+E) time for a graph with V vertices and E edges.

Divide and conquer is an algorithm design paradigm that works by recursively breaking a problem into two or more smaller subproblems of the same type, solving each independently, and combining their solutions.

Docker is a platform for building, shipping, and running containerized applications. A Docker container packages an application with all its dependencies into a standardized unit that runs consistently across any environment.

Dynamic programming (DP) is an optimization technique that solves problems by breaking them into overlapping subproblems, solving each subproblem once, and storing the result to avoid redundant recomputation.

Encapsulation is the OOP principle of bundling data and the methods that operate on that data into a single unit (class), and restricting direct access to the internal state from outside code — exposing only a controlled public interface.

Eventual consistency is a consistency model where, after all updates stop, all replicas of a distributed system will eventually hold the same data — but reads may return stale data in the window between a write and full propagation.

Garbage collection (GC) is the automatic process of identifying and freeing memory occupied by objects that are no longer reachable from the program, preventing memory from being exhausted by unused allocations.

Git is a distributed version control system that tracks changes to files over time, allowing multiple developers to collaborate on code, review history, create parallel branches, and merge changes — all with the ability to revert to any previous state.

GitHub Copilot is an AI coding assistant that suggests code completions inline as you type in your editor, trained on billions of lines of public code and backed by OpenAI language models.

GraphQL is a query language and runtime for APIs where clients specify exactly what data they need in a single request, eliminating over-fetching and under-fetching problems common in REST APIs.

HTTP (Hypertext Transfer Protocol) is the application-layer protocol that governs how web browsers and servers exchange data. Every web request you make — loading a page, submitting a form, calling an API — uses HTTP.

HTTPS (HTTP Secure) is HTTP with TLS (Transport Layer Security) encryption. It encrypts data in transit between browser and server, preventing eavesdropping and tampering, and authenticates the server's identity via certificates.

Hallucination in code is when an AI generates plausible-looking but incorrect or fabricated code — inventing function names, library methods, or API endpoints that don't exist, or producing logically incorrect implementations with false confidence.

Hoisting is JavaScript's behavior of moving function and variable declarations to the top of their scope before code runs. Function declarations are fully hoisted (callable before definition); var declarations are hoisted but not initialized (return undefined before assignment); let/const are hoisted but not accessible (Temporal Dead Zone).

An operation is idempotent if performing it multiple times produces the same result as performing it once. Idempotency enables safe retries in distributed systems where network failures may cause duplicate requests.

Immutability means that once a value is created, it cannot be changed. Instead of modifying existing data, you create new data with the changes applied. This prevents a class of bugs caused by unexpected mutations.

Inheritance is an OOP mechanism where a child class automatically receives the properties and methods of its parent class, allowing code reuse and creating an 'is-a' relationship between types.

Memoization is an optimization technique where a function caches its return value for a given set of arguments, so subsequent calls with the same arguments return the cached result instead of recomputing it.

Merge sort is a divide-and-conquer sorting algorithm that recursively splits an array in half, sorts each half, and merges the sorted halves back together. It runs in O(n log n) time in all cases.

Microservices is an architectural style where an application is built as a collection of small, independent services — each responsible for a specific business capability, communicating via APIs, and deployable independently.

Middleware is a function that sits between receiving an HTTP request and sending a response, transforming requests, enforcing policies, or adding data to the request context. Multiple middleware functions form a pipeline.

NoSQL ('Not only SQL') refers to a category of databases that use non-relational data models — documents, key-value pairs, columns, or graphs — offering flexible schemas, horizontal scalability, and different consistency trade-offs than relational databases.

OAuth 2.0 is an authorization framework that allows users to grant third-party applications limited access to their accounts on another service — without sharing their passwords. It's the protocol behind 'Login with Google' and 'Continue with GitHub'.

Polymorphism (meaning 'many forms') is the ability of different types to respond to the same interface or method call in their own way, allowing code to work with objects of different types uniformly without knowing their specific type.

Prompt engineering is the practice of crafting inputs (prompts) to AI language models to elicit specific, reliable, and high-quality outputs — treating model inputs as a form of programming that is precise, structured, and testable.

Quick sort is a divide-and-conquer sorting algorithm that works by selecting a pivot element, partitioning the array into elements less than and greater than the pivot, and recursively sorting each partition. Average case is O(n log n); worst case is O(n²).

Rate limiting controls how many requests a client can make to an API within a given time window, protecting against abuse, DoS attacks, and resource exhaustion.

Recursion is a technique where a function solves a problem by calling itself with a smaller or simpler input, until it reaches a base case that can be solved directly without further self-calls.

Responsive design is the approach of building web interfaces that automatically adapt their layout and appearance to different screen sizes, from mobile phones to desktop monitors, using flexible layouts, media queries, and relative units.

SQL (Structured Query Language) is the standard language for interacting with relational databases. It's used to query data (SELECT), insert records (INSERT), update records (UPDATE), delete records (DELETE), and define schemas (CREATE TABLE).

SSH (Secure Shell) is a cryptographic network protocol for securely connecting to remote computers, enabling remote command execution, file transfer (SCP/SFTP), and encrypted tunneling over an unsecured network.

Scope is the region of code where a variable is accessible. JavaScript uses lexical (static) scoping: a variable's scope is determined by where it's declared in the source code, not where it's called from.

Server-side rendering (SSR) generates the full HTML for a page on the server before sending it to the browser, resulting in faster initial content display and better SEO than client-side rendering.

Space complexity measures how much additional memory an algorithm uses as a function of input size, expressed in Big O notation. It includes auxiliary space (extra memory beyond the input) and sometimes input storage.

Time complexity is a measure of how the number of operations an algorithm performs grows as a function of its input size, expressed using Big O notation to describe the worst-case growth rate.

Vibe coding is writing software by prompting an LLM, accepting what it generates, and shipping without reviewing or understanding the code — relying on intuition and iteration rather than engineering judgment.

A balanced binary tree is a binary tree where the height of the left and right subtrees of every node differs by at most one (or a small constant), ensuring the tree's height stays O(log n) and all operations remain efficient.

A binary tree is a tree data structure where each node has at most two children, called the left child and right child. It's the foundation for binary search trees, heaps, and many database index structures.

A CDN (Content Delivery Network) is a distributed network of servers that caches content at locations geographically close to users, reducing latency and offloading traffic from origin servers.

A cache is a fast, temporary storage layer that stores results of expensive operations (database queries, API calls, computations) so subsequent requests for the same data can be served faster without repeating the expensive work.

A callback is a function passed as an argument to another function, to be invoked later — either synchronously (like Array.map's callback) or asynchronously (like setTimeout's callback) — when a certain event or condition occurs.

A class is a blueprint for creating objects that share the same properties and methods. It defines the structure and behavior of a type of object; instances are individual objects created from that blueprint.

A closure is a function that 'closes over' its surrounding scope — retaining access to variables from its outer function even after that outer function has finished executing.

A container is a lightweight, isolated execution environment that packages an application with all its dependencies, sharing the host OS kernel. Containers are faster and more resource-efficient than virtual machines.

Cookies are small pieces of data (name-value pairs) stored by the browser and automatically sent to the server with every HTTP request to the matching domain, most commonly used for session management, authentication, and user preferences.

A database index is an auxiliary data structure (usually a B-tree) that allows the database to find rows matching a condition in O(log n) time instead of scanning every row (O(n)). Indexes speed up reads but slow down writes.

A database transaction is a sequence of SQL operations executed as a single atomic unit: either all operations commit successfully, or all are rolled back on failure, leaving the database in a consistent state.

A doubly linked list is a linked list where each node has two pointers: next (pointing to the next node) and prev (pointing to the previous node), enabling O(1) traversal and deletion in both directions.

A foreign key is a column in one table that references the primary key of another table, creating a relationship between them and enforcing referential integrity — ensuring that references always point to existing records.

A function is a named, reusable block of code that performs a specific task. It can accept inputs (parameters), execute logic, and return an output. Functions are the primary unit of code reuse and abstraction.

A graph is a data structure consisting of vertices (nodes) connected by edges. Unlike trees, graphs can have cycles, multiple paths between nodes, and disconnected components.

A greedy algorithm makes the locally optimal choice at each step — the decision that looks best right now — without considering future consequences. It's fast and simple, but only produces the globally optimal solution for problems with the greedy-choice property.

A hash table (also called a hash map or dictionary) stores key-value pairs and provides O(1) average-case lookups, insertions, and deletions by using a hash function to compute the storage location from the key.

A heap is a complete binary tree where each node satisfies the heap property: in a min-heap, every parent is smaller than its children; in a max-heap, every parent is larger. This structure enables O(1) access to the minimum (or maximum) element.

A JWT (JSON Web Token) is a compact, self-contained token consisting of three Base64-encoded parts (header, payload, signature) that allows a server to verify a token's authenticity without a database lookup.

A large language model (LLM) is a neural network trained on massive text datasets that generates text by predicting the most likely next tokens given preceding context. GPT-4, Claude, and Gemini are LLMs.

A linked list is a sequence of nodes where each node holds a value and a pointer (reference) to the next node. Unlike arrays, elements are not stored contiguously in memory.

A load balancer distributes incoming network traffic across multiple servers, preventing any single server from being overwhelmed, enabling horizontal scaling, and providing automatic failover when a server goes down.

A map is a key-value data structure (also called a dictionary or associative array) that stores pairs of keys and values, providing O(1) average-case lookup, insertion, and deletion by key.

A message queue is an asynchronous communication buffer where producers write messages and consumers process them independently, decoupling the two systems and enabling them to operate at different speeds and fail independently.

A monolith is an application where all components (UI, business logic, data access) run in a single process and are deployed as one unit. Most successful applications start as well-structured monoliths.

A primary key is a column (or set of columns) that uniquely identifies each row in a database table. It must be unique across all rows, cannot be null, and is automatically indexed. It's the reference point for foreign keys in other tables.

A priority queue is a data structure that always returns the element with the highest priority first (or lowest, in a min-priority queue), regardless of the order elements were inserted. It's typically implemented using a heap.

A Progressive Web App (PWA) is a web application that uses modern browser APIs — primarily service workers and a web app manifest — to deliver native-app-like features including offline functionality, push notifications, and home screen installation.

A Promise is an object representing the eventual completion or failure of an asynchronous operation. It's in one of three states: pending (operation in progress), fulfilled (completed successfully), or rejected (failed).

In JavaScript, every object has a prototype — another object from which it inherits properties and methods. The prototype chain is the mechanism behind JavaScript's inheritance: property lookups walk up the chain until found or reaching null.

A queue is a First-In, First-Out (FIFO) data structure: items are added at the back (enqueue) and removed from the front (dequeue), like a line at a coffee shop.

A REST API (Representational State Transfer API) is an architectural style for building web APIs using HTTP where resources are identified by URLs, and standard HTTP methods (GET, POST, PUT, DELETE) define operations on those resources.

A relational database stores data in tables (rows and columns) with defined relationships between tables, enforced by primary keys and foreign keys. It uses SQL for queries and guarantees ACID properties for data integrity.

A SQL JOIN combines rows from two or more tables based on a related column (usually a foreign key). The type of JOIN determines which rows are included when no match exists: INNER (only matches), LEFT (all left rows + matches), RIGHT, or FULL OUTER.

A session is a server-side store of user-specific data (login state, preferences, cart contents) tied to an identifier stored in a cookie. Sessions maintain state across multiple stateless HTTP requests.

A set is an unordered collection of unique values, backed by a hash table. It provides O(1) average-case add, delete, and has (membership test) operations.

A Single Page Application (SPA) loads a single HTML page and dynamically updates content using JavaScript as users navigate, avoiding full page reloads. React, Angular, and Vue apps are typically SPAs.

A stack is a Last-In, First-Out (LIFO) data structure: you can only add elements to the top and remove elements from the top. Think of it like a stack of plates.

In LLMs, a token is the smallest unit of text the model processes — roughly 0.75 words or 3-4 characters in English. LLM pricing, context window limits, and generation speed are all measured in tokens.

A trie (pronounced 'try') is a tree data structure optimized for storing and searching strings, where each node represents a single character. It enables O(m) search, insertion, and prefix matching where m is the string length.

A type system is a set of rules that assigns types to values and expressions, and uses those types to detect potential errors. Static type systems check types at compile time (TypeScript, Java); dynamic type systems check at runtime (JavaScript, Python).

A variable is a named container for storing a value in a program. It associates a human-readable name with a location in memory, allowing you to store, retrieve, and update data throughout your code.

A virtual machine (VM) is a software emulation of a physical computer that runs a complete operating system in isolation, using a hypervisor to share physical hardware resources with other VMs on the same host.

A web server is software (and the hardware it runs on) that accepts HTTP requests from clients and returns HTTP responses — serving static files, routing requests to application servers, or handling both.

A WebSocket is a persistent, full-duplex communication channel between a browser and server over a single TCP connection, enabling real-time bidirectional messaging without the overhead of repeated HTTP requests.

An API (Application Programming Interface) is a defined contract specifying how software components communicate — what requests are valid, what data format to use, and what responses to expect — without needing to know the implementation details.

An adjacency list is a graph representation where each vertex stores a list of its neighboring vertices. It's the most space-efficient way to represent sparse graphs and is the standard input format for most graph algorithms.

An array is an ordered collection of elements accessed by a numeric index, stored in contiguous memory locations. It's the most fundamental data structure in programming.

An environment variable is a named value stored outside your source code in the process environment, used to configure application behavior per deployment environment without changing code.

An interface is a contract that defines the shape of an object (its properties and method signatures) without specifying an implementation. Any object or class that satisfies the interface can be used wherever that interface is expected.

An ORM (Object-Relational Mapper) maps database tables to classes and rows to objects, providing a programmatic interface to query and manipulate data using your programming language instead of raw SQL.

An object is a collection of key-value pairs (properties) that represent a real-world entity or concept. In JavaScript, objects can hold any values as properties — including functions (methods) — and are the most fundamental data structure.

nginx (pronounced 'engine-x') is a high-performance open-source web server, reverse proxy, and load balancer widely used as the front door to production web applications.

The CAP theorem states a distributed data store can guarantee at most two of three properties: Consistency (all reads return the most recent write), Availability (all requests receive a response), and Partition tolerance (the system operates despite network partitions).

The DOM (Document Object Model) is the browser's in-memory tree representation of an HTML page. JavaScript can read, modify, add, and delete nodes in this tree to dynamically update the page without a full reload.

The event loop is the mechanism that allows JavaScript (a single-threaded language) to perform non-blocking asynchronous operations by managing the call stack, task queue, and microtask queue to execute code, collect events, and run queued tasks.