Tech Glossary

Abstract Base Class

ABC — cannot be instantiated, only subclassed. Defines interface.

Abstract Class

A class that cannot be instantiated directly, only subclassed. Defines a contract with abstract methods that subclasses must implement. Common in Java, C#, and Python.

Abstract Factory

Creational pattern for creating families of related objects without specifying concrete classes.

Abstract Syntax

The logical structure of code independent of concrete syntax. ASTs represent abstract syntax.

Abstraction

The principle of hiding complexity and exposing only what's necessary. Classes, interfaces, and APIs are forms of abstraction that simplify development.

Access Modifier

Keywords controlling visibility of class members. Public (anywhere), private (same class), protected (subclass). TypeScript, Java, and C# enforce access modifiers.

Accessor

A getter method returning the value of a private property. Part of encapsulation in OOP languages.

Accessor Method

Getter returning private field value. Encapsulation mechanism.

Accumulator

A variable collecting results through iteration. reduce() uses accumulator pattern.

ACL Pattern

Access Control List pattern — permissions attached to objects specifying allowed operations per user.

Active Record

ORM pattern where objects wrap database rows. Rails ActiveRecord. Combines data and behavior.

Actor Model

Concurrency model where actors communicate via messages with no shared state. Used in Erlang and Akka.

Adapter

Converts one interface to another. Wraps incompatible class to work with existing code.

Adapter Pattern

A design pattern wrapping an incompatible interface to make it compatible. Converts one interface into another that clients expect. Common when integrating third-party libraries.

Address Space

Range of memory addresses accessible to a process. Virtual address space isolated per process.

Address Space Layout Randomization

ASLR memory security technique randomizing locations.

Affine Type

Type used at most once. Rust ownership is affine. Enables memory safety without GC.

Agile

Iterative software development methodology valuing individuals, working software, collaboration, and responding to change. Scrum and Kanban are Agile frameworks.

Agile Manifesto

2001 principles: individuals, working software, collaboration, change.

Ahead-of-Time

AOT compilation before execution. Go, Rust compile AOT. Faster startup than JIT.

Ahead-of-Time Compilation

Compiling before execution. Faster startup than JIT.

Algebraic Data Type

Types composed via sum (union) and product (tuple). Rust enums and Haskell data types. Enables pattern matching.

Algorithm

A finite sequence of instructions to solve a problem. The foundation of all computing, from sorting data to content recommendations.

Alias

Alternative name for a type, command, or resource. TypeScript type alias, bash alias.

Alignment

Memory alignment requirements for data types. Affects performance and correctness on hardware.

Allocator

Component managing memory allocation. malloc in C, jemalloc, mimalloc. Custom allocators for perf.

Alpha Testing

Internal testing before beta release. Found by developers and QA team.

Ambient Declaration

TypeScript declare for existing JS code. Provides types without implementation.

Amortized Analysis

Averaging operation cost over a sequence. Dynamic array append is O(1) amortized despite occasional O(n) resize.

AMQP

Advanced Message Queuing Protocol. RabbitMQ implements it.

Anagram

Words with same letters rearranged. Classic interview problem.

Annotation

Metadata attached to code elements. Java @Override, Python decorators, TypeScript decorators. Processed by compilers, frameworks, or runtime for behavior modification.

Anonymous Function

A function without a name, defined inline. Arrow functions (() => {}) in JS, lambdas in Python. Used for callbacks, event handlers, and short-lived operations.

Anti-Corruption Layer

DDD pattern isolating domain from external systems. Translates between models.

Anti-Pattern

A common but counterproductive programming practice. God class, spaghetti code, and premature optimization are anti-patterns. Recognizing them is key to writing better code.

AOP

Aspect-Oriented Programming — separating cross-cutting concerns (logging, caching) from business logic.

API

Application Programming Interface — a set of rules enabling communication between different software. REST and GraphQL APIs are the most common on the modern web.

API Client

Code library for consuming an API. Auto-generated from OpenAPI specs.

API Contract

Agreement on API interface: endpoints, types, behaviors. OpenAPI specification documents it.

API Rate Limit

Maximum API calls per time period. 429 status when exceeded. Token bucket algorithm.

API Version

Managing API changes. /v1/, /v2/. Semantic versioning for APIs.

APM

Application Performance Monitoring — tracking speed, errors, and dependencies in production. New Relic, Datadog.

Application Binary Interface

ABI defining binary interaction between components.

Application Layer

Highest network layer handling protocols. HTTP, FTP, SMTP, DNS.

Application Server

Server hosting application logic. Tomcat, Gunicorn, Puma. Between web server and DB.

Application State

Current data values of running application.

Arch Decision Record

ADR documenting architecture decisions. Context, decision, consequences.

Argument

A value passed to a function call. Different from parameter which is the variable in the function definition.

Argument Parsing

Processing command-line arguments. argparse (Python), commander (Node), clap (Rust).

Argument Unpacking

Expanding collection into function arguments.

Arithmetic Overflow

Calculation exceeding type maximum. Wraps around or throws. Security vulnerability.

Array

An ordered collection of elements accessed by index. Fixed-size in C/Java, dynamic in JavaScript/Python. O(1) access by index, O(n) search. The most basic data structure.

Array Buffer

Fixed-length binary data buffer in JavaScript. Foundation for typed arrays and WebGL data processing.

Array Destructuring

Extracting array elements to variables. const [a, b] = [1, 2]. Pattern matching.

Aspect

Cross-cutting concern in AOP. Logging, caching, auth applied across modules.

Aspect Ratio (Code)

Width to height ratio. 16:9, 4:3.

Assembler

Translates assembly language to machine code.

Assembly Language

Low-level language using mnemonics for CPU instructions. Architecture-specific. Used in kernels and drivers.

Assert

Statement verifying condition. assert(x > 0). Fails loudly. Testing and runtime checks.

Assertion

A statement verifying a condition is true during execution. Used in tests (expect/assert) and runtime checks. Fails loudly when assumptions are violated.

Assertion Library

Testing assertions. expect(x).toBe(5). Chai, Jest.

Assignment

Storing value in variable. let x = 5. Destructuring assignment. Compound: x += 5.

AST

Abstract Syntax Tree — a tree representation of source code structure. Compilers, linters, and formatters parse code into ASTs. Babel and ESLint manipulate ASTs.

Async Generator

A generator yielding Promises. async function* in JavaScript. Perfect for paginated APIs and streaming.

Async Iterator

An iterator that yields values asynchronously using for-await-of in JavaScript. Useful for streaming data, paginated APIs, and reading files line by line.

Async Queue

A structure processing tasks sequentially with async operations. Prevents resource overwhelming.

Async/Await

Syntax for asynchronous code looking synchronous. await pauses until promise resolves.

Asynchronous

Operations that don't block execution while waiting for results. async/await in JavaScript, Promises, and event loops enable efficient async code.

Atomic Design

Brad Frost's design methodology: atoms → molecules → organisms → templates → pages. Builds complex interfaces from simple components.

Atomic Operation

An operation that completes entirely or not at all, with no intermediate state visible. Database transactions and concurrent programming rely on atomicity.

Atomic Type

Type with guaranteed atomic read/write. AtomicInteger, AtomicBool. Lock-free concurrency.

Autoboxing

Automatic primitive to wrapper conversion. Java int to Integer.

Autoload

Loading modules on first use. PHP autoloading, Ruby autoload. Reduces startup time.

Automatic Memory Management

Runtime handling allocation and deallocation. GC.

Availability

System accessible when needed. 99.99% = 52 min downtime/year.

AVL Tree

Self-balancing BST where subtree heights differ by at most 1. O(log n) operations guaranteed.

Awk

Text-processing language for extracting and transforming data in terminals. Powerful for log analysis.

Backend

The server-side part of software: business logic, database, authentication. Common languages: Node.js, Python, Go, Rust.

Backend as a Service

A platform providing ready-made backend: auth, database, storage, functions. Supabase, Firebase, and Appwrite eliminate building backend from scratch.

Backend for Frontend

BFF pattern — custom backend per frontend type.

Backoff Strategy

Retry with increasing delays: 1s, 2s, 4s. Exponential backoff with jitter prevents thundering herd.

Backpressure

A flow control mechanism where consumers signal producers to slow down. Prevents memory overflow in streams. Node.js streams and Kafka implement backpressure.

Backtracking

Algorithm trying solutions, undoing on failure. Regex engine, sudoku solver.

Backward Compatibility

New version working with old data and interfaces.

Badge

Visual indicator showing status or count. Notification badges, CI status badges.

Bag

Unordered collection allowing duplicates. Multiset.

Bare Metal Programming

Programming directly on hardware without OS. Embedded systems, microcontrollers.

Base Case

The condition stopping recursion. Without it, recursion causes stack overflow.

Base Class

Class that other classes inherit from. Also called superclass or parent class.

Bash Script

Shell script automating system tasks. #!/bin/bash shebang. chmod +x to make executable.

Batch

Processing multiple items together. Batch inserts, batch API calls. More efficient.

Behavioral Pattern

Design patterns for object interaction. Observer, strategy, command, iterator.

Benchmark (Code)

Measuring code performance: execution time, memory, throughput. Vitest bench, pytest-benchmark.

Benchmark (Performance)

Standardized test measuring performance.

Benchmark Suite

Collection of benchmarks measuring different aspects of performance.

Best Practice

Recommended approach based on experience. Code reviews, testing, documentation.

Beta Testing

External testing before GA. Real users find issues. Public or closed beta.

BFS

Breadth-First Search — a graph/tree traversal exploring all neighbors before going deeper. Uses a queue. Finds shortest path in unweighted graphs. Used in social network analysis.

Big Endian

Most significant byte first in memory. Network byte order.

Big O Notation

Mathematical notation describing algorithm complexity as a function of input size. O(1) is constant, O(n) is linear, O(n²) is quadratic.

Binary

Base-2 number system. 0 and 1. Foundation of computing. 8 bits = 1 byte.

Binary Protocol

Communication using binary format. gRPC, MessagePack. Smaller and faster than text.

Binary Search

An efficient algorithm finding elements in sorted arrays. Divides search space in half each step. O(log n) time complexity. Much faster than linear search for large datasets.

Binary Tree

A tree where each node has at most two children. BST (Binary Search Tree) enables O(log n) search. Heaps, AVL trees, and red-black trees are variants.

Binding

Associating name with value or reference. Variable binding, this binding, data binding.

Binding (Code)

Associating name with value. Variable, this, event binding.

Bit

Smallest data unit. 0 or 1. 8 bits = byte. Foundation of all digital data.

Bit Field

Data structure allocating specific bits to fields. Compact storage for flags in protocols and hardware.

Bit Manipulation

Operating directly on binary representations. Checking flags, setting permissions, and optimizing algorithms. Bitwise AND, OR, XOR, and shifts. Common in embedded and systems programming.

Bit Masking

Using bitwise operations to extract or set specific bits. Permission flags.

Bitmask

Integer using individual bits as boolean flags.

Bitwise Operation

Operations on individual bits: AND (&), OR (|), XOR (^), NOT (~), shifts (<<, >>). Used in permissions, flags, cryptography, and performance optimization.

Black Box Testing

Testing without knowledge of internal implementation. Input/output only.

Block

A group of statements. Delimited by {} in most languages. Creates scope for let/const.

Block Chain (Data)

Linked list of cryptographically signed data blocks.

Blockchain (Code)

Linked list of cryptographically signed blocks. Immutable append-only data structure.

Blocking I/O

I/O operations that halt execution until complete. A thread waits idle during disk reads or network calls. Non-blocking I/O (async) is preferred for scalable servers.

Bloom Filter

Probabilistic set membership test. May say yes incorrectly, never no. Space efficient.

Blue-Green Deployment

Two identical environments. Deploy to inactive, switch. Instant rollback.

Boilerplate

Repetitive code needed to set up a project. Create React App, create-next-app, and templates reduce boilerplate at the start of projects.

Boolean

Data type with true/false values. Foundation of logic and conditions. Named after George Boole.

Boolean Expression

Expression evaluating to true or false.

Boolean Logic

AND, OR, NOT operations. Foundation of computing. Circuit design and conditionals.

Bootstrapping

Starting a system using a simpler version of itself. Compiler bootstrapping.

Borrow Checker

Rust compile-time system enforcing ownership rules. Prevents data races and dangling refs.

Bottleneck

The slowest component limiting system performance. Profiling identifies bottlenecks to optimize.

Bottom-Up

Building complex from simple components. Dynamic programming.

Boundary Testing

Testing at input edges: min, max, zero, empty, null. Catches off-by-one errors.

Bounded Context

DDD concept defining clear boundaries for a domain model. Each context has own language.

Branch

An independent line of development in Git. Allows working on features without affecting main code. Feature branches, release branches, hotfix branches.

Branch (Code)

Code path chosen by condition. if/else branches.

Branch Prediction

CPU guessing next instruction path. Misprediction costs cycles. Affects performance.

Breadth-First Search

Level-by-level graph traversal using queue.

Breakpoint (Debug)

Marker pausing debugger. Set in IDE. Inspect variables and step through code.

Bridge (Pattern)

Decoupling abstraction from implementation.

Bridge Pattern

Decoupling abstraction from implementation so both vary independently. Separates what from how.

Broadcast (Code)

Sending message to all listeners simultaneously. Events, pub/sub.

Broker

Intermediary managing communication. Message broker, service broker.

Brownfield Project

Building on existing code or legacy systems. Opposite of greenfield. Most real-world projects.

Browser Automation

Controlling browser programmatically. Playwright, Puppeteer.

Brute Force Algorithm

Trying all possibilities. Simple but slow. O(n!) for permutations.

Bubble Sort

Simple O(n²) sorting. Compare adjacent, swap. Educational but never use in production.

Buffer

A temporary memory area holding data during transfer between systems. Node.js Buffer handles binary data. Ring buffers and double buffering are common patterns.

Buffer Underrun

Reading buffer faster than filled. Audio skips, data gaps.

Bug

An error or defect in code causing unexpected behavior. The term originated in 1947 when a moth was found in a relay of the Harvard Mark II computer.

Bug Report

Document describing a defect: steps to reproduce, expected vs actual behavior, environment info.

Build Artifact

Output of build process: binaries, Docker images, bundles. Stored in registries, versioned, immutable.

Build Automation

Automated compilation and packaging. CI/CD builds.

Build Number

Incrementing identifier for each build. Version tracking.

Build System

Tool automating compilation, testing, and packaging. Make, Gradle, Bazel, and Turborepo. Incremental builds only recompile changed files for speed.

Builder

Creational pattern constructing complex objects step by step. Fluent API.

Builder Pattern

A design pattern constructing complex objects step by step. Separates construction from representation. Fluent API enables chaining: new QueryBuilder().select().where().build().

Built-in Type

Language-provided type. int, string, bool, float.

Bulk Insert

Inserting many records at once. Much faster than individual.

Bundle Size

Total JavaScript sent to browser. Smaller is faster.

Bundler

Tool combining modules into single output. webpack, Rollup, esbuild, Vite.

Burst

Temporary spike in activity. Burst capacity, burst writes.

Bus Factor

Number of team members whose absence would stall a project. Documentation increases bus factor.

Bytecode

Intermediate code between source and machine code. JVM bytecode (Java), WASM, and Python .pyc files. Portable across platforms, interpreted or JIT-compiled.

C Language

Foundational systems language (1972). Manual memory, pointers. Linux kernel, Git, Redis written in C.

C++

Extension of C with OOP, templates, RAII. Systems programming. Unreal Engine, Chrome.

Cache Eviction

Removing items from full cache. LRU, LFU, FIFO.

Cache Hit

When requested data is found in cache. Opposite of cache miss. High hit rate means good performance.

Cache Hit Rate

Percentage of requests served from cache.

Cache Invalidation

Removing stale data from cache when the source changes. One of the two hard problems in CS. TTL, event-driven, and write-through are strategies.

Cache Line

Smallest unit CPU transfers between cache and memory.

Cache Miss

Requested data not in cache. Requires slower fetch.

Cache Stampede

Many cache misses overwhelming backend simultaneously.

Call by Name

Evaluating argument expression each time accessed.

Call Graph

Graph of function calling relationships.

Call Stack

A stack data structure tracking function calls. Each call pushes a frame; returns pop it. Stack overflow occurs when too deep (infinite recursion). Visible in error traces.

Callback

A function passed as an argument to another function, executed when an operation completes. Fundamental pattern in async JavaScript, before Promises and async/await.

Callback Hell

Deeply nested callbacks making code unreadable. Solved by Promises and async/await.

Camel Case

Naming convention: myVariableName. Standard in JavaScript. Pascal Case: MyClassName. Snake: my_variable.

Canary Deployment

Rolling out to small user percentage first. Detect issues before full rollout.

Canonical Form

Standard representation removing ambiguity.

Capacity Planning

Estimating resources for expected load. CPU, memory, storage projections based on growth.

Cardinality

Number of elements or unique values in set/column.

Cascading

Effects propagating through related elements. CSS cascade, database cascade delete.

Cascading Delete

Automatically deleting child records when parent deleted.

Case Statement

Switch case selecting code branch by value.

Cast

Explicitly converting between types. parseInt('42') in JS, (int)3.14 in C. May lose data.

Catch Block

Code handling exceptions from try block. try { } catch(e) { }. Handle errors meaningfully.

Catch-All

Handler matching all remaining cases. Default route.

CDN (Code)

Using CDN for package delivery. unpkg, jsdelivr, cdnjs. Script tags for libraries.

Ceiling Function

Rounding up to nearest integer. Math.ceil().

Chain

Linked sequence of operations. Method chaining, middleware chain, promise chain.

Chain (Pattern)

Linked sequence of processing steps.

Chain of Responsibility

Pattern where request passes through handler chain. Each processes or passes. Middleware chains.

Changelog

A file documenting notable changes for each version. Keep a Changelog format: Added, Changed, Deprecated, Removed, Fixed, Security. Conventional Commits automate it.

Character Encoding

Mapping characters to bytes. UTF-8, ASCII.

Character Set

Defined collection of characters and codes. ASCII (128), Unicode (150K+). UTF-8 is universal.

Checked Exception

Exception that must be caught or declared. Java.

Checksum

Computed value verifying data integrity. MD5, SHA checksums detect corrupted downloads.

Child Process

Process created by another process. Fork, spawn.

Chunk

Portion of data processed together. Chunked transfer.

CI/CD

Continuous Integration/Continuous Deployment. Automated build, test, deploy pipeline.

Circuit Breaker

Pattern stopping calls to failing service. Open/closed/half-open states.

Circular Dependency

Module A depends on B, B depends on A. Causes initialization issues. Extract to third module.

Class

A blueprint for creating objects with shared properties and methods. Supports inheritance and encapsulation. ES6 classes in JS, dataclasses in Python, structs in Go.

Class Diagram

UML diagram showing classes, attributes, methods, relationships.

Class Method

Method belonging to class, not instances. @classmethod in Python, static in Java.

Clean Architecture

Robert C. Martin's architecture with concentric layers. Entities at the center, use cases, adapters, and frameworks in outer layers. Dependencies point inward.

Clean Build

Building from scratch without cached artifacts.

Clean Code

Well-written, readable, and maintainable code. Principles include descriptive names, small functions, and single responsibility. Popularized by Robert C. Martin.

Clean Install

Installing from scratch removing previous versions. npm ci for clean node_modules.

Clear

Removing all elements from collection or display.

CLI

Command Line Interface — text-based interface for interacting with software. Terminal commands, shell scripts, and CLI tools. More efficient than GUIs for many dev tasks.

CLI Tool

Command-line interface application. npm, git, docker. Built with oclif, commander.

Client SDK

Software development kit for API consumers.

Client-Server

Architecture where clients request services from servers. Web, mobile apps.

Clipboard

System area for temporary data storage. Cut, copy, paste operations.

Clock Drift

Time difference between clocks. Impacts distributed systems.

Clone

Creating a copy. git clone for repos, structuredClone() for JS objects. Shallow vs deep clone.

Closure

A function that retains access to variables from its outer scope even after the outer function returns. Fundamental in JavaScript for data privacy and currying.

Closure (Detail)

Function capturing variables from outer scope.

Cloud Function

Serverless function triggered by events. AWS Lambda, Cloudflare Workers. Pay per invocation.

Cluster

Group of connected computers working together. Database, compute, or search clusters.

Coalescing

Combining multiple operations into one. Batch operations.

COBOL

1959 business language still running banking systems. ~220 billion lines in production.

Code Archive

Compressed code for distribution. .tar.gz, .zip.

Code Audit

Systematic code examination for quality and security.

Code Base

Complete source code of a project or organization.

Code Clone

Duplicated code in different locations. Clone detection.

Code Coverage

Percentage of code executed during tests. Line, branch, and function coverage. 80%+ is common target. Istanbul/nyc for JS, coverage.py for Python.

Code Duplication

Same logic in multiple places. DRY violation.

Code Freeze

Period where no new changes allowed. Before releases or during incidents.

Code Generation

Automatically creating source code from specifications, schemas, or models. OpenAPI generates API clients, Prisma generates types, and protobuf generates serialization code.

Code Metrics

Quantitative measurements: cyclomatic complexity, LOC, coverage. SonarQube tracks metrics.

Code Path

Sequence of executed statements through program.

Code Point

Numeric value assigned to character in Unicode.

Code Review

The process of reviewing code by other developers before merge. Improves quality, shares knowledge, and reduces bugs. Pull Requests facilitate reviews.

Code Signing

Digitally signing code to verify authenticity. macOS Gatekeeper, npm provenance.

Code Smell

An indicator of a potential problem in code: long functions, unclear names, duplication. Not a bug but suggests the need for refactoring.

Code Style

Consistent formatting conventions. Prettier, Black (Python). Team agreement.

Codebase

Complete collection of source code for a project. Monorepo or polyrepo.

Codegen

Automatically generating code from definitions. OpenAPI, Prisma, protobuf.

Codegen Tool

Tool generating code from specifications.

Coercion

Automatic type conversion by the language runtime. JavaScript coerces '5' + 3 to '53' (string). Source of bugs. TypeScript and strict equality (===) prevent coercion issues.

Coercion (Detail)

Implicit type conversion by runtime. JS: '5' + 3 = '53'.

Cognitive Load

Mental effort to understand code. Reduce with simplicity.

Cohesion

How closely related a module's responsibilities are. High cohesion = module does one thing well.

Collaboration Tool

Software enabling team work. GitHub, Slack, Figma.

Collection

Data structure holding multiple elements. Arrays, lists, sets, maps. Each has specific performance.

Colocating

Keeping related code together. Tests next to source, styles next to components.

Column

Vertical data field in table or database.

Comma-Separated

Data delimited by commas. CSV format.

Command

An object encapsulating an action. CLI commands, CQRS commands, Redux actions.

Command Bus

Dispatching commands to appropriate handlers.

Command Pattern

A design pattern encapsulating a request as an object. Enables undo/redo, queuing, and logging operations. Each command has execute() and optionally undo().

Command Queue

Queue of commands for sequential processing.

Comment

Text ignored by compiler. // single line, /* multi */. Good comments explain why, not what.

Commit

A snapshot of changes in Git. Each commit has a unique hash, descriptive message, and reference to the previous commit. Atomic commits ease debugging.

Compact

Reducing size by removing unused space.

Comparator

Function defining custom sort order. sort((a,b) => a.price - b.price). Returns negative/zero/positive.

Compare

Checking equality or ordering between values.

Compilation

Translating source to executable. AOT compiles before running; JIT compiles during execution.

Compile Error

Error caught during compilation. Type errors, syntax errors. Fix before running.

Compiler

A program that translates high-level source code into executable machine code. Examples: GCC (C/C++), rustc (Rust), javac (Java).

Compiler Optimization

Automatic code improvement during compilation.

Compiler Warning

Non-fatal issue detected during compilation.

Completion Handler

Callback called when async operation finishes.

Complex Type

Non-primitive type: objects, arrays, classes. Passed by reference.

Component

Self-contained, reusable piece of UI or logic. React, Vue, Web Components. Props in, events out.

Component Test

Testing component with its dependencies.

Composite Pattern

Treating individual objects and compositions uniformly. Tree structures like file systems.

Composition

Building complex objects from simpler ones instead of inheritance. 'Has-a' vs 'is-a' relationship. Composition over inheritance is a core principle of modern design.

Composition Root

Single location where dependencies are composed. Application entry point.

Compression

Reducing data size. Lossless (gzip) preserves all data. Lossy (JPEG) sacrifices some quality.

Compute

Processing power for calculations. Cloud compute, edge compute, serverless compute.

Compute Shader

GPU program for general computation. GPGPU.

Computed Property

Property derived from other data. Vue computed(), React useMemo(). Recalculates on dependency change.

Concatenation

Joining strings or arrays. 'hello' + ' world', [...arr1, ...arr2].

Concurrency

Execution of multiple tasks progressing at the same time. Threads, goroutines, and async/await are concurrency mechanisms. Different from parallelism.

Concurrency Control

Ensuring correct behavior with concurrent access. Optimistic (versions) and pessimistic (locks).

Condition Variable

Thread synchronization waiting for state change.

Conditional

Code executing based on condition. if/else, ternary, switch. Control flow.

Config File

File defining settings. .env, config.yaml, tsconfig.json. Externalize configuration from code.

Config Server

Centralized configuration management. Spring Cloud.

Configuration

Settings defining application behavior. Environment vars, config files, flags.

Confluent

Company behind Kafka. Managed streaming platform.

Connection

Established link between systems. Database connections, HTTP connections, WebSocket.

Connection Pool

Reusing pre-created connections. Database pools. Reduces creation overhead.

Consistency

All nodes showing same data. Strong (immediate), eventual (delayed). CAP theorem.

Consistency Model

Rules for distributed data visibility. Strong, eventual.

Console Application

Program running in terminal. No GUI. CLI tools, scripts, utilities.

Constant

A variable whose value cannot be changed after assignment. const in JavaScript (reference immutable), final in Java, let in Swift. Communicates developer intent.

Constant Folding

Compiler evaluating constant expressions at compile time.

Constant Time

O(1) operation. Hash table lookup, array access by index. Doesn't grow with input.

Constraint

Limitation or rule. Database constraints (unique, foreign key), type constraints.

Constraint Satisfaction

Finding values meeting all constraints.

Constructor

A special method called when creating an object. Initializes properties and state. constructor() in JS classes, __init__ in Python, New() in Go.

Consumer

Component receiving and processing messages or events. Kafka consumers, queue subscribers.

Consumer Group

Set of consumers sharing message processing load.

Container

A software unit that packages code with all its dependencies. Docker is the standard. Lighter than VMs as they share the host OS kernel.

Container (Code)

Abstraction holding elements. Array, list, map, set. Also: Docker container.

Content Hash

Hash of file content for cache invalidation.

Content Type

MIME type specifying data format. application/json, text/html. HTTP Content-Type header.

Context Switch

Overhead of switching between tasks. CPU saves/restores state. Mental context switching too.

Continuation

Representation of remaining computation. Continuation-passing style. Advanced control flow.

Continuation Passing

Style where result passed to callback. CPS.

Continuous Deployment

Automatically deploying every change that passes tests to production. Beyond CI/CD — no manual approval gate. Requires excellent test coverage and monitoring.

Continuous Integration

The practice of frequently integrating code into a shared repository with automated tests. CI catches bugs early. Tools: GitHub Actions, Jenkins, GitLab CI.

Contract Testing

Verifying API providers and consumers agree on interface. Pact framework. Catches breaking changes.

Control Flow

Order of code execution. if/else, loops, switch/case alter flow. Sequential by default.

Controller

Component handling input and directing flow. MVC controller. API route handlers.

Convention Over Configuration

Sensible defaults reducing decisions. Rails and Next.js use conventions.

Conversion

Changing data from one type/format to another. Type casting, encoding, serialization.

Cookie

Small data stored by browser for a domain. Session IDs, preferences. HttpOnly for security.

Copy Constructor

Constructor creating object as copy of another. Deep vs shallow copy considerations.

Copy Elision

Compiler optimization avoiding unnecessary copies.

Copy Semantics

Rules for copying objects. C++ copy constructor.

Copy-on-Write

An optimization delaying data copying until modification. Both references share data until one writes. Used in fork(), Git objects, and persistent data structures.

Coroutine

A function that can suspend and resume execution. Python async/await, Kotlin coroutines, and Go goroutines. Enable cooperative multitasking without threads.

CORS

Cross-Origin Resource Sharing. HTTP headers allowing cross-origin requests.

Counter

Variable tracking count. Increment, decrement, reset.

Counting Semaphore

Semaphore allowing N concurrent accesses.

Coupling

The degree of dependency between software modules. Low coupling (loose coupling) is desirable — allows changing one module without affecting others.

CPU Bound

Task limited by CPU speed. Image processing, compression. Use worker threads.

CQRS

Command Query Responsibility Segregation — separating read and write models. Different data stores optimized for each. Complex but powerful for high-scale systems with event sourcing.

Crash

Unexpected program termination. Unhandled exception, segfault. Crash reports aid debugging.

Critical Path (Code)

Longest execution path determining minimum time.

Cron Job

Scheduled Unix task. Cron syntax: */5 * * * * runs every 5 min. crontab manages schedules.

Cross-Compilation

Compiling code on one platform to run on another. Building ARM binaries on x86, or iOS apps on Mac. Go and Rust have excellent cross-compilation support.

Cross-Cutting Concern

Functionality spanning multiple modules. Logging, auth.

Cross-Reference

Link between related data or documentation.

CRUD

Create, Read, Update, Delete — the four basic data persistence operations. Most web applications are essentially CRUD over a database.

Cryptographic Hash

One-way hash for security. SHA-256, BLAKE3. Irreversible.

Cryptographic Protocol

Rules for secure communication. TLS, SSH.

CSS Preprocessor

Language extending CSS. SASS, Less, Stylus. Variables, nesting, mixins.

CSV

Comma-Separated Values — plain text tabular data. Universal exchange format. Papaparse parses in JS.

CUDA Core

NVIDIA GPU processing unit for parallel computation.

Current Directory

The active directory in terminal. pwd shows it. Relative paths resolve from here.

Currying

Transforming a function with multiple arguments into a sequence of functions each taking one. add(1,2) becomes add(1)(2). Common in functional programming.

Cursor

Pointer to position in data. Database cursor for iterating results. Pagination cursor.

Custom Allocator

User-defined memory allocation strategy.

Custom Error

Application-specific error type. class NotFoundError extends Error. Meaningful error handling.

Custom Hook

Reusable React function with stateful logic. Prefix use: useLocalStorage, useDebounce.

Custom Iterator

User-defined sequential access implementation.

Cyclomatic Complexity

Code complexity measuring decision paths.

Daemon

A background process running without user interaction. System daemons (cron, sshd), Docker daemon (dockerd). Named after Maxwell's demon thought experiment.

Data Access Object

DAO pattern encapsulating data source operations.

Data Binding

Synchronizing data between model and view. One-way (React) or two-way (Vue v-model).

Data Class

A class primarily holding data with minimal behavior. Python @dataclass, Kotlin data class, TypeScript interfaces. Auto-generates equals, hash, and toString.

Data Container

Object holding structured data for transfer.

Data Contract

Agreement on data format between components.

Data Definition Language

DDL SQL creating schema. CREATE TABLE.

Data Encapsulation

Hiding data behind methods. Private fields.

Data Flow

How data moves through application. Unidirectional (React) or bidirectional. Redux enforces unidirectional.

Data Format

Structure for data representation. JSON, XML, YAML.

Data Integrity

Maintaining accuracy and consistency of data.

Data Loader

Component batching and caching data fetches.

Data Mapper

ORM pattern separating domain from persistence.

Data Object

Object primarily holding data. DTO, record, struct.

Data Partition

Dividing data across storage locations.

Data Serialization

Converting objects for storage. JSON, protobuf.

Data Source

Origin of data. Database, API, file, stream.

Data Store

System storing data. Database, cache, file system.

Data Structure

An organized way to store and access data efficiently. Arrays, linked lists, trees, graphs, hash tables, stacks, and queues. Choosing the right structure impacts performance dramatically.

Data Transfer Object

DTO — object carrying data between processes. No business logic, just fields.

Data Type

Classification of variable values. Primitive (number, string) and complex (object, array).

Data Validation

Verifying data meets rules and constraints.

Database

An organized system for storing and querying data. Relational (PostgreSQL, MySQL) use tables; NoSQL (MongoDB, Redis) use documents or key-value pairs.

Database Connection

Link between application and database. Connection string. Pool for efficiency.

Database Driver

Library connecting application to specific database.

Database Index

Structure speeding up queries. B-tree, hash. CREATE INDEX. Trade-off with writes.

Database Lock

Preventing concurrent data modification.

Database Migration

Scripts changing schema over time. Prisma migrate, Flyway. Version-controlled, reversible.

Database Pool

Reusing pre-created database connections.

Database Schema

Structure definition. Tables, columns, relationships.

Database Transaction

Atomic unit of database operations. ACID.

Date Format

Standard date representation. ISO 8601, locale-specific.

Date Library

Library for date operations. date-fns, Day.js, Luxon. Native Date is limited.

DDD Aggregate

Cluster of domain objects as a unit. Has root entity. Consistency boundary in DDD.

Dead Code

Code that can never be executed or whose result is never used. Tree shaking removes dead code from bundles. Increases maintenance burden and confuses developers.

Dead Letter Queue

Queue storing messages that couldn't be processed. SQS, RabbitMQ support DLQ.

Deadlock

A state where two or more processes wait for each other indefinitely, unable to proceed. Occurs when locks are acquired in different orders. Detection and prevention strategies exist.

Deadlock Detection

Identifying circular wait conditions.

Debounce (Code)

A programming technique delaying function execution until a pause in calls. Implemented with timers. Commonly used for search inputs and window resize handlers.

Debug

The process of finding and fixing bugs in code. Debuggers, console.log, breakpoints, and stack traces are essential tools. VS Code and Chrome DevTools are popular.

Debug Logging

Verbose output for troubleshooting issues.

Debugger

Tool for stepping through code execution.

Debugging

Finding and fixing code defects. Debuggers, console.log, breakpoints.

Decimal Precision

Exact arithmetic for financial calculations. 0.1+0.2≠0.3 in floats. Use BigDecimal or integer cents.

Decision Tree (Code)

Nested conditions selecting outcomes.

Declarative Programming

Specifying what, not how. SQL, HTML, CSS.

Decorator

A pattern that adds behavior to functions or classes without modifying them. Python @decorators, TypeScript decorators, and Java annotations. Used in frameworks extensively.

Decorator Pattern

Adding behavior to object without modifying class. Wrapping objects.

Decoupling

Reducing dependencies between components. Interfaces, events, message queues.

Deep Copy

Creating a completely independent copy of an object and all nested objects. structuredClone() in JS, copy.deepcopy() in Python. Shallow copy only copies top-level references.

Deep Learning

Neural networks with many layers. Image recognition, NLP, generative AI.

Default Case

Handler when no other conditions match.

Default Export

Module primary export. One per file. Imported without braces.

Default Parameter

Function parameter with pre-assigned value. function greet(name='World'). Simplifies calls.

Default Value

Value used when none provided.

Defensive Programming

Anticipating failures in code. Validation, null checks, error handling.

Definition

Declaration providing implementation details.

Delay

Waiting specified time before proceeding.

Delegation

Object forwarding request to another object. Composition alternative to inheritance.

Delete Operation

Removing data from storage.

Delta

Difference between two values or states.

Denormalization

Adding redundant data for read performance. Reduces joins. NoSQL often denormalized.

Dependency

External code a project relies on. Managed by package managers (npm, pip, cargo). Direct vs transitive dependencies. Lock files pin exact versions for reproducibility.

Dependency Graph

Directed graph showing module dependencies. Package managers resolve these graphs.

Dependency Hell

Version conflicts between dependencies requiring incompatible versions. Lock files mitigate.

Dependency Injection

A pattern where dependencies are passed to an object instead of created internally. Facilitates testing and reduces coupling. Frameworks like Spring and NestJS use DI.

Deploy

The process of making an application available to users. Can be manual or automated (CD). Platforms: Vercel, AWS, Railway, Coolify.

Deployment

Releasing software to production. Manual, automated, blue-green, canary.

Deployment Environment

Target system for running code. Dev, staging, prod.

Deployment Pipeline

Automated path from commit to production. Build → test → staging → production.

Deprecation

Marking code as outdated and discouraged. Warns developers to migrate before removal. @deprecated annotation, console warnings, and documentation communicate deprecation.

Depth-First Search

Traversal exploring deep before backtracking.

Derived Class

Class inheriting from base class. Subclass.

Deserialization

Converting stored format back to object.

Design Document

Written description of planned implementation.

Design Pattern

Reusable solution to common problems. Gang of Four: creational, structural, behavioral.

Design Patterns

Reusable solutions to common software problems. The Gang of Four defined 23 patterns: Singleton, Factory, Observer, Strategy, etc.

Design Review

Evaluating proposed design before implementation.

Design System

Reusable components and guidelines. Shadcn/ui, Material UI, Ant Design.

Design Token

Named value storing design decisions: colors, spacing, typography. Figma tokens export to CSS.

Desktop Application

Software running locally on computer. Electron, Tauri, native.

Destructuring

Extracting values from objects or arrays into variables. const {name, age} = user in JS. Python tuple unpacking. Cleaner, more readable code.

Deterministic

A process always producing the same output for the same input. Builds, tests, and deployments should be deterministic. Non-determinism causes flaky tests and hard bugs.

Dev Container

Containerized development environment. VS Code Dev Containers. Consistent setup.

Dev Environment

Local setup for development work.

Developer Experience

DX — how easy and enjoyable tools are. Good DX: fast, documented, intuitive.

Development Server

Local server with hot reload, error overlays. Vite dev server starts in milliseconds.

DevOps

Culture and practices uniting development and operations. CI/CD, infrastructure as code, and continuous monitoring accelerate software delivery.

DFS

Depth-First Search — a graph/tree traversal exploring as deep as possible before backtracking. Uses a stack. Applications: topological sort, maze solving, cycle detection.

Diagram

Visual representation of system/process. UML, ERD, sequence, architecture diagrams.

Dictionary

Key-value data structure. Python dict, JS Object/Map. O(1) average lookup.

Diff

Difference between two file versions. git diff shows changes. Code review displays diffs.

Diff Algorithm

Computing differences between data. Myers diff.

Digest

Fixed-size output of hash function.

Dijkstra Algorithm

Shortest path in weighted graph. O(V log V).

Directed Acyclic Graph

DAG — graph with directed edges, no cycles. Git commits, task schedulers.

Directive

Instruction to compiler/framework. Angular directives, Vue directives, pragma.

Directory

Folder organizing files. Hierarchical file system.

Dirty Read

Reading uncommitted transaction data. Isolation levels prevent. Leads to inconsistency.

Disk I/O

Reading/writing to storage. SSD IOPS >> HDD. Database performance often I/O limited.

Dispatch

Routing operation to handler. Dynamic dispatch.

Dispose

Releasing resources. IDisposable in C#.

Distributed Lock

Lock across multiple nodes. Redis Redlock, etcd leases. Prevents concurrent modification.

Distributed System

System spanning multiple machines. Challenges: partitions, consistency, latency. CAP theorem.

Divide and Conquer

Solving by splitting into subproblems.

DNS Resolver

Client looking up domain name to IP address.

Docker

Containerization platform that packages applications into portable containers. Docker Compose orchestrates multi-container setups, Docker Hub distributes images.

Docker Compose

Defining multi-container apps in YAML. Services, networks, volumes. docker compose up.

Docker Image

Immutable template for containers. Layered filesystem. Built from Dockerfile.

Docstring

Documentation embedded in source code. Python triple-quote strings, JSDoc comments, Javadoc. Generates API documentation automatically. Essential for library authors.

Documentation

Written material explaining code, APIs, systems. README, API docs, ADRs, tutorials.

Domain

Area of knowledge or activity. Domain model, domain logic, domain events.

Domain Event

Event representing business significance. OrderPlaced, PaymentProcessed. Event-driven architecture.

Domain Logic

Business rules and operations.

Domain Model

Conceptual model of business domain. Entities, value objects, aggregates.

Domain Service

Service containing business logic not belonging to entity.

Domain-Driven Design

An approach centering design on the business domain. Bounded contexts, aggregates, entities, and value objects model business reality in code.

Dotenv

Loading environment variables from .env file. dotenv library. Development convenience.

Double

64-bit floating-point number. IEEE 754 standard. Precision issues affect financial calculations.

Double-Ended Queue

Deque — add/remove from both ends.

Downtime

Period service is unavailable. Planned (maintenance) or unplanned (outage). SLAs define limits.

Driver

Software enabling hardware communication.

DRY Principle

Don't Repeat Yourself — single representation for each piece of knowledge.

Dry Run

Executing without making changes. terraform plan, git --dry-run. Preview effects safely.

Dry Run (Code)

Executing without making actual changes.

DSL

Domain-Specific Language — a language designed for a specific domain. SQL for databases, CSS for styling, Terraform HCL for infrastructure. More expressive than general-purpose languages.

DTO Pattern

Data Transfer Object — carrying data between layers without business logic.

Duck Typing

Type system where an object's suitability is determined by its methods, not its class. If it walks like a duck and quacks like a duck, it's a duck. Python and JavaScript use duck typing.

Dunder Method

Python double-underscore methods (__init__, __str__). Define operator behavior. Magic methods.

Duplicate Code

Same code in multiple places. DRY violation. Extract to shared function.

Duplicate Detection

Finding identical records in data.

Durability

Data surviving system failures. ACID D.

Dynamic Array

Array automatically resizing. ArrayList, vector.

Dynamic Configuration

Changing settings without restart.

Dynamic Dispatch

Runtime method selection. Virtual methods in C++. Enables polymorphism.

Dynamic Import

Loading modules on demand. import('./module.js') returns Promise. Enables code splitting.

Dynamic Link Library

DLL shared code loaded at runtime. .so, .dylib.

Dynamic Programming

An optimization technique solving complex problems by breaking them into overlapping subproblems. Memoization (top-down) and tabulation (bottom-up). Used in algorithms courses.

Dynamic Proxy

Proxy created at runtime. Java InvocationHandler.

Dynamic SQL

SQL constructed at runtime. Risk of injection.

Dynamic Typing

Types checked at runtime. Python, JavaScript, Ruby. Flexible but late error catching.

Eager Evaluation

Computing values immediately. Opposite of lazy. Default in most languages.

Eager Loading

Loading all related data upfront in one query. Prevents N+1 query problem. Prisma include, SQLAlchemy joinedload. Opposite of lazy loading.

Early Return

Exiting function early for invalid state.

Echo

Outputting received input. Echo server, shell echo.

Edge Case

An input or scenario at the extreme boundary of expected behavior. Empty arrays, null values, max integers. Good testing covers edge cases.

Effectful

Operation with side effects. I/O, network, mutation.

Elastic Search

Distributed search and analytics engine. Full-text search, log analysis. Based on Lucene.

Embedded Database

Database within application. SQLite, RocksDB.

Embedded System

Computer within larger device. Microcontrollers in appliances, cars, medical devices.

Emit

Publishing event or signal. Vue $emit, Node.js EventEmitter.emit(), Socket.io emit.

Empty Collection

Collection with zero elements. [], {}.

Empty String

String with length zero. '' or "".

Emulation

Mimicking one system on another. Game emulators, hardware emulation, QEMU.

Enable

Activating feature or setting.

Encapsulation

An OOP principle of hiding internal details and exposing only a public interface. Private, protected, and public control access. Protects data integrity.

Encoding

Converting data from one format to another. UTF-8 encodes text, Base64 encodes binary, URL encoding handles special characters. Different from encryption — encoding is reversible without a key.

End of Life

EOL — software stops receiving updates. Node.js, Python have EOL schedules. Migrate before.

End-to-End

Complete flow from start to finish.

End-to-End Test

Tests the complete application from the user's perspective. Simulates clicks, forms, and navigation. Playwright, Cypress, and Selenium are popular tools.

Endpoint (API)

Specific URL path for API access. GET /api/users. Each handles specific operations.

Engine

Core component providing fundamental functionality. V8 JS engine, Unreal game engine.

Enterprise Software

Large-scale business applications. ERP, CRM. Complex requirements.

Entity

Object with unique identity persisting over time. DDD entities have IDs and lifecycle.

Entity Framework

Microsoft ORM for .NET applications.

Entry

Single item in collection or data store.

Entry Point

File/function where execution begins. main() in C, index.js in Node.js.

Enum

A type with a fixed set of named constants. TypeScript enum, Python Enum, Rust enum (algebraic types). Prevents invalid values and improves code readability.

Enumerable

Object that can be iterated over.

Environment Setup

Configuring development environment.

Environment Variable

A key-value pair configured outside the application. Database URLs, API keys, and feature flags. .env files for development, platform config for production. Never commit secrets.

Ephemeral

Short-lived, temporary. Ephemeral containers, storage.

Equality Check

Comparing values. == vs === in JavaScript.

Equatable

Implementing equality comparison. Equatable protocol.

Error Boundary

React component catching child errors. Displays fallback UI instead of crash.

Error Boundary (Detail)

React fallback UI for component tree errors.

Error Chain

Linking errors showing root cause chain.

Error Correction

Detecting and fixing data errors. ECC memory.

Error Handling

Strategies for managing failures: try/catch, Result types, error boundaries. Good error handling provides useful messages, recovers gracefully, and logs for debugging.

Error Handling (Detail)

Strategies for managing failures gracefully.

Error Message

Human-readable description of what went wrong. Include what, why, and fix suggestion.

Error Propagation

Passing errors up the call stack.

Error State

Application state indicating something went wrong.

Escape Hatch

Mechanism bypassing abstractions when needed.

Eval

Executing string as code. Security risk. Avoid.

Evaluate

Computing the value of an expression. Interpreter evaluates code.

Event (Code)

Occurrence that triggers response. Click, timer, message.

Event Aggregator

Centralizing event publish/subscribe.

Event Bus

Communication channel for publish/receive without direct references. Decouples components.

Event Handler

Function responding to specific events. onClick, onSubmit in React. Connects actions to logic.

Event Loop

The mechanism that handles async operations in JavaScript. Checks the call stack, processes microtasks (Promises), then macrotasks (setTimeout). Core of Node.js.

Event Queue

Queue of events awaiting processing. JS event loop processes queue. Message queues distributed.

Event Sourcing

Storing state changes as a sequence of events instead of current state. Enables audit trail, time travel, and event replay. Used with CQRS pattern.

Event Store

Database of events for event sourcing.

Event Stream

Continuous ordered event sequence. Kafka topics, CDC, WebSocket streams.

Event-Driven

An architecture where flow is determined by events (user actions, messages, data changes). Node.js, Apache Kafka, and AWS Lambda are event-driven. Enables loose coupling.

Event-Driven Architecture

System where events trigger actions. Loose coupling, scalability.

Event-Driven Programming

Flow determined by events.

Eventual Consistency

Data becoming consistent over time, not immediately.

Exception

An error condition disrupting normal program flow. Thrown and caught with try/catch. Checked (Java) vs unchecked exceptions. Some languages prefer Result types (Rust, Go).

Exception Handling

Mechanism for runtime errors. try/catch/finally, error boundaries. Graceful recovery.

Exception Safety

Guaranteeing state consistency when exceptions occur.

Executable

File that can be run as program. .exe, ELF binaries, shell scripts with +x.

Execute

Running code or command.

Execution Context

Environment where code runs: scope, variables, this value. JS creates per function.

Execution Plan

Database strategy for query execution. EXPLAIN.

Executor

Component running submitted tasks.

Exit Code

Numeric value from process: 0 success, non-zero failure. CI fails on non-zero.

Expansion

Increasing capacity or capabilities.

Experiment

Testing hypothesis with controlled conditions.

Exponential Backoff

Retry doubling wait: 1s, 2s, 4s, 8s. With jitter for thundering herd. Standard for retries.

Export

Making code available to other modules. export default in JS, pub in Rust.

Export Default

Module's single primary export.

Express.js

Popular Node.js web framework. Middleware, routing. Minimalist, unopinionated.

Expression

Code producing value. 1 + 2, fn(), a && b.

Extension

Addition to existing software. Browser extensions, VS Code extensions. Plugin architecture.

Extension Method

Adding methods to existing types without modifying them. Kotlin and C# extension functions, Swift extensions. Enhances readability and API design.

External API

Third-party API consumed by application.

Extract

Pulling data from source. ETL extraction phase.

Extreme Programming

XP agile method. Pair programming, TDD.

Facade (Code)

Simplified interface to complex system.

Facade Pattern

Simplified interface to complex subsystem. Hides complexity behind clean API.

Facility

Service or utility supporting main functionality.

Factory

Object or function creating other objects.

Factory Method

Creating objects through method instead of constructor. Subclasses decide type.

Factory Pattern

A design pattern that creates objects without specifying exact classes. Factory methods and abstract factories decouple creation from usage. Common in frameworks.

Fail Fast

Report errors immediately rather than continuing. Easier debugging. Assertions support this.

Fail-Safe

System defaulting to safe state on failure.

Fallback

Alternative when primary fails. CSS fallback fonts, error boundary UIs. Graceful degradation.

Fan-Out

One operation triggering multiple downstream operations.

FastAPI

Python web framework with auto-docs. Type hints, async. High performance.

Feature Branch

Git branch for single feature. Created from main, merged via PR. Short-lived best.

Feature Extraction (Code)

Deriving useful features from raw data.

Feature Flag (Code)

Boolean toggling feature availability.

Feature Toggle

Enable/disable features without deployment. LaunchDarkly, Unleash. Trunk-based development.

Feedback Loop

Cycle where output influences next input. CI results inform changes. Short loops improve speed.

Fence

Memory barrier ensuring operation ordering.

FFI

Foreign Function Interface — calling code written in one language from another. Python ctypes, Node.js N-API, Rust FFI. Enables using C libraries from high-level languages.

Fibonacci Sequence

Sequence where each number is sum of two preceding. 0,1,1,2,3,5,8...

FIFO

First-In-First-Out ordering. Queues.

FIFO Queue

First-In-First-Out queue. SQS, RabbitMQ. Messages processed in order.

File Descriptor

Integer identifying open file in Unix. stdin=0, stdout=1, stderr=2.

File Handle

Reference to open file for I/O operations.

File Lock

Preventing concurrent file access.

File Path

Location of file in filesystem hierarchy.

File System

Software organizing files on storage. ext4, APFS, NTFS. Hierarchical with directories.

File Writer

Component writing data to file.

Filler

Placeholder content. Lorem ipsum, skeleton data.

Filter

Selecting elements matching condition. array.filter(x => x > 5). SQL WHERE, grep.

Final

Cannot be overridden or extended. Java final.

Finally Block

Code always executing after try/catch. Cleanup: closing files, releasing resources.

Finite Automaton

Machine with states and transitions. Regex.

Finite State Machine

A computational model with a finite number of states and transitions. Used in parsers, UI state (loading/error/success), and game AI. XState implements FSMs in JS.

First-Class Function

Functions treated as values — assigned to variables, passed as arguments, and returned from functions. JavaScript, Python, and Kotlin have first-class functions.

Fixed Point

Exact decimal without floating-point errors.

Flag

A boolean variable controlling program behavior. Feature flags toggle features on/off. Command-line flags configure CLI tools. LaunchDarkly and Flagsmith manage feature flags.

Flask

Python micro web framework. Simple, extensible. REST APIs and web apps.

Flat

Converting nested structure to single level.

Flattening

Converting nested structure to single level. Array flat(), object flattening.

Floating Point

Approximate decimal representation. IEEE 754.

Floor Function

Rounding down to nearest integer. Math.floor().

Flow Control

Managing execution order and data flow.

Fluent Interface

An API design using method chaining for readable code. query.where('age > 18').orderBy('name').limit(10). jQuery, Prisma, and many builders use fluent interfaces.

Flush

Writing buffered data to destination immediately.

Fold

Reducing collection to single value. reduce().

For Loop

Iteration construct. for(let i=0; i<n; i++). for...of for iterables.

Foreign Key

Database column referencing another table's primary key.

Fork

Creating a copy of a repository or process. GitHub forks copy repos for contribution. Unix fork() creates child processes. Forking is fundamental to open-source collaboration.

Format

Arranging data for display or storage.

Format String

String with placeholders for values. f-strings Python, template literals JS.

Formatter

Tool auto-formatting code. Prettier (JS), Black (Python), gofmt (Go).

Forward Declaration

Declaring before defining. C header prototypes.

Forward Proxy

Client-side intermediary for outgoing requests.

FOSS

Free and Open Source Software. Linux, Firefox, PostgreSQL. MIT, GPL, Apache licenses.

Fragment (Code)

Partial piece. URL fragment, GraphQL fragment.

Fragmentation

Data scattered across non-contiguous storage. GC and defragmentation address it.

Framework

A reusable software structure providing base functionality. React and Vue for frontend, Express and Django for backend, Next.js for full-stack.

Free Function

Function not attached to any object or class.

Freeze

Making object immutable. Object.freeze().

Front Controller

Single entry point handling all requests.

Frontend

The visual interface users interact with. Built with HTML, CSS, and JavaScript. Modern frameworks: React, Vue, Svelte, Angular.

Frozen Object

Object that cannot be modified. Object.freeze() in JS. For configuration constants.

Full Stack

A developer who works on both frontend and backend. Masters everything from user interfaces to servers, databases, and deployment.

Full-Text Search

Searching entire document content. Elastic.

Function Composition

Combining functions. f(g(x)). pipe, compose.

Function Overloading

Multiple functions same name, different params. TypeScript overloads, Java method overloading.

Function Pointer

Variable storing function reference. C function pointers.

Function Scope

Variables accessible only within declaring function. var in JS is function-scoped.

Function Signature

Name, parameters, return type defining function.

Functional Component

React component as function returning JSX. Hooks add state. Modern React standard.

Functional Programming

A paradigm based on pure functions, immutability, and composition. No side effects. Haskell, Elixir, and Clojure are functional; JS and Python support FP.

Futex

Fast userspace mutex. Linux synchronization.

Future

Object representing eventual result. Similar to Promise.

Fuzzing

Testing with random/malformed input to find crashes. AFL, cargo fuzz. Discovers edge cases.

Garbage

Unreachable memory ready for collection.

Garbage Collection

Automatic memory management that reclaims unused memory. Java, Go, and JavaScript use GC. Rust uses ownership instead. GC pauses can impact latency.

Garbage Collection (Detail)

Automatic memory reclamation by runtime.

Garbage Collector

Automatic memory reclamation. JVM GC, V8 GC. Mark-and-sweep, generational.

Garbage In Garbage Out

GIGO — the principle that flawed input produces flawed output. Applies to software, data analysis, and ML models. Input validation and data quality are essential.

Gateway

Entry point to system. API gateways route requests, payment gateways process transactions.

Generator

A function yielding multiple values lazily, one at a time. function* in JS, yield in Python. Memory-efficient for large sequences. Foundation of async iterators.

Generic Type

Type with parameters. Array<T>, Option<T>.

Generics

Type parameters allowing code to work with multiple types safely. Array<T> in TypeScript, Vec<T> in Rust, List<E> in Java. Write once, use with any type.

Git

A distributed version control system created by Linus Torvalds. Tracks changes, creates branches, and enables collaboration. The foundation of GitHub and GitLab.

Git Bisect

Finding bug-introducing commit via binary search. Mark good/bad, Git narrows down.

Git Branch

Independent development line. Feature branches, main, develop.

Git Cherry-Pick

Applying specific commit to different branch.

Git Clone

Copying remote repository locally.

Git Commit

Snapshot of changes. SHA hash identifies. Message describes changes.

Git Conflict

Competing changes needing manual resolution.

Git Diff

Showing differences between commits or files.

Git Flow

Branching model. feature, develop, release, main.

Git History

Chronological commit record.

Git Hook

Scripts triggered by Git events. pre-commit for linting, pre-push for tests. Husky manages.

Git Init

Creating new Git repository.

Git Log

Viewing commit history.

Git Merge

Combining branch changes. Merge commit or fast-forward. Resolve conflicts.

Git Pull

Fetching and merging remote changes.

Git Push

Uploading local commits to remote.

Git Rebase

Replaying commits on another branch. Linear history. Interactive rebase squashes commits.

Git Remote

Link to remote repository. origin, upstream.

Git Reset

Undoing commits. Soft, mixed, hard reset.

Git Stash

Temporarily saving uncommitted changes. git stash saves, pop restores.

Git Submodule

Repository nested inside another repository.

Git Tag

Named reference to commit. v1.0.0 marks releases. Triggers CI release pipelines.

GitHub

A Git-based code hosting platform. Pull requests, issues, Actions CI/CD, Copilot AI. The world's largest open-source code repository.

GitHub Actions

CI/CD platform. YAML workflows. Marketplace actions. Free for public repos.

GitHub Copilot

AI pair programmer suggesting code.

GitLab

DevOps platform. Git hosting, CI/CD, monitoring. Self-hosted or cloud.

Glob Pattern

A wildcard pattern for matching file paths. *.js matches all JS files, src/**/*.ts matches all TS files recursively. Used in gitignore, tsconfig, and build tools.

Global State

State accessible from anywhere in the application. Redux store, React Context, and Zustand manage global state. Overuse makes code hard to test and reason about.

Global Variable

Variable accessible from anywhere. Creates coupling, hinders testing. Minimize globals.

Go

Google's language designed for simplicity and concurrency. Goroutines make concurrent programming easy. Fast compilation, single binary output. Popular for backends and CLI tools.

Go Language

Google's language. Simplicity, concurrency via goroutines. Single binary.

Go Routine

Go lightweight concurrent function execution.

Golden Path

Recommended standard approach. Convention.

Goroutine

Go's lightweight concurrent function. Cheaper than OS threads — millions can run simultaneously. Communicate via channels. Go's approach to concurrency.

Graceful Shutdown

Cleaning up before exit. Finish requests, close connections, flush logs. SIGTERM handlers.

Grafana Dashboard

Visualization panel for metrics and logs.

Graph

A data structure with nodes (vertices) connected by edges. Directed or undirected, weighted or unweighted. Used in social networks, maps, and dependency resolution.

Graph (Data)

Nodes connected by edges. Directed or undirected.

Graph Algorithm

Operating on graphs. BFS, DFS, Dijkstra.

Graph Database

Database storing nodes and edges. Neo4j, Amazon Neptune. Social networks, fraud detection.

GraphQL API

A query language for APIs created by Facebook. The client specifies exactly what data it needs, avoiding over-fetching and under-fetching.

GraphQL Mutation

Write operation in GraphQL.

GraphQL Query

Read operation in GraphQL.

GraphQL Schema

Type system defining API. Types, queries, mutations, subscriptions.

Greedy Algorithm

Choosing locally optimal at each step.

Greenfield Project

New project without legacy constraints. Complete technology freedom. Rare in enterprise.

Grep

Unix text search tool. grep pattern file. Regular expressions. Essential for debugging.

Group By

Aggregating data by category. SQL GROUP BY.

Guard Clause

Early return for invalid conditions. Flattens nesting. if (!x) return. Improves readability.

Gzip

Lossless compression. HTTP responses 60-80% smaller. Content-Encoding header.

gzip

Lossless compression reducing HTTP response size 60-80%.

Handle

Reference to system-managed resource. File handles, DB connections. Must be properly closed.

Handler

Function processing specific request/event type. HTTP handlers, error handlers.

Happy Path

Default scenario when everything works. Test happy path first, then edge cases.

Hash Code

Numeric value computed from object for hash tables.

Hash Collision

When two different inputs produce the same hash value. Hash tables handle collisions with chaining or open addressing. Good hash functions minimize collisions.

Hash Map

Key-value data structure with O(1) lookup. JavaScript Map, Python dict, Java HashMap.

Hash Set

Set implemented using hash table. O(1) operations.

Hash Table

A data structure mapping keys to values with O(1) average lookup. JavaScript objects, Python dicts, and Java HashMaps are hash tables. Collisions handled by chaining.

Hashable

Object that can produce hash code. Dict keys must be.

Haskell

Pure functional language. Strong types, lazy evaluation, monads. Academic and finance.

Having Clause

SQL filter on aggregated results. After GROUP BY.

Head

First element. List head, Git HEAD (current commit).

Header File

C/C++ .h file declaring interfaces. Separates interface from implementation.

Health Check

Endpoint verifying service status. /health. Load balancers poll. Return dependencies.

Heap

A tree-based data structure where the parent is always greater (max-heap) or smaller (min-heap) than children. Priority queues use heaps. Also refers to dynamic memory allocation area.

Heap (Data Structure)

Tree where parent > children (max-heap). Priority queues. Also: dynamic memory area.

Heap Allocation

Dynamic memory allocated on heap. Objects in most languages. GC manages.

Heap Memory

Dynamic memory allocated at runtime for objects and data. Managed by garbage collector in Java/JS or manually in C/C++. Slower than stack but flexible in size.

Heartbeat (Code)

Periodic signal confirming system alive.

Helper

Utility function or class supporting main logic.

Helper Function

Utility supporting main logic. formatDate(), validateEmail(). Usually pure functions.

Heuristic

Practical approach finding good enough solution.

Hexadecimal

Base-16: 0-9 and A-F. Colors (#FF5733), memory addresses. Each digit = 4 bits.

Hexagonal Architecture

A pattern isolating business logic from external dependencies using ports and adapters. Facilitates testing and swapping technologies without affecting the core.

Hidden Field

Non-visible form input carrying data.

Higher-Order Function

A function that takes functions as arguments or returns functions. map(), filter(), reduce() are higher-order. Fundamental in functional programming.

Hijacking

Taking control of session, request, or connection.

Histogram

Frequency distribution visualization. Performance profiling.

Hit

Successful cache lookup or search result.

Hoisting

JavaScript behavior where variable and function declarations are moved to the top of their scope. var is hoisted (undefined), let/const are in temporal dead zone.

Hook

Mechanism for extending behavior. React hooks, Git hooks, WordPress hooks.

Horizontal

Side by side. Horizontal scaling, layout.

Host

Machine running services. Hostname identifies.

Hot Code Path

Frequently executed code deserving optimization.

Hot Path

Most frequently executed code. Optimizing hot path has biggest performance impact.

Hot Reload

Updating code in a running application without restarting. Vite HMR for web, Flutter hot reload for mobile. Dramatically speeds up development iteration.

HTTP

HyperText Transfer Protocol. Foundation of web. Request-response. Stateless.

HTTP Client

Software making HTTP requests. fetch, Axios, requests (Python), curl.

HTTP Header

Metadata in HTTP request/response. Content-Type, Authorization, Cache-Control.

HTTP Method

Request actions: GET read, POST create, PUT update, DELETE remove.

HTTP Server

Software handling HTTP requests. Express.js, FastAPI, Nginx, Caddy.

HTTP Status Code

Response result indicator. 200 OK, 404 Not Found, 500 Server Error.

Hypertext

Text with links to other content. Web foundation.

I/O Bound

Task limited by I/O speed. DB queries, file reads. Async handles efficiently.

IDE

Integrated Development Environment — an editor with integrated tools: autocomplete, debugging, terminal, Git. VS Code, Cursor, and JetBrains are the most popular.

Idempotent

An operation producing the same result regardless of how many times it's executed. PUT and DELETE should be idempotent. Critical for reliable APIs and retry logic.

Idiomatic

Code following language conventions. Pythonic, idiomatic Go. Readable to community.

Image (Container)

Read-only template for containers. Built from Dockerfiles. Layered, immutable.

Immutable

Data that cannot be changed after creation. New values require creating new objects. Immutable.js, Immer, and Object.freeze(). Prevents bugs from unexpected mutations.

Imperative

Step-by-step programming style. for loops, mutations. Opposite of declarative.

Import

Bringing external code into module. import from in JS, from import in Python.

Import Map

A browser feature mapping module specifiers to URLs without a bundler. Enables using bare imports (import React from 'react') directly in browsers. Supported in all modern browsers.

In-Memory Database

Database storing all data in RAM. Redis, Memcached. Sub-millisecond latency.

Index

A data structure improving database query speed. B-tree and hash indexes. CREATE INDEX speeds SELECT but slows INSERT/UPDATE. Composite indexes cover multiple columns.

Index (Database)

Structure improving query speed. B-tree, hash indexes. Speeds SELECT, slows INSERT.

Infinite Loop

Loop that never terminates. while(true) for servers. Break conditions prevent accidents.

Inheritance

An OOP mechanism where a class inherits properties and methods from another. Enables code reuse. Composition over inheritance is preferred in modern design.

Injection Attack

Inserting malicious input altering execution. SQL injection, XSS. Sanitize inputs.

Inner Join

SQL join returning only matching rows from both tables. Most common join type.

Input Validation

Checking input meets constraints. Client-side (UX) and server-side (security). Zod, Yup.

Instance

Object created from class. new User(). Each has own data, shares methods.

Integer Overflow

When a calculation exceeds the maximum value a data type can hold, wrapping around. Security vulnerability in C/C++. Rust panics on overflow in debug mode.

Integration

Connecting systems to work together. API integrations, CI. Testing verifies connections.

Integration Test

Tests interaction between multiple components: API + database, services together. Slower than unit tests but verifies pieces work together.

Interface (Programming)

A contract defining methods a class must implement, without implementation. TypeScript and Java interfaces ensure objects fulfill a contract.

Interpreter

Software executing source code directly. Python, Ruby interpreters. More flexible than compiled.

Introspection

Program examining own structure at runtime. Python type(), dir(). JS typeof, instanceof.

Inversion of Control

A principle where framework calls your code, not the other way around. Hollywood principle: don't call us, we'll call you. Dependency injection is a form of IoC.

Iteration

Repetition of a code block. for, while, and forEach loops are iterations. In Agile, iteration refers to a development cycle (sprint).

Iterator

Object providing sequential access to elements. for...of in JS, __iter__ in Python.

JavaScript

The programming language of the web. Runs in browsers and on servers (Node.js). Dynamic, interpreted, and the most used language according to Stack Overflow Survey.

JIT Compilation

Just-In-Time — compiling at runtime for optimization. V8 (JS), HotSpot (Java).

JSON

JavaScript Object Notation — a lightweight data exchange format. Human and machine readable. The standard format for REST APIs and configuration.

JSON Schema

Vocabulary for validating JSON structure. Defines types, required fields, patterns.

Kanban

Visual workflow management. Cards move through columns (Todo, In Progress, Done). WIP limits.

Key-Value Store

Simple database mapping keys to values. Redis, DynamoDB. Fast lookups. No complex queries.

KISS Principle

Keep It Simple, Stupid. Simpler solutions are better. Avoid over-engineering.

Kubernetes

A container orchestration platform that automates deployment, scaling, and management. K8s is the standard for production applications at scale.

Lambda Function

An anonymous function defined inline. Arrow functions in JavaScript (=>) and lambdas in Python. Essential in functional programming and callbacks.

Late Binding

Resolving method calls at runtime. Dynamic dispatch in OOP. Enables polymorphism.

Lazy Evaluation

Delaying computation until the result is actually needed. Generators, streams, and lazy loading use this. Saves memory and computation for large or infinite sequences.

Lexer

A component converting source code text into tokens (lexical analysis). The first stage of compilation. Identifies keywords, identifiers, operators, and literals.

Library

Reusable code providing specific functionality. Lodash, Axios, NumPy. You call library code.

Linked List

A data structure where each element points to the next. Dynamic size, efficient insertion/deletion. Singly linked, doubly linked, and circular variants.

Linting

Static analysis of code for errors, style issues, and potential bugs without running it. ESLint for JS/TS, Ruff for Python, clippy for Rust.

Literal

Fixed value in source code. 42, 'hello', true, [1,2,3]. As opposed to variables.

Load Balancer (Code)

Distributing work across workers or connections in application code.

Log Level

Severity categories: DEBUG, INFO, WARN, ERROR, FATAL. Production typically INFO+.

Loose Coupling

Minimal dependency between modules. Change one without affecting others. Good design goal.

Machine Code

Binary instructions (0s and 1s) the processor executes directly. The lowest level of programming, generated by compilers from high-level languages.

Map (Data Structure)

Key-value collection. JS Map, Java HashMap. O(1) lookup. Keys can be any type in Map.

Memoization

Caching function results for repeated inputs. useMemo in React. Avoids expensive recomputation.

Memory Leak

Memory allocated but never freed. Grows over time causing slowdowns. Profilers detect leaks.

Merge

Combining changes from one branch into another in Git. Fast-forward, merge commit, and squash merge are strategies. Merge conflicts occur when changes conflict.

Message Broker

Intermediary for message passing. RabbitMQ, Kafka, NATS. Decouples producers and consumers.

Method

Function associated with an object or class. user.save(), array.push(). Accesses this/self.

Method Chaining

Calling multiple methods sequentially. array.filter().map().reduce(). Fluent interface.

Microservice

Small independent service with own database. Communicates via APIs. Scales individually.

Microservices

Architecture where the application is split into small, independent services. Each has its own database and communicates via APIs. Scales individually.

Middleware

A software layer between request and response. In Express.js and Next.js, middleware processes auth, logging, CORS, etc. before reaching the handler.

Middleware (Code)

Function between request and response. Auth, logging, CORS. Express, Next.js middleware.

MIME Type

Media type identifying format. text/html, application/json, image/webp.

Mock

A simulated object mimicking real dependency behavior in tests. Jest mock, Vitest mock, and Sinon allow testing code in isolation.

Module

Self-contained unit of code. ES modules, CommonJS, Python modules. Encapsulates functionality.

Module Pattern

Using closures to create private scope. IIFE in JS. Predates ES modules.

Monad

Composable computation wrapper. Promises in JS, Option in Rust. Chains operations handling context.

Monkey Patching

Modifying existing code at runtime. Useful for testing. Risky in production.

Monolithic Architecture

An application deployed as a single unit. Simpler initially but harder to scale. Many companies migrate to microservices as they grow.

Monorepo

A single repository containing multiple projects or packages. Turborepo and Nx manage monorepos. Shared code, atomic commits, but can be complex at scale.

Mutex

Mutual Exclusion — a synchronization primitive preventing concurrent access to shared resources. Only one thread can hold a mutex at a time. Prevents race conditions.

MVC Architecture

Model-View-Controller — separates data (Model), interface (View), and logic (Controller). Foundation of frameworks like Rails, Django, and Laravel.

MVC Pattern

Model-View-Controller separating data, UI, and logic. Rails, Django, Laravel.

Namespace

Container for identifiers avoiding naming collisions. C++ namespace, Python packages.

Native Code

Machine code compiled for specific CPU architecture. Maximum performance. No interpreter needed.

Nested Function

Function defined inside another function. Has access to outer scope (closure).

Nil/Null

Absence of value. null in JS/Java, None in Python, nil in Go/Ruby. Billion-dollar mistake.

Node (Data)

An element in a data structure. Tree nodes, linked list nodes, graph nodes.

Noop

No-operation function that does nothing. Used as default callbacks and placeholders.

Null Coalescing

Operator returning right operand if left is null/undefined. ?? in JS/TS. a ?? 'default'.

Null Safety

Language features preventing null/undefined reference errors. Kotlin nullable types (?), Rust Option<T>, TypeScript strict null checks. The billion-dollar mistake solved.

Object

Collection of key-value pairs. JavaScript objects, Python dicts. Foundation of OOP.

Object Pool

Reusing pre-created objects instead of creating new ones. Connection pools, thread pools.

Object-Oriented Programming

A paradigm based on objects with data (attributes) and behavior (methods). Pillars: encapsulation, inheritance, polymorphism, abstraction. Java, C#, and Python use OOP.

Observer Pattern

A design pattern where objects (observers) subscribe to events from a subject. When state changes, all observers are notified. Foundation of event-driven programming.

Opaque Type

Type whose internal structure is hidden from consumers. Only creator knows implementation.

Open-Closed Principle

Software entities open for extension, closed for modification. SOLID O principle.

Optional Chaining

Safely accessing nested properties. user?.address?.city returns undefined if null.

ORM

Object-Relational Mapping — a library mapping database tables to code objects. Prisma, Drizzle, TypeORM, and SQLAlchemy are popular ORMs.

Outer Join

SQL join including rows without matches. LEFT JOIN keeps all left table rows.

Overriding

Subclass providing specific implementation of parent method. Polymorphism mechanism.

Package Manager

Tool managing software dependencies: install, update, remove. npm/pnpm/yarn for JS, pip for Python, cargo for Rust, brew for macOS. Lock files ensure reproducibility.

Pair Programming

Two developers at one computer. Driver types, navigator reviews. Knowledge sharing.

Parameter

Variable in function definition. Different from argument (value passed when calling).

Parse

Analyzing text to extract structured data. JSON.parse(), URL parsing, CSV parsing.

Parser

A component analyzing token sequences to build an AST (syntax analysis). The second stage of compilation. Validates syntax rules and creates structured representations.

Partial Application

Creating function with some arguments pre-filled. bind() in JS. Related to currying.

Pass by Reference

Passing pointer/reference to data. Changes affect original. Objects in JS, & in C++.

Pass by Value

Passing copy of data. Changes don't affect original. Primitives in JS, by default in Go.

Patch (Code)

Small targeted code change. Git patches, monkey patches. Minimal change to fix issue.

Path Finding

Algorithm finding route between nodes. Dijkstra, A*. Used in maps, games, networking.

Pattern Matching

Checking value against patterns. Rust match, when in Kotlin. More powerful than switch.

Pipe

Operator passing output to next function. Unix | pipe, proposed JS |> pipeline operator.

Plugin

Extension adding features to host application. ESLint plugins, webpack plugins, Babel plugins.

Pointer

Variable storing memory address. C/C++ pointers, unsafe Rust. Direct memory manipulation.

Polling

Repeatedly checking for changes. Long polling, short polling. Less efficient than push/websocket.

Polymorphism

OOP principle where objects of different types respond to the same interface. Method overriding (runtime) and overloading (compile-time). Enables flexible, extensible code.

Preprocessor

Processes code before compilation. C preprocessor (#include, #define), SASS for CSS.

Priority Queue

Queue where highest priority dequeued first. Implemented with heap. Task scheduling.

Process (Code)

Running program instance with own memory. PID identifies. Isolated from other processes.

Producer

Component creating and sending messages/events. Kafka producers, event emitters.

Profile

Measuring program performance. CPU profiler, memory profiler. Chrome DevTools, py-spy.

Programming Language

A formal system of instructions for communicating with computers. Classified as compiled (C, Rust), interpreted (Python, JS), or hybrid (Java, C#).

Promise

Object representing future value. Pending → fulfilled/rejected. async/await syntactic sugar.

Property

Named attribute of an object. user.name, element.style. Getter/setter accessors.

Protocol (Code)

Interface definition. Swift protocols, TypeScript interfaces. Defines what, not how.

Prototype

Object from which others inherit. JS prototype chain. Object.create(). Pre-class inheritance.

Proxy Pattern

Object acting as substitute controlling access to another. JS Proxy, Python __getattr__.

Pseudocode

Informal code-like description of algorithm. Language-independent. Used in planning and teaching.

Pull Request

A request to integrate code from one branch into another. Enables code review, discussion, and CI before merge. GitHub PRs and GitLab MRs are the standard workflow.

Queue

A FIFO (First In, First Out) data structure. Enqueue adds to back, dequeue removes from front. Used in task scheduling, BFS, and message queues like RabbitMQ.

Queue (Data Structure)

FIFO collection. Enqueue adds back, dequeue removes front. Message queues, BFS.

Race Condition

A bug where behavior depends on the timing of concurrent operations. Two threads modifying the same variable. Mutexes, atomic operations, and channels prevent races.

Read-Eval-Print Loop

REPL — interactive programming environment. Python shell, Node.js REPL, browser console.

Readonly

Property that cannot be modified after initialization. TypeScript Readonly<T>, const assertions.

Recursion

A function calling itself to solve a problem by breaking it into smaller subproblems. Requires a base case to stop. Used in tree traversal, sorting, and fractals.

Refactoring

Restructuring existing code without changing external behavior. Improves readability, performance, or maintenance. Tests ensure nothing breaks.

Reflection

Program examining and modifying own structure at runtime. Java reflection, C# reflection.

Regex

Regular Expression — a pattern for matching text strings. Powerful for validation, search, and replacement. /^[a-z]+@[a-z]+\.[a-z]{2,}$/ matches basic emails.

Release

Published version of software. Major, minor, patch releases. Release notes document changes.

REPL

Read-Eval-Print Loop — interactive environment. Python shell, Node.js REPL. Quick experimentation.

Repository

A versioned code storage location using Git. Remote repos (GitHub, GitLab) enable collaboration. Mono-repo vs multi-repo are organizational strategies.

Resource

Any data or service consumed: memory, CPU, file handles, network connections. Must be managed.

REST API

An interface following REST principles: stateless, resources via URLs, HTTP methods (GET, POST, PUT, DELETE). The most common standard for web APIs.

Rest Parameter

Collecting remaining arguments. function sum(...nums) in JS. *args in Python.

Return Value

Value function sends back to caller. return statement. void functions return nothing.

Reverse Proxy (Code)

Server forwarding requests to backend. Nginx, Caddy. SSL termination, load balancing.

Runtime Error

Error occurring during execution, not compilation. TypeError, NullPointerException.

Rust

Systems programming language focused on safety, speed, and concurrency. No garbage collector, ownership model prevents memory bugs. Loved by developers for 8 consecutive years.

Saga Pattern

Managing distributed transactions as sequence of local transactions with compensations.

Sandbox (Code)

Isolated environment for safe code execution. Browser sandbox, Docker containers.

Scalar

Single value (not collection). Numbers, strings, booleans. Opposite of vector/collection.

Scope

Region where variable is accessible. Block, function, module, global scope.

SDK

Software Development Kit — a set of tools, libraries, and documentation for developing on a platform. AWS SDK, Stripe SDK, Firebase SDK.

Sealed Class

Class restricting which classes can inherit from it. Kotlin sealed class, TypeScript discriminated unions.

Semaphore

A synchronization primitive controlling access to a shared resource with a counter. Allows N concurrent accesses (unlike mutex which allows 1). Used for connection pools and rate limiting.

Serialization

Converting objects into a format for storage or transmission. JSON.stringify(), Protocol Buffers, and MessagePack. Deserialization reverses the process.

Set

Collection of unique values. JS Set, Python set. O(1) membership test. No duplicates.

Shallow Copy

Copying top-level properties only. Nested objects still shared. Spread operator {...obj}.

Shim

Code bridging API differences. Polyfills are shims for newer browser features.

Short Circuit

Logical operators stopping evaluation early. a && b skips b if a is false.

Side Effect

Observable change beyond return value. I/O, global mutations. Pure functions have no side effects.

Singleton Pattern

A design pattern ensuring a class has only one instance with global access. Used for database connections, loggers, and config. Can make testing harder.

Slice

Extracting portion of array/string. array.slice(1,3), string.substring(0,5).

Software Architecture

The high-level structure of a system: components, relationships, and principles. Clean Architecture, hexagonal, and microservices are common patterns.

SOLID

Five OOP design principles: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion. Produces more robust code.

SOLID Principles

Five OOP principles: Single Responsibility, Open-Closed, Liskov, Interface Segregation, DI.

Sort Algorithm

Algorithm ordering elements. Quick sort O(n log n), merge sort (stable), Tim sort (hybrid).

Sorting

Arranging elements in order. Comparison-based (O(n log n) limit) and non-comparison (counting sort).

Source Code

Text written in a programming language that defines program behavior. It's compiled or interpreted to be executed by the machine.

Source Map

File mapping minified code to original source. Enables debugging production code.

Spread Operator

Expanding iterable elements. {...obj} copies, [...arr] spreads. Function calls: fn(...args).

SQL

Structured Query Language for relational databases. SELECT, INSERT, UPDATE, DELETE. Industry standard.

Stack

A LIFO (Last In, First Out) data structure. Push adds, pop removes from the top. The call stack tracks function execution. Used in undo operations and parsing.

Stack (Data Structure)

LIFO collection. Push/pop from top. Call stack, undo operations, parsing.

Stack Overflow

Call stack exceeding size limit from deep recursion. Error in most languages.

Standard Library

Built-in modules shipped with language. Python stdlib, Go stdlib, Rust std.

State

Data representing current condition. Component state, application state, server state.

State Machine

A model with finite states and transitions between them. Used in UI (loading/error/success), game logic, and workflows. XState is a popular JS library.

State Management

Patterns for managing application state. Redux, Zustand, Jotai for React.

Static Analysis

Analyzing code without executing. Linters, type checkers, security scanners.

Static Method

Method belonging to class, not instances. Called on class directly. Utility functions.

Static Typing

Types checked at compile time. TypeScript, Rust, Java. Catches errors early.

Strategy Pattern

A design pattern defining a family of interchangeable algorithms. The client selects which strategy to use at runtime. Payment processing with different gateways is a classic example.

String

Sequence of characters. Immutable in most languages. UTF-8 encoding. Template literals.

Struct

Value type grouping related data. Go struct, Rust struct, C struct. Like class without methods.

Stub

Simplified implementation replacing real component in tests. Returns predefined responses.

Subclass

Class inheriting from another (superclass). Extends behavior. class Dog extends Animal.

Subroutine

A sequence of instructions performing a task. Functions and methods are subroutines.

Switch Statement

Control flow selecting branch based on value. switch/case in most languages.

Symbol

Unique immutable identifier. JavaScript Symbol(), Ruby :symbol. Property keys, enums.

Symbol Table

A data structure mapping identifiers to their types, scopes, and memory locations. Used by compilers and interpreters. Essential for variable resolution and type checking.

Synchronization

Coordinating concurrent operations. Mutexes, semaphores, barriers, channels.

Synchronous

Operations executed sequentially — each waits for the previous one to finish. Simpler but can block execution on slow operations like I/O.

Syntax Sugar

Language features making code more readable. async/await over Promises, destructuring.

Task Runner

Tool automating development tasks. npm scripts, Make, Gulp. Build, test, deploy.

TCP/IP

Foundation protocol suite of the internet. TCP for reliable delivery, IP for addressing.

TDD

Test-Driven Development — writing tests before code. Cycle: Red (test fails) → Green (minimal code) → Refactor (improve). Ensures high test coverage.

Template Method

Pattern defining algorithm skeleton, letting subclasses override steps.

Ternary Operator

Conditional expression: condition ? ifTrue : ifFalse. Inline if/else.

Test Double

General term for test substitutes: mocks, stubs, fakes, spies, dummies.

Test Fixture

Fixed state used as test baseline. Setup before tests, teardown after.

Test Suite

Collection of related tests. Grouped by feature, module, or scenario.

this Keyword

Reference to current object context. Varies by language and call site in JS.

Thread

Lightweight execution unit sharing process memory. OS threads, green threads.

Thread Pool

A collection of pre-created threads ready to execute tasks. Avoids the overhead of creating threads for each task. Node.js libuv, Java ExecutorService use thread pools.

Thread Safety

Code safe for concurrent multi-thread execution. No race conditions or data corruption.

Throw

Raising an exception. throw new Error('msg') in JS. Python raise. Go panic.

Time Complexity

How an algorithm's runtime grows with input size. O(1) constant, O(log n) logarithmic, O(n) linear, O(n²) quadratic. Critical for choosing algorithms at scale.

Topological Sort

Ordering directed graph nodes so every edge goes from earlier to later. Used for task scheduling, dependency resolution, and build systems. Only works on DAGs.

Trait

Interface-like construct in Rust defining shared behavior. Implemented by types.

Transpiler

Converts source code from one language to another at the same level. TypeScript to JavaScript, Babel for modern JS to older JS. Different from compiler (high to low level).

Tree

Hierarchical data structure. Root node, children, leaves. Binary trees, B-trees, tries.

Trie

A tree data structure for efficient string prefix operations. Autocomplete, spell checkers, and IP routing use tries. O(m) lookup where m is string length.

Truncation

Cutting data to fit size. String truncation, decimal truncation. May lose information.

Tuple

Immutable ordered collection. Python tuples, TypeScript tuples. Fixed size, mixed types.

Type Alias

Creating alternative name for type. type ID = string in TypeScript.

Type Assertion

Telling compiler about type. value as string in TS. Overrides inference.

Type Guard

Runtime check narrowing type. typeof, instanceof. TypeScript type predicates.

Type Inference

Compiler deducing types without explicit annotation. TypeScript, Rust, Go infer types.

Type Safety

Ensuring operations are performed on compatible data types. Static typing (TypeScript, Rust) catches errors at compile time. Dynamic typing (Python, JS) checks at runtime.

Type System

Language rules for types. Nominal (Java), structural (TypeScript), duck (Python).

TypeScript

A typed superset of JavaScript by Microsoft. Adds static types, interfaces, and enums. Catches bugs at compile time. The standard for large-scale JS projects.

Union Type

Value can be one of several types. string | number in TypeScript. Sum types.

Unit Test

Tests an isolated unit of code (function, method, class). Fast and independent. Jest, Vitest, pytest, and JUnit are unit testing frameworks.

Unsigned Integer

Integer without sign bit, only positive values. uint8: 0-255. Used for sizes, indexes.

Value Object

Object without identity, defined by its values. Money(100,'USD'). Immutable in DDD.

Variable

Named storage for data. let, const, var in JS. Scope and lifetime rules vary by language.

Variadic Function

Function accepting variable number of arguments. ...args in JS, *args in Python.

Version Control

System tracking file changes over time. Git dominates. Branching, merging, history.

Versioning

The practice of tracking and managing code changes over time. Semantic Versioning (SemVer) uses MAJOR.MINOR.PATCH. Git is the standard versioning system.

Virtual Method

Method that can be overridden by subclasses. Default in Java, virtual keyword in C++.

Visitor Pattern

Pattern separating algorithm from object structure. Double dispatch. Compiler AST visitors.

Void

Return type indicating no value. void functions in C/TS. Unit type in Rust/Kotlin.

Waterfall Model

Sequential development: requirements → design → implementation → testing → deployment.

Weak Reference

Reference not preventing garbage collection. WeakMap, WeakRef in JS. Cache friendly.

Webhook

An HTTP callback notifying an application when an event occurs in another. Stripe sends webhooks when a payment is processed. Push-based vs polling.

While Loop

Loop executing while condition is true. while(x > 0) { x-- }. Check before each iteration.

Wrapper

Object/function enclosing another to add behavior. HTTP client wrappers, type wrappers.

XOR

Exclusive OR — true when inputs differ. Bitwise XOR for encryption, checksums, toggling bits.

YAML

YAML Ain't Markup Language — a readable format for structured data and configuration. Used in Docker Compose, Kubernetes, GitHub Actions, and Ansible.

YAML Pipeline

A CI/CD pipeline defined in a YAML file. GitHub Actions, GitLab CI, and Azure DevOps use YAML to define jobs, steps, and automation triggers.

Yield

Pausing generator execution and returning value. yield in JS/Python generators.

Zero-Based Index

Array indexing starting at 0. First element at index 0. Most languages use zero-based.

A/B Testing

Comparing two versions (A and B) to determine which performs better. Tests headlines, layouts, CTAs, etc. Optimizely, PostHog, and Google Optimize are tools.

Abort Controller

JS API for canceling fetch requests. AbortController signal. Timeout and cleanup.

Abort Signal

Token passed to cancelable operations. AbortController.

Above the Fold

Content visible without scrolling. Critical for first impression and engagement. Optimize above-the-fold loading speed. Term borrowed from newspaper printing.

Accept Header

HTTP header specifying media types the client can process. Accept: application/json tells the server to respond with JSON. Content negotiation mechanism.

Accept-Encoding

HTTP header for supported compression methods.

Accept-Language

HTTP header specifying preferred languages. Content negotiation for i18n.

Accessibility Tree

The browser's representation of the page for assistive technologies. Built from the DOM with ARIA attributes. Screen readers navigate the accessibility tree.

Accordion

A UI component showing/hiding content sections. Click a header to expand/collapse. Reduces visual clutter. HTML <details>/<summary> provides native accordion behavior.

Action (Form)

A URL where form data is sent on submit. <form action='/api/submit'>. Server Actions in Next.js handle form submissions on the server. Progressive enhancement.

Adaptive Image

An image served at different sizes/formats based on device. srcset and sizes attributes, <picture> element. Reduces bandwidth on mobile. Modern CDNs auto-optimize.

Address Bar

Browser URL input. Shows current URL, HTTPS lock, search. Omnibox in Chrome.

AJAX

Asynchronous JavaScript and XML — making HTTP requests without page reload. XMLHttpRequest was original API. fetch() is modern replacement. Foundation of interactive web apps.

Alignment (CSS)

Positioning elements. text-align, align-items, justify-content. Grid and Flexbox alignment.

Alt Attribute

HTML attribute providing text description for images. Required for accessibility — screen readers announce alt text. Decorative images use empty alt=''.

Alt Text

Descriptive text for images read by screen readers and shown when images fail to load. Essential for accessibility and SEO. Be concise and descriptive, not 'image of'.

Analytics

Collecting and analyzing user behavior data. Page views, clicks, conversions, and user flows. Google Analytics, Plausible, and PostHog. Informs product and marketing decisions.

Anchor Tag

The HTML <a> element creating hyperlinks. href attribute specifies the destination. Target _blank opens in new tab. Foundation of web navigation.

Animated GIF

Image format supporting animation. Limited colors. Being replaced by video and APNG.

Animation

Visual movement on web pages. CSS animations, CSS transitions, and JavaScript (GSAP, Framer Motion). requestAnimationFrame for smooth 60fps. Enhance UX when used subtly.

API Rate Limit

Maximum number of API requests allowed per time period. 429 Too Many Requests response when exceeded. Token bucket and sliding window algorithms implement limits.

API Versioning

Managing API changes without breaking existing clients. URL versioning (/v1/), header versioning, and query params. Semantic versioning communicates breaking changes.

APNG

Animated PNG. Better quality than GIF. Supports transparency. Growing browser support.

App Bar

Top navigation bar in mobile web apps. Title, actions, navigation. Material Design pattern.

App Shell

The minimal HTML, CSS, and JS needed for the UI skeleton. Cached for instant loading. Content loads dynamically. Core of PWA architecture for offline-first apps.

Application Cache

Deprecated offline caching mechanism. Replaced by Service Workers and Cache API.

Aria Attributes

ARIA (Accessible Rich Internet Applications) attributes enhancing HTML accessibility. aria-label, aria-hidden, aria-expanded. Bridge gaps in semantic HTML for assistive technology.

Aria Label

Accessible name for element. aria-label attribute.

ARIA Role

Attribute defining element purpose for screen readers. role=button, navigation, dialog.

Article Element

HTML <article> for self-contained content. Blog posts, comments, news articles.

Aside Element

HTML <aside> for tangentially related content. Sidebars, pull quotes, ads.

Aspect Ratio

The proportional relationship between width and height. 16:9 for video, 1:1 for thumbnails. CSS aspect-ratio property. Prevents layout shifts during image loading.

Asset

Any file used by a web application: images, fonts, stylesheets, scripts, and videos. Asset optimization (compression, CDN) directly impacts page load performance.

Asset Pipeline

The process of compiling, minifying, and fingerprinting CSS, JS, and images for production. Rails asset pipeline, Vite, and webpack handle this automatically.

Astro Islands

Astro's architecture where interactive components (islands) hydrate independently in a sea of static HTML. Each island loads its JS only when needed. Partial hydration.

Async Component

Component loaded asynchronously on demand. React.lazy(), Vue defineAsyncComponent.

Async Iteration

Iterating over async data sources. for await...of.

Async Script

A <script async> attribute loading JS without blocking HTML parsing. Executes as soon as downloaded. Order not guaranteed. Best for independent scripts like analytics.

Atomic CSS

CSS methodology where each class does one thing. .mt-4 adds margin-top, .flex adds display:flex. Tailwind CSS is the most popular atomic CSS framework.

Attribute Selector

CSS selector targeting elements by attribute. [type='email'], [data-active], and [href^='https']. Powerful for styling without adding classes.

Audio API

Web Audio API for processing and synthesizing audio in browsers. Oscillators, filters, and spatial audio. Powers web-based music tools, games, and audio visualization.

Audio Element

HTML <audio> for embedding sound. Controls attribute shows player. Multiple sources.

Authentication Flow

The sequence of steps to verify user identity. Login form → server validation → JWT/session → redirect. OAuth flow involves authorization server. Passwordless simplifies UX.

Autocomplete

Browser or custom feature suggesting input completions. HTML autocomplete attribute, search suggestions, and address autofill. Improves form completion rates.

Autofill

Browser automatically filling form fields from saved data. Names, addresses, and payment info. HTML autocomplete attributes guide autofill. Improves conversion rates significantly.

Autoplay

Automatic media playback. Browsers restrict for UX. Muted autoplay allowed.

AVIF

AV1 Image Format. 50% smaller than JPEG. Supports HDR, transparency. Growing support.

Babel

JavaScript transpiler converting modern code (ES2024+) to versions compatible with older browsers. Less necessary with native ES modules and esbuild.

Back Button

Browser navigation to previous page. History API. SPA must manage history correctly.

Backdrop

CSS ::backdrop pseudo-element for full-screen and dialog overlays. Styling behind modals.

Background Fetch

Service Worker API for large downloads continuing after page close.

Background Image

CSS property setting an element's background to an image. background-size: cover for full coverage. Multiple backgrounds supported. Use <img> for content images instead.

Background Sync

Service Worker API for deferring actions until connectivity restores.

Bandwidth

Maximum data transfer rate. Network bandwidth (Mbps), server bandwidth allocation. Limited bandwidth causes slow loading. Compression and CDNs optimize bandwidth usage.

Base64

A binary-to-text encoding scheme representing binary data in ASCII. Used for embedding images in CSS/HTML, email attachments, and JWT payloads. Increases size by ~33%.

Baseline Alignment

CSS aligning items to text baseline. align-items: baseline in Flexbox.

Beacon API

Sending analytics data reliably on page unload. navigator.sendBeacon(). Fire-and-forget.

BFF

Backend for Frontend — a server layer tailored to a specific frontend's needs. Mobile BFF returns different data than web BFF. Simplifies frontend logic.

Blob

Binary Large Object — raw binary data stored as a single entity. File uploads, images, and media. Blob storage (S3, Azure Blob) stores unstructured data at scale.

Block Element

An HTML element occupying full available width, starting on a new line. <div>, <p>, <h1>, and <section>. Opposite of inline elements (<span>, <a>).

Block Formatting

CSS rendering context containing floats.

Block Formatting Context

BFC — CSS rendering area containing floats and collapsing margins. Created by overflow.

Boolean Attribute

HTML attribute where presence means true. disabled, checked, required. No value needed.

Border Radius

CSS property for rounded corners. border-radius: 8px. Circular: 50%.

Bottom Sheet

Mobile UI pattern sliding up from bottom. Maps, actions, details. Touch-friendly.

Bounce Rate

The percentage of visitors leaving the site without interacting. High bounce rate may indicate irrelevant content, poor UX, or slow speed.

Box Model

CSS model defining element dimensions. Content + padding + border + margin. box-sizing: border-box includes padding and border in width. Foundation of CSS layout.

Breadcrumb

A navigation pattern showing the user's location in a hierarchy. Home > Category > Product. Improves UX and helps SEO through structured data.

Breakpoint (CSS)

Screen width triggering responsive layout change. 768px tablet, 1024px desktop.

Brotli

A compression algorithm by Google, 15-25% smaller than Gzip. Supported by all modern browsers. Slower compression but faster decompression. Ideal for static assets.

Browser Cache

Local storage of web resources for faster subsequent loads. Controlled by Cache-Control, ETag, and Expires headers. Clear cache to see latest changes during development.

Browser Compatibility

Ensuring websites work across different browsers. Can I Use tracks feature support. Polyfills add missing features. Progressive enhancement handles varying support.

Browser DevTools

Built-in development tools in browsers. Elements inspector, console, network tab, performance profiler, and Lighthouse. Chrome DevTools is the most feature-rich.

Browser Engine

The core component rendering web pages. Blink (Chrome, Edge), WebKit (Safari), and Gecko (Firefox). Processes HTML, CSS, and JavaScript into visual output.

Browser Storage

Client-side data persistence. localStorage, sessionStorage, IndexedDB, cookies.

Bundle Analyzer

Tool visualizing JavaScript bundle contents and sizes. webpack-bundle-analyzer.

Bundler

A tool combining multiple files into optimized bundles. Vite, Webpack, Rollup, and esbuild process JS, CSS, and assets for production.

Button Element

HTML <button> element for clickable actions. type='submit' for forms, type='button' for JS actions. Prefer <button> over <div onclick> for accessibility.

Cache

Temporary storage of frequently accessed data to speed up responses. Browser cache, CDN cache, Redis cache, and HTTP cache headers.

Cache API

Browser API for caching request/response pairs. Used by Service Workers for offline.

Cache Busting

Forcing browsers to download updated resources instead of cached versions. Filename hashing (app.abc123.js), query strings, and versioned URLs. Build tools automate this.

Cache Partition

Browser isolating caches by top-level origin.

Cache-Control

HTTP header defining caching behavior. max-age=3600 caches for 1 hour. no-cache revalidates. immutable for fingerprinted assets. The primary caching mechanism.

Canvas API

HTML5 API for drawing 2D graphics programmatically. Games, charts, image processing, and animations. WebGL extends Canvas for 3D. Performance-critical rendering.

Captcha

Completely Automated Public Turing test to tell Computers and Humans Apart. reCAPTCHA, hCaptcha, and Turnstile prevent bot abuse. Invisible captchas reduce friction.

Card (UI)

Contained surface for related content. Image, title, description, actions. Material Design.

Carousel (UI)

A UI component cycling through content items. Product images, testimonials, and news. Accessibility concerns — ensure keyboard navigation and pause control.

CDN

Content Delivery Network — a globally distributed network of servers serving content from the closest point to the user. Cloudflare, Fastly, and AWS CloudFront.

CDN (Web)

Content Delivery Network caching at edge. Cloudflare, Fastly, CloudFront.

Charset

Character encoding defining how bytes map to characters. UTF-8 encodes all Unicode and is the web standard (98%+ of pages). Set via meta charset tag.

Charset Meta

<meta charset='UTF-8'> declaring document encoding. Must be first in <head>.

Checkbox

An HTML input allowing multiple selections. <input type='checkbox'>. Controlled (React state) or uncontrolled (DOM). Indeterminate state for partial selection.

Chip (UI)

Compact element for tags, filters, or actions. Material Design Chips.

Chrome Extension

Browser plugin extending Chrome functionality. Manifest V3. Content scripts.

Class Attribute

HTML attribute assigning CSS classes to elements. <div class='container'>. Multiple classes separated by spaces. JavaScript: element.classList.add/remove/toggle.

Clear Fix

CSS technique clearing floated elements. Modern: display: flow-root.

Client Hint

HTTP headers sharing device info for optimization.

Client-Server

Architecture where the client (browser) makes requests and the server responds. The foundation of the modern web. REST APIs follow this model.

Clipboard API

Browser API for reading/writing to the system clipboard. navigator.clipboard.writeText() copies text. Requires user interaction and HTTPS. Powers copy-to-clipboard buttons.

Cloak

Preventing un-styled content flash before JavaScript loads. Vue v-cloak hides elements until compiled. CSS: [v-cloak] { display: none }. Improves perceived performance.

CLS

Cumulative Layout Shift — a Core Web Vital measuring visual stability. Elements shifting unexpectedly score poorly. Set explicit dimensions on images and ads to prevent CLS.

Code Mirror

Open-source browser code editor. Syntax highlighting, themes. VS Code uses Monaco.

Code Splitting

Breaking JavaScript bundles into smaller chunks loaded on demand. Route-based and component-based splitting. Reduces initial load time. Webpack and Vite support it natively.

Color Contrast

Ratio between foreground and background colors. WCAG 4.5:1 for text. Accessibility.

Color Picker

UI for selecting colors. <input type=color>. Custom pickers with HSL/RGB.

Color Space

A system for representing colors. sRGB (web standard), Display P3 (wide gamut), and HSL (hue-saturation-lightness). CSS color() function enables wide-gamut colors.

Columns (CSS)

Multi-column layout. column-count, column-gap. Newspaper-style text flow.

Component Library

Collection of reusable UI components. Shadcn, MUI, Chakra, Ant Design.

Composable

Vue.js reusable stateful logic function.

Compression (Web)

Reducing transfer size. gzip, Brotli for text. WebP, AVIF for images.

Conditional Rendering

Showing/hiding UI elements based on state. {isLoggedIn && <Dashboard />} in React. v-if in Vue. Ternary for if/else: {loading ? <Spinner /> : <Content />}.

Connection (Web)

Link between browser and server. Keep-alive reuses. HTTP/2 multiplexes.

Connection Pool

Reusing database connections instead of creating new ones per request. Reduces latency and resource usage. PgBouncer for PostgreSQL, connection pool in ORMs.

Consent Manager

Tool managing user cookie consent. GDPR compliance. OneTrust, Cookiebot.

Container Query

CSS queries based on parent container size instead of viewport. @container (min-width: 400px). Enables truly responsive components regardless of where they're placed.

Content Editable

HTML attribute making any element editable. contenteditable='true'. Foundation of rich text editors. WYSIWYG editors like TipTap and ProseMirror use contenteditable.

Content Encoding

HTTP header specifying compression algorithm used. gzip, br (Brotli), and deflate. Servers compress, browsers decompress. Accept-Encoding header negotiates.

Content Layout Shift

CLS metric. Unexpected element movement.

Content Negotiation

Server selecting response format by Accept header.

Content Projection

Passing content into component slots. React children, Vue slots, Angular ng-content.

Content Security

CSP controlling resource loading sources. Prevents XSS. Nonce or hash for inline.

Context API

React mechanism sharing data without prop drilling. Provider/Consumer pattern.

Controlled Component

Form element whose value is controlled by React state. onChange updates state.

Conversion

When a user completes a desired action: purchase, signup, download. Conversion rate (%) is the key metric for marketing and UX optimization.

Cookie

A small file stored in the browser by the server. Used for sessions, preferences, and tracking. GDPR requires consent for non-essential cookies.

Cookie Banner

A UI element requesting consent for cookie usage. Required by GDPR and ePrivacy Directive. Consent Management Platforms (CMP) manage preferences.

Core Web Vitals

Google's UX metrics: LCP (loading speed), INP (interactivity), CLS (visual stability). A ranking factor in Google Search.

CORS

Cross-Origin Resource Sharing — a mechanism allowing requests between different domains. HTTP headers like Access-Control-Allow-Origin control permissions.

CORS Header

Access-Control-Allow-Origin header enabling cross-origin requests.

CORS Preflight

OPTIONS request checking if actual request is allowed. Before non-simple requests.

Counter (CSS)

CSS counter-increment and counter() for automatic numbering.

Critical CSS

The minimum CSS needed to render above-the-fold content. Inlined in the HTML <head> for fastest first paint. Remaining CSS loaded asynchronously. Tools extract it automatically.

Critical Path

Minimum resources needed for initial render. HTML, critical CSS, blocking JS.

Cross-Browser Testing

Verifying website functionality across browsers and devices. BrowserStack, Sauce Labs, and Playwright test on real browsers. Catches rendering and behavior differences.

Cross-Origin Isolation

COOP/COEP headers enabling SharedArrayBuffer.

Cross-Site Request

Request from one origin to another. CORS controls access.

CSR

Client-Side Rendering — HTML generated in the browser via JavaScript. More interactive but worse initial SEO. Traditional SPAs with React or Vue use CSR.

CSS Accent Color

Styling form control accent colors natively.

CSS Animation

Defining multi-step animations in CSS. @keyframes rules with animation property. Transform and opacity changes are GPU-accelerated. Prefer CSS animations for simple transitions.

CSS Architecture

Methodologies organizing CSS. BEM, ITCSS, CUBE CSS. Scalable and maintainable.

CSS Aspect Ratio

Property maintaining element proportions.

CSS Backdrop Filter

Applying effects to area behind element.

CSS Cascade

The algorithm determining which CSS rules apply when multiple rules target the same element. Specificity, origin, order, and !important determine winners.

CSS Clamp

Responsive values with min/max bounds. clamp(1rem, 2vw, 2rem). Fluid typography.

CSS Color Mix

Mixing colors in CSS. color-mix() function.

CSS Columns

Multi-column text layout. Newspaper style.

CSS Containment

Isolating parts of the page for rendering optimization. contain: layout paint tells the browser this subtree is independent. Improves rendering performance significantly.

CSS Counter

A CSS feature for automatic numbering. counter-increment and counter(). Numbered lists, section numbering, and footnotes without JavaScript.

CSS Custom Property

Variables defined with --name and accessed with var(--name). Cascade through the DOM. Enable dynamic theming, responsive values, and component customization.

CSS Display

Element rendering type. block, flex, grid, none.

CSS Filter

Visual effects applied to elements. filter: blur(5px), brightness(1.2), and grayscale(). GPU-accelerated. backdrop-filter applies to the area behind an element.

CSS Flexbox

One-dimensional layout system for rows or columns. justify-content, align-items, flex-grow, and gap. Simpler than Grid for linear layouts. Most used CSS layout method.

CSS Float

Legacy layout method. Float left/right. Use Flexbox.

CSS Framework

Pre-built styles and components. Tailwind, Bootstrap, Bulma.

CSS Grid

A two-dimensional CSS layout system. Rows and columns defined with grid-template. Powerful for complex layouts. Works alongside Flexbox for different use cases.

CSS Grid (Detail)

Two-dimensional layout system with rows and columns. grid-template-columns, grid-area, and fr unit. More powerful than Flexbox for complex page layouts.

CSS has Selector

Parent selector :has() targeting elements containing specific children. game-changer.

CSS Houdini

Low-level CSS APIs for custom rendering.

CSS Layer

@layer for controlling cascade order. Reset, base, components, utilities layers.

CSS Logical Properties

Direction-aware properties. Start/end vs left/right.

CSS Margin

Space outside element border. Collapsing margins.

CSS Math

calc(), min(), max(), clamp() for dynamic values. calc(100% - 2rem).

CSS Nesting

Native CSS feature allowing nested selectors like SASS. .card { .title { color: red } }. Reduces repetition and improves readability. Supported in all modern browsers.

CSS Overflow

Handling content exceeding container.

CSS Padding

Space inside element between content and border.

CSS Paint

Houdini API for custom CSS backgrounds.

CSS Paint API

Houdini API for custom CSS backgrounds via JavaScript. Generative patterns.

CSS Position

Element placement: static, relative, absolute, fixed.

CSS Property

A style attribute. color, margin, display. 500+ properties in CSS.

CSS Reset

Removing default browser styles for consistency. Normalize.css, modern CSS reset.

CSS Rule

Selector + declaration block. .button { color: blue }. The basic CSS unit.

CSS Scope

@scope at-rule limiting where styles apply. Native component scoping.

CSS Scroll Timeline

Scroll-linked animations. @scroll-timeline.

CSS Selector

A pattern selecting HTML elements for styling. .class, #id, element, [attribute], and :pseudo-class. Specificity determines which styles win when selectors conflict.

CSS Selector List

Comma-separated selectors. .a, .b { }.

CSS Size

Width and height properties. auto, fixed, percentage.

CSS Specificity

The weight determining which CSS rules apply. Inline > ID > class > element. !important overrides all but is bad practice. Understanding specificity prevents style conflicts.

CSS Subgrid

Grid children aligning to parent grid tracks. Nested layout alignment.

CSS Transform

Modifying element appearance without affecting layout. translate, rotate, scale, and skew. GPU-accelerated for smooth animations. transform-origin sets the pivot point.

CSS Transition

Animating property changes smoothly. transition: opacity 0.3s ease. Only animates between two states. Simpler than keyframe animations for hover effects and state changes.

CSS Unit

Measurement types. px, rem, em, vw, vh, %, ch, fr. Relative vs absolute.

CSS Variable

A custom property storing reusable values. :root { --primary: #3B82F6 }. Accessed via var(--primary). Cascades through DOM. JavaScript can read/write CSS variables.

CSS Variables

Custom properties defined with -- prefix, accessed with var(). Enable theming, dark mode, and dynamic styling. Cascade and inherit like regular CSS properties.

CSS View Transition

Animating between page states. document.startViewTransition.

CSS-in-JS

Writing CSS styles in JavaScript files. styled-components, Emotion, and vanilla-extract. Scoped styles, dynamic theming, but runtime cost. Tailwind CSS is an alternative.

CSSOM

CSS Object Model — the browser's internal representation of CSS. JavaScript can read and modify CSSOM. getComputedStyle() reads applied styles. CSSOM construction blocks rendering.

Custom Element

A browser API for creating reusable HTML elements. class MyButton extends HTMLElement. Part of Web Components. Encapsulated, framework-agnostic, and native.

Custom Event

JavaScript CustomEvent for application-specific events. dispatchEvent.

Custom Media Query

@custom-media defining reusable media queries. Part of CSS spec.

Dark Mode

An interface mode with dark background and light text. Reduces eye strain, saves OLED battery, and is preferred by many developers. prefers-color-scheme in CSS.

Data Attribute

Custom HTML attributes storing extra data. data-id='123', accessed via element.dataset.id. Bridges HTML and JavaScript. CSS can select [data-active='true'].

Data Fetching

Retrieving data from server. fetch, SWR, React Query, server components.

Data Table

UI component displaying tabular data. Sorting, filtering, pagination. TanStack Table.

Date Picker

UI for selecting dates. Native <input type=date> or custom. Calendar widget.

Debounce

Delays executing a function until a pause in events. Used for search inputs — waits until the user stops typing before sending the request. Reduces unnecessary API calls.

Defer Script

A <script defer> attribute loading JS in parallel but executing after HTML parsing. Maintains execution order unlike async. Best for scripts depending on DOM.

Description List

HTML <dl> with <dt>/<dd> pairs. Glossaries, metadata, key-value displays.

Design System

A collection of reusable components, guidelines, and principles for visual consistency. shadcn/ui, Material Design, and Ant Design are popular design systems.

Design System (Web)

Unified components, tokens, guidelines. Ensures consistency across product.

Details Element

HTML <details>/<summary> for expandable content. Native accordion behavior.

Device Emulation

Simulating mobile devices in browser DevTools. Responsive testing.

Dialog Element

Native HTML <dialog> element for modal and non-modal dialogs. showModal() displays with backdrop. Accessible by default with focus trapping and Escape key support.

Disabled State

UI state preventing user interaction. disabled attribute on buttons and inputs. Visually indicated (grayed out). aria-disabled for custom components.

Disclosure Widget

UI pattern revealing hidden content. Details/summary, accordion, dropdown.

DNS

Domain Name System — translates domain names (google.com) to IP addresses. Works like the internet's phone book. Cloudflare (1.1.1.1) and Google (8.8.8.8) are popular DNS.

DNS Lookup

The process of resolving a domain name to an IP address. Adds latency to first requests. DNS caching, preconnect, and dns-prefetch reduce lookup time.

DNS Prefetch

A resource hint telling browsers to resolve DNS for external domains early. <link rel=dns-prefetch> saves 20-120ms per domain. Useful for CDN and analytics domains.

Doctype

Declaration at the top of HTML documents. <!DOCTYPE html> triggers standards mode. Without it, browsers use quirks mode with legacy rendering behaviors.

DOM

Document Object Model — the browser's tree representation of an HTML page. JavaScript manipulates the DOM to update content dynamically. Virtual DOM optimizes updates.

DOM API

JavaScript interface for document manipulation.

DOM Event

Browser event: click, submit, keydown, scroll. Event listeners handle them.

DOM Manipulation

Modifying page elements with JavaScript. createElement, appendChild, innerHTML.

DOM Node

Individual node in document tree. Element, text, comment, document nodes.

DOM Parser

Parsing HTML/XML strings into DOM. DOMParser API, parseFromString.

DOM Tree

Hierarchical representation of HTML document.

Domain

A readable name identifying a website on the internet (e.g., techdailyshot.com). Registered through registrars like Cloudflare, Namecheap, or Porkbun.

Double Submit Cookie

CSRF protection pattern. Cookie value matches form field value.

Drag and Drop

Browser API for dragging elements. draggable attribute, dragstart/drop events. Libraries like dnd-kit and react-beautiful-dnd add features. File drops for uploads.

Drawing API

Canvas 2D, SVG, WebGL for rendering graphics in browsers.

Dropdown

A UI component showing a list of options. HTML <select>, custom dropdowns with accessibility. Combobox for searchable dropdowns. Headless UI and Radix provide accessible dropdowns.

Dry Layout

CSS approach avoiding unnecessary wrapper divs. Semantic HTML with minimal markup.

Dynamic Route

URL pattern with variable segments. /users/:id. Next.js [id].js, Express :param.

Edge Cache

Content cached at CDN edge servers near users. Static assets, HTML pages, and API responses. Cache-Control headers control edge caching. Instant serving for cached content.

Edge Function

Serverless function running at CDN edge.

Edge Functions

Serverless functions running at CDN edge locations near users. Sub-millisecond cold starts. Vercel Edge Functions, Cloudflare Workers, and Deno Deploy.

Element Query

Deprecated predecessor to container queries. Responsive to parent size.

Email Template

HTML formatted for email clients. Limited CSS support — inline styles required. MJML and React Email simplify creation. Tables for layout due to poor email client CSS support.

Embed

Including external content in a page. <iframe> for websites, <embed> for media, and oEmbed for social content. Security considerations: sandbox attribute restricts iframe capabilities.

Embed Code

HTML snippet for embedding third-party content. YouTube, Twitter, maps.

Emoji Picker

A UI component for selecting emoji characters. Native OS pickers and web implementations. Accessible via keyboard shortcuts (Win+. or Cmd+Ctrl+Space).

Empty State

UI shown when no data exists. Helpful message, illustration, action button.

Environment Variable (Web)

Server-side config. NEXT_PUBLIC_ prefix for client. .env.local.

Error Boundary

A React component catching JavaScript errors in its child tree. Displays fallback UI instead of crashing the entire app. Class component with componentDidCatch.

Error Boundary (Web)

Component catching child errors showing fallback.

Error Page

A custom page displayed when errors occur. 404 Not Found, 500 Server Error. Custom error pages maintain brand consistency and help users navigate back.

Error Recovery

Gracefully handling failures. Retry, fallback content, error boundaries.

ETag

An HTTP header providing a version identifier for a resource. Browsers send If-None-Match for conditional requests. Enables efficient caching with 304 Not Modified responses.

Event Bubbling

DOM events propagating from target element up through ancestors. Click on a button bubbles to its parent div, then body. stopPropagation() prevents bubbling.

Event Delegation

Handling events on a parent element instead of individual children. One listener on <ul> handles all <li> clicks. Efficient for dynamic lists and large collections.

Event Listener

A function registered to respond to specific events. addEventListener('click', handler). Multiple listeners per event. removeEventListener for cleanup. Passive option for scroll.

Event Propagation

How events travel through DOM. Capture (down), target, bubble (up).

Exit Intent

Detecting when user moves to close/leave page. Popup trigger for retention.

Experimental Feature

Browser feature behind flag. chrome://flags, about:config. Not stable.

Expires Header

HTTP header setting an absolute expiration date for cached resources. Less flexible than Cache-Control. Often used alongside max-age. Legacy but still supported.

External Script

JavaScript loaded from a separate file. <script src='app.js'>. Cacheable across pages. async and defer control loading behavior. Better than inline for production.

Fallback Content

Content shown when primary fails. Image alt text, font fallback, error UI.

Fallback Font

A substitute font displayed while the primary web font loads. font-display: swap shows fallback immediately. System font stacks as fallbacks prevent layout shifts.

Favicon

The small icon displayed in browser tabs and bookmarks. Multiple sizes for different contexts. SVG favicons with dark mode support are modern best practice.

Feature Detection

Checking if a browser supports a feature before using it. Modernizr and native checks (if ('serviceWorker' in navigator)). Better than user-agent sniffing.

Feature Detection (Web)

Checking browser capabilities before using.

Fetch API

Modern JavaScript API for making HTTP requests. Returns Promises. Replaces XMLHttpRequest. fetch('/api/data').then(r=>r.json()). Supports streaming, AbortController, and Request/Response.

Field Validation

Checking individual form field. Required, pattern, custom rules. Real-time feedback.

Figma

Collaborative design tool. Components, auto-layout, prototyping. Industry standard.

Figma (Tool)

The leading collaborative design tool. Design, prototyping, Dev Mode, and FigJam. Real-time multiplayer editing revolutionized product design.

File Input

HTML input for file selection. <input type='file' accept='image/*'>. Multiple files with multiple attribute. Drag and drop provides better UX for file uploads.

File Reader

JavaScript API reading files from user's device. FileReader.readAsText().

File Upload

Sending files to server. <input type=file>, drag-and-drop, chunked uploads.

First Contentful Paint

FCP — the time from navigation to when the browser renders the first piece of content. A key performance metric. Under 1.8 seconds is considered good.

First Input Delay

FID — legacy Core Web Vital measuring time from first interaction to browser response. Replaced by INP (Interaction to Next Paint) in 2024. Heavy JS blocks the main thread.

Fixed Layout

Non-responsive design with fixed pixel widths. Legacy approach. Use responsive.

Fixed Position

CSS position: fixed elements stay in place during scrolling. Relative to viewport. Used for sticky headers, floating buttons, and cookie banners. Can cause mobile issues.

Flexbox

A one-dimensional CSS layout model for arranging items in rows or columns. justify-content, align-items, and flex-grow control distribution. Simpler than Grid for linear layouts.

Floating Label

Form label animating from placeholder to above input on focus.

Focus Management

Controlling which element receives keyboard focus. tabindex for focus order, focus trapping in modals, and aria-activedescendant for composite widgets.

Focus Ring

Visual indicator showing focused element. outline property. :focus-visible for keyboard only.

Focus Trap

Keeping keyboard focus within a specific container. Essential for modals and dialogs. Tab cycles through focusable elements inside. Focus returns to trigger on close.

Font Display

Controlling web font loading behavior. Swap, block.

Font Face

CSS @font-face rule for loading custom fonts. Specifies font file, family name, weight, and style. WOFF2 format for best compression. Subset fonts for faster loading.

Font Loading

Strategies for loading web fonts without layout shifts. font-display: swap shows fallback immediately. Preloading critical fonts and using system font stacks for performance.

Font Loading API

JavaScript API controlling web font loading. document.fonts.ready promise.

Font Subset

Including only needed characters in font file. Reduces size dramatically.

Font Weight

CSS property for text thickness. 100 thin to 900 black. Variable fonts: any value.

Footer

The bottom section of a page or section. HTML <footer> element. Contains copyright, links, and contact info. Semantic element improving accessibility and SEO.

Footer (Web)

Bottom page section with legal, links, contact. HTML <footer> element.

Form Action

Server endpoint handling form submission. Next.js Server Actions.

Form Data

JavaScript FormData API for constructing form key-value pairs. new FormData(formElement). Supports file uploads. Automatically sets multipart/form-data content type.

Form State

Current values and status of form inputs. Controlled by React state or FormData.

Form Validation

Checking form input meets requirements before submission. HTML5 validation (required, pattern, min/max) and JavaScript validation (Zod, Yup). Both client and server-side needed.

Fragment

A way to group elements without adding extra DOM nodes. React Fragment (<>...</>), Vue template, and DocumentFragment. Keeps markup clean and improves performance.

Frame Rate

The number of frames rendered per second. 60fps is smooth, below 30fps feels janky. requestAnimationFrame synchronizes with display refresh. Performance tools measure frame rate.

Full Screen API

Browser API for entering/exiting full-screen mode. requestFullscreen().

Full-Width Layout

A design spanning the entire viewport width. Negates container max-width. Used for hero sections and feature showcases. CSS: width: 100vw with overflow considerations.

Functional CSS

Utility-first approach. Small single-purpose classes. Tailwind CSS philosophy.

Gallery

UI component displaying image collection. Grid layout, lightbox for full view.

Gap (CSS)

Space between flex/grid items. gap: 16px. Replaces margin-based spacing.

Geolocation API

Browser API accessing user's geographic position. navigator.geolocation.getCurrentPosition(). Requires user permission. Used for maps, local search, and location-based features.

Git Pages

Static site hosting directly from Git repositories. GitHub Pages, GitLab Pages, and Cloudflare Pages. Automatic deployment on push. Free for public repos.

Global CSS

Styles applied site-wide. Reset, typography, utilities. Imported in layout.

Golden Ratio

Proportional relationship ~1.618:1. Used in design for pleasing proportions.

Gradient

CSS visual effect transitioning between colors. linear-gradient, radial-gradient, and conic-gradient. Used for backgrounds, text, and borders. Multiple color stops for complex effects.

GraphQL

A query language for APIs letting clients request exactly the data they need. Single endpoint, strongly typed schema, real-time subscriptions. Created by Facebook.

GraphQL (Web)

API query language. Client specifies exact data.

GraphQL Subscription

Real-time data streaming in GraphQL using WebSockets. Clients subscribe to events and receive updates automatically. Used for live feeds, notifications, and chat.

Grid Area

Named regions in CSS Grid layout. grid-template-areas defines layout visually. grid-area assigns elements to areas. Intuitive for complex page structures.

Grid Column

Vertical track in CSS Grid. grid-column: 1 / 3 spans two columns.

Grid Gap

Space between CSS Grid or Flexbox items. gap: 16px for equal spacing. row-gap and column-gap for different axes. Replaces margin hacks for component spacing.

Grid Row

Horizontal track in CSS Grid. grid-row: 1 / -1 spans all rows.

Grid Template

Defining grid structure. grid-template-columns: repeat(3, 1fr) for equal thirds.

Gutter

Space between grid columns. CSS gap property. Print term adopted by web design.

Gzip

A compression algorithm reducing file sizes by 60-80%. Servers compress responses, browsers decompress. Brotli is newer and more efficient. Enabled via Accept-Encoding header.

Hamburger Menu

Three-line icon toggling mobile navigation. Widely recognized but debated UX.

Hash Fragment

The part of a URL after #. Used for in-page navigation and client-side routing. Not sent to server. hashchange event detects changes. SPA routers used hash routing.

Hash Router

Client-side routing using URL hash fragment. /#/about. No server config needed.

HATEOAS

Hypermedia as Engine of Application State. REST principle. Links in responses.

Head Element

HTML <head> containing metadata: <title>, <meta>, <link>, and <script>. Not rendered visually. Critical for SEO, social sharing, and resource loading.

Head Management

Dynamically updating <head> content. next/head, react-helmet. Title, meta tags.

Header Element

HTML <header> element for introductory content. Page headers with logo and navigation, or section headers. Multiple <header> elements per page are valid.

Headless CMS

A CMS providing content via API without a frontend. Strapi, Sanity, and Contentful let you use any frontend (React, Vue, etc.) with content management.

Headless Component

UI component with logic but no styling. Headless UI, Radix. Style yourself.

Heatmap

Visualization of where users click, scroll, and move their mouse. Identifies areas of interest and UX problems. Hotjar and Microsoft Clarity are popular.

HEIC

High Efficiency Image Container — Apple's image format using HEVC compression. 50% smaller than JPEG at same quality. Convert to WebP/AVIF for web compatibility.

Helper Class

CSS utility class for common styles. .text-center, .hidden, .sr-only.

Hero Section

The prominent top section of a landing page. Large headline, subtext, CTA button, and often a background image or video. First thing visitors see. Must communicate value.

Hidden Content

Content visually hidden but accessible to screen readers. CSS: .sr-only class with clip and overflow. aria-hidden='true' hides from screen readers. Different use cases.

High Contrast

Accessibility mode with increased contrast. Forced colors media query.

History API

Browser API for manipulating the URL without page reload. history.pushState() adds URL to history. Enables SPA routing. back(), forward(), and replaceState() methods.

Hosting

A service storing and serving websites on the internet. Shared, VPS, dedicated, or cloud. Providers: Vercel, Netlify, AWS, Hetzner.

Hot Module Replacement

HMR — updating modules in a running application without a full page reload. Preserves state during development. Vite HMR is near-instantaneous.

Hover State

Visual change when cursor hovers over an element. :hover pseudo-class in CSS. Not available on touch devices. Use focus-visible for keyboard users.

HTML Attribute

Named value on HTML element. class, id, href, src. Controls behavior and appearance.

HTML Entity

Special characters in HTML using & codes. &amp; for &, &lt; for <, &nbsp; for non-breaking space. Prevents browser interpretation of reserved characters.

HTML Form

The <form> element grouping input elements for data submission. action URL, method GET/POST. Native validation with required and pattern. Progressive enhancement with JS.

HTML Parser

Browser component parsing HTML text into DOM tree. Forgiving of errors.

HTML Semantics

Using HTML elements for their intended meaning: <nav> for navigation, <article> for content, <aside> for sidebars. Improves accessibility, SEO, and code readability.

HTML Tag

Element markers in HTML. Opening <div>, closing </div>, self-closing <img />.

HTML5

The fifth major version of HTML. Semantic elements, Canvas, WebSocket, Geolocation, and localStorage. Released 2014 but the living standard continues evolving.

HTMX

Library extending HTML with AJAX, CSS transitions.

HTTP

HyperText Transfer Protocol — the web's communication protocol. Defines how browsers request and receive pages. Methods: GET, POST, PUT, DELETE.

HTTP Cache

Storing HTTP responses for reuse. Browser cache and proxy cache. Cache-Control.

HTTP Caching

Storing responses for reuse. Cache-Control.

HTTP Cookie

Server-set data stored by browser. Session, preferences. Secure, HttpOnly, SameSite.

HTTP Proxy

Intermediary for HTTP requests. Forward proxy or reverse proxy.

HTTP Request

Client message to server. Method, URL, headers, body. GET, POST, PUT, DELETE.

HTTP Response

Server message to client. Status code, headers, body. JSON, HTML, binary.

HTTP/2

Major HTTP revision with multiplexing (multiple requests over one connection), header compression, and server push. Significantly faster than HTTP/1.1. Supported by all modern browsers.

HTTP/3

Latest HTTP version using QUIC protocol (UDP-based). Faster connection setup, better on unreliable networks, and eliminates head-of-line blocking. Cloudflare and Google support it.

HTTPS

HTTP Secure — encrypted version of HTTP using TLS/SSL. The padlock in the browser indicates HTTPS. Required for security, SEO, and user trust.

HTTPS Redirect

Automatically redirecting HTTP requests to HTTPS. Server-side redirect (301) and HSTS header. Ensures all traffic is encrypted. Required for modern web security.

Hydration

The process of attaching JavaScript event handlers to server-rendered HTML. The page becomes interactive. Slow hydration causes the 'uncanny valley' — visible but unresponsive UI.

Hyperlink

A clickable reference to another resource. HTML <a href='url'>text</a>. Foundation of the web. Links can be internal (same site) or external (different domain).

i18n

Internationalization — designing software to support multiple languages and regions. i18n libraries (next-intl, react-i18next) handle translations, dates, numbers, and RTL layouts.

Icon (Web)

Small visual symbol. SVG icons, icon fonts, emoji. Lucide, Heroicons.

Icon Font

Font files containing icons instead of text characters. Font Awesome, Material Icons. Being replaced by SVG icons for better accessibility, sizing, and multi-color support.

Idempotency Key

A unique identifier ensuring an API request is processed only once. Prevents duplicate payments or actions on network retries. Stripe uses idempotency keys.

Iframe

An HTML element embedding another document within the page. <iframe src='url'>. Used for third-party embeds (YouTube, maps). Security: sandbox attribute restricts capabilities.

Image CDN

CDN optimizing and transforming images. Cloudinary, imgix. Format conversion, resizing.

Image Format

File formats for images: JPEG (photos), PNG (transparency), WebP (modern), AVIF (next-gen), SVG (vectors). Choosing the right format balances quality and file size.

Image Lazy Loading

Deferring image load until near viewport. loading=lazy attribute. Native.

Image Map

An HTML image with clickable areas. <map> and <area> elements define regions. Legacy technique. Modern alternatives: SVG with links or CSS positioned links over images.

Image Optimization

Reducing image file sizes without visible quality loss. WebP and AVIF formats, responsive srcset, lazy loading, and CDN image transformation. Biggest performance win for most sites.

Image Sprite

Single image with multiple graphics. CSS background-position selects region.

Immersive Web

WebXR API for VR/AR experiences in browser. Three.js, A-Frame.

Import Map (Web)

A browser feature mapping module names to URLs. <script type='importmap'>. Enables bare imports without bundlers. Modern alternative to bundling for simpler applications.

IndexedDB

A browser-based NoSQL database for storing large amounts of structured data client-side. Asynchronous API, supports indexes and transactions. Used by PWAs for offline storage.

Infinite Scroll

Loading more content as the user scrolls down, instead of pagination buttons. Used by Twitter, Instagram, and Reddit. Intersection Observer API detects scroll position.

Inline Block

CSS display combining inline flow with block dimensions. Replaced by Flexbox.

Inline Element

An HTML element flowing within text without line breaks. <span>, <a>, <strong>, and <em>. Only takes needed width. Cannot set width/height (use inline-block).

Inline Style

CSS applied directly to an element via style attribute. Highest specificity. Used for dynamic values in JS frameworks. Avoid for static styles — use classes instead.

INP

Interaction to Next Paint — Core Web Vital measuring responsiveness. Time from user interaction to visual response. Under 200ms is good. Replaced FID in 2024.

Input Element

HTML element for user data entry. Types: text, email, password, number, date, range, color, file. Attributes: placeholder, required, pattern, min, max.

Input Mask

Formatting input as user types. Phone (123) 456-7890, card 4111-1111-1111-1111.

Interactive Element

HTML element users can interact with. Buttons, links, inputs, select.

Internal Link

Link within same website. Relative URLs. Good for SEO and navigation.

Intersection Observer

Browser API detecting when elements enter or exit the viewport. Efficient lazy loading, infinite scroll, and scroll-triggered animations without scroll event listeners.

ISR

Incremental Static Regeneration — Next.js feature regenerating static pages in the background after deployment. Combines SSG speed with dynamic content freshness.

Jamstack

Web architecture: JavaScript, APIs, Markup. Pre-rendered sites served via CDN with dynamic functionality via APIs. Vercel and Netlify popularized it.

JavaScript Engine

Runtime executing JS. V8 (Chrome/Node), SpiderMonkey (Firefox), JSC (Safari).

JSON

JavaScript Object Notation. Lightweight data format. Universal data exchange.

JSON API

A specification for building APIs with JSON. Standardizes request/response format, relationships, sorting, filtering, and pagination. Reduces bikeshedding on API design.

JSON Web Token

JWT — compact token for authentication. Header.payload.signature. Stateless auth.

JSON-LD

JSON for Linking Data — structured data format for Schema.org markup. Embedded in HTML <script> tags. Powers rich snippets in Google Search results.

JWT Token

JSON Web Token — a compact, self-contained token for authentication. Contains header, payload (claims), and signature. Stateless — no server-side session needed.

Keyboard Navigation

Navigating websites using keyboard alone. Tab moves focus, Enter activates, Escape closes. Essential for accessibility. tabindex and focus management enable keyboard UX.

Keyframe

CSS @keyframes defining animation states at specific points. 0%, 50%, 100%.

Label Element

HTML <label> associates text with form inputs. Clicking label focuses the input. for attribute links to input id. Essential for accessibility and mobile usability.

Landing Page

A web page focused on a single action/conversion. Minimal design, clear CTA, and persuasive copy. Used in marketing campaigns, launches, and lead generation.

Last Modified

HTTP header indicating when resource last changed. Conditional request support.

Layout

How elements are arranged on page. CSS Grid, Flexbox, positioning.

Layout Engine

Browser component calculating element positions. Blink, WebKit, Gecko.

Layout Shift

Unexpected movement of page elements during loading. Images without dimensions, dynamic ads, and late-loading fonts cause shifts. CLS metric measures this.

Lazy Image

An image loaded only when it enters the viewport. loading='lazy' attribute. Native browser support. Reduces initial page weight. Placeholder or blur-up effect while loading.

Lazy Loading

A technique deferring resource loading until needed. Images, components, and routes load on-demand, improving initial performance.

LCP

Largest Contentful Paint — Core Web Vital measuring loading performance. Time until the largest visible element renders. Under 2.5 seconds is good. Optimize images and fonts.

Letter Spacing

CSS property adjusting space between characters. letter-spacing: 0.05em. Used in headings and button text. Improves readability of uppercase and small text.

Lighthouse

A Google tool auditing page performance, accessibility, SEO, and best practices. Score from 0-100. Integrated into Chrome DevTools.

Lighthouse Score

A 0-100 score from Google Lighthouse for Performance, Accessibility, Best Practices, and SEO. 90+ is green. Measures real-world web quality metrics.

Line Clamp

CSS limiting text to N lines with ellipsis. -webkit-line-clamp. Truncation.

Line Height

CSS property controlling space between text lines. line-height: 1.5 for body text. Affects readability and vertical rhythm. Unitless values recommended over px.

Link Element

HTML <link> for external resources. Stylesheets, favicons, preload hints, and canonical URLs. rel attribute defines relationship: stylesheet, icon, preconnect.

Link Hover

Visual change when hovering over link. :hover pseudo-class. Color, underline.

Link Prefetch

Browser hint to fetch a resource likely needed for future navigation. <link rel='prefetch'>. Loaded at low priority during idle time. Improves subsequent page load.

Link Preload

Telling the browser to fetch a critical resource early. <link rel=preload as=font> for fonts, as=script for JS. Improves loading of above-the-fold resources.

List Element

HTML ordered <ol> and unordered <ul> lists with <li> items. Semantic structure for navigation menus, features, and step-by-step instructions. Styled with list-style.

Loader

UI component indicating loading state. Spinners, bars, dots. CSS animation.

Loading State

UI feedback indicating data is being fetched. Spinners, skeleton screens, and progress bars. Improves perceived performance. React Suspense handles loading states declaratively.

Local Storage

Browser API storing key-value pairs persistently (5-10MB). Synchronous, string-only. Good for preferences, not sensitive data. sessionStorage clears on tab close.

Locale

Language and regional settings affecting formatting. en-US, pt-BR, ja-JP. Intl API formats dates, numbers, and currencies. Accept-Language header for server-side locale.

Localization

Adapting content for specific locale. Translation, date/number formatting.

Logical Properties

CSS properties based on writing direction instead of physical direction. margin-inline-start instead of margin-left. Automatically correct for RTL languages.

Login Form

Authentication interface. Username/email, password, submit. OAuth alternative.

Long Task

A browser task blocking the main thread for 50ms+. Causes janky UI and poor INP scores. Break long tasks with setTimeout, requestIdleCallback, or web workers.

Main Element

HTML <main> containing the page's primary content. One per page. Helps screen readers skip to main content. Landmarks improve navigation for assistive technology.

Manifest File

A JSON file describing a web app for PWA installation. Name, icons, theme color, start URL, and display mode. Required for Add to Home Screen on mobile.

Markdown

Lightweight markup language. # heading, **bold**, [link](url). README, docs.

Marquee

Legacy HTML element for scrolling text (deprecated). CSS animations achieve similar effects. Generally considered poor UX. Use sparingly for tickers and announcements.

Mask

CSS mask property applying an image as a mask to an element. Alpha channel determines visibility. Used for creative shapes, image effects, and icon coloring.

Masonry Layout

Pinterest-style staggered grid. Items fill vertical space. CSS Grid experimental.

Max Width

CSS property limiting an element's maximum width. max-width: 1200px for content containers. Combined with width: 100% for responsive behavior. Prevents content from becoming too wide.

Media Query

CSS rules applying styles based on device characteristics: screen width, orientation, color scheme. Foundation of responsive design. @media (max-width: 768px) targets mobile.

Mega Menu

A large dropdown menu displaying multiple categories and links. Used by e-commerce sites. Requires careful accessibility: keyboard navigation, screen reader announcements.

Meta Description

An HTML meta tag describing page content for search results. Under 160 characters. Compelling descriptions improve click-through rates from search results. Not a ranking factor.

Meta Tag

HTML tags in <head> providing metadata: title, description, keywords, viewport. Essential for SEO and social media sharing.

Meta Viewport

HTML meta tag controlling viewport behavior on mobile. width=device-width, initial-scale=1. Without it, mobile browsers render at desktop width then zoom out.

Metadata

Data about data. HTML <meta>, JSON-LD, Open Graph. SEO and social sharing.

Micro Frontend

Independently deployable frontend parts. Module federation, iframe, web components.

Middleware (Web)

Software intercepting requests before they reach the handler. Authentication, logging, CORS, and rate limiting. Express middleware, Next.js middleware, and Cloudflare middleware.

MIME Type

Media type identifying file formats in HTTP. text/html, application/json, image/webp. Content-Type header tells browsers how to process responses.

Minification

Removing spaces, comments, and unnecessary characters from code. Reduces JS, CSS, and HTML size. Terser and cssnano are minifiers.

Minified CSS

CSS with whitespace, comments, and unnecessary characters removed. Reduces file size 20-50%. cssnano, lightningcss, and build tools minify automatically. Source maps for debugging.

Minified JavaScript

JavaScript with whitespace removed and variables shortened. Terser and esbuild minify production code. Reduces bundle size significantly. Source maps map back to original.

Mobile First

Design strategy starting with mobile layout then enhancing for larger screens. @media (min-width: 768px) adds desktop styles. Content priorities and touch-friendly by default.

Mobile Navigation

Navigation patterns for small screens. Hamburger menu, bottom tab bar.

Modal

An overlay dialog requiring user attention before returning to the main content. Used for confirmations, forms, and alerts. Accessible modals trap focus and support Escape key.

Modal Dialog

Overlay requiring user attention. Focus trap, backdrop, Escape to close.

Module Bundler

Tool combining modules into bundles. webpack, Rollup, esbuild, Vite.

Monospace Font

Font with equal character width. Code editors. JetBrains Mono, Fira Code.

MPA

Multi-Page Application — traditional web architecture where each navigation triggers a full page load from the server. Better SEO, simpler architecture. Astro and Rails use MPA.

Multi-Column

CSS layout flowing text across columns. column-count, column-gap.

Mutation Observer

A browser API watching for DOM changes. Triggers callbacks when elements are added, removed, or modified. Used by frameworks and analytics for dynamic content detection.

Named Export

Explicit exports from module. export { Button }. Import by name.

Native Lazy Loading

Browser loading=lazy attribute. Images and iframes. No JavaScript needed.

Nav Element

HTML <nav> element for navigation links. Screen readers identify navigation landmarks. Multiple <nav> elements with aria-label differentiate primary, secondary, and footer navigation.

Navigation

Moving between pages/sections. <nav> element, links, routing. UX critical.

Network Request

HTTP call from browser to server. Visible in DevTools Network tab.

Network Waterfall

A timeline visualization of resource loading in browser DevTools. Shows request timing, size, and dependencies. Essential for diagnosing loading performance issues.

Newsletter

Email subscription for regular updates. Signup form, confirmation. Mailchimp.

Next.js

React framework with SSR, ISR, App Router. Vercel created. Most popular React framework.

No Script

HTML <noscript> element displaying content when JavaScript is disabled. Fallback messages, static content, and tracking pixels. Progressive enhancement alternative.

Node.js

JavaScript runtime for servers. V8 engine. npm ecosystem. Backend, CLI tools.

Normalize CSS

A CSS reset providing consistent default styles across browsers. Normalizes form elements, headings, and margins. Modern alternative: CSS reset by Josh Comeau or Tailwind preflight.

Notification API

Browser API for displaying system notifications. Requires user permission. Used by chat apps, news sites, and PWAs. Service workers enable push notifications.

Number Input

HTML <input type='number'> for numeric values. min, max, and step attributes. Spinner buttons for increment/decrement. Mobile shows numeric keyboard.

Nuxt

Vue.js framework like Next.js. SSR, auto-imports, file routing. Vercel equivalent.

OAuth

An authorization protocol allowing apps to access resources on behalf of the user without exposing passwords. Login with Google/GitHub uses OAuth 2.0.

Object Fit

CSS property controlling how replaced content (images, videos) fits its container. cover fills container cropping excess, contain fits entirely with letterboxing.

OG Image

The image displayed when a URL is shared on social media. Defined by og:image Open Graph tag. Optimal size: 1200x630px. Dynamic OG images generated per page.

Opacity

CSS property controlling element transparency. 0 (invisible) to 1 (fully opaque). GPU-accelerated when animated. Affects all children — use rgba() for background-only transparency.

Open Graph

Facebook's protocol for controlling how links appear on social media. og:title, og:description, og:image define a URL's preview card.

Open Graph Protocol

Metadata standard controlling how URLs appear when shared on social media. og:title, og:description, og:image tags. Essential for link preview cards.

OPFS

Origin Private File System — browser API for high-performance file storage. Faster than IndexedDB for binary data. Used by WASM apps, SQLite in browser, and file editors.

Optimistic Update

Updating the UI immediately before server confirmation, then reverting on failure. Makes apps feel instant. React Query and SWR support optimistic updates.

Overflow

CSS property handling content exceeding container bounds. overflow: hidden clips, scroll adds scrollbar, auto shows scrollbar only when needed. overflow-x and overflow-y independently.

Page Lifecycle

Browser events during page load/unload. DOMContentLoaded, load, beforeunload.

Page Load Time

Total time from navigation to fully loaded page. Measured by Load event. Core Web Vitals focus on perceived load time (LCP). Under 3 seconds for good UX.

Page Speed

How fast a web page loads and becomes interactive. Google PageSpeed Insights scores pages 0-100. Factors: server time, resource size, render-blocking resources, and images.

Page Transition API

Browser API for animated transitions between page navigations. Smooth, native-feeling transitions without JavaScript libraries. view-transition CSS property.

Page Weight

Total size of page resources. HTML, CSS, JS, images. Lighter = faster.

Pagination

Splitting large datasets into pages for display. Offset-based (page=2&limit=10) or cursor-based (after=xyz). Cursor-based is more efficient for large datasets.

Parallax

A scrolling effect where background moves slower than foreground, creating depth illusion. CSS transforms and Intersection Observer. Performance-intensive — use sparingly.

Partial Hydration

Only hydrating interactive components in a server-rendered page, leaving static parts as plain HTML. Astro Islands and React Server Components use partial hydration.

Password Input

HTML <input type='password'> masking user input. autocomplete='new-password' for registration. Show/hide toggle improves UX. Never store plaintext passwords.

Password Visibility

Toggle showing/hiding password input. Eye icon. Improves UX.

Path

The part of a URL identifying a specific resource. /blog/hello-world. URL-encoded for special characters. Express routes match paths to handlers.

Payment Request

Browser API for streamlined payments. Native UI for card and wallet.

PDF (Web)

Portable Document Format. Embed with <embed> or <iframe>. pdf.js for rendering.

Performance API

Browser API measuring detailed timing data. performance.now() for high-resolution timestamps. Performance Observer monitors metrics. Navigation Timing measures page load phases.

Performance Budget

Maximum allowed values for page weight, load time, and resource counts. Teams agree on budgets and CI fails when exceeded. Prevents performance regression.

Performance Monitoring

Tracking page speed in production. Core Web Vitals, RUM data.

Permalink

A permanent URL for a specific resource. Blog post URLs, documentation links. Should never change once published. Redirects handle URL structure changes.

Permissions API

Browser API querying permission status. Notifications, geolocation, camera.

Picture Element

HTML <picture> for responsive images with multiple sources. <source> elements with media queries and type attributes. Fallback <img> for unsupported browsers.

Pixel

The smallest unit of a digital image or display. CSS pixels may differ from device pixels. devicePixelRatio indicates the ratio. @2x images for retina displays.

Pixel Density

Physical pixels per CSS pixel. Retina = 2x. srcset for high-DPI images.

Placeholder

Hint text in form inputs shown when empty. placeholder attribute. Disappears on focus. Don't use as label substitute — labels are always visible and accessible.

Placeholder Image

Temporary image while actual loads. Blur-up, LQIP, solid color.

Platform Detection

Identifying user's OS or browser. User-Agent, feature detection preferred.

Plugin (Web)

Browser extension or site add-on. jQuery plugins, webpack plugins.

PNG

Portable Network Graphics. Lossless, supports transparency. Screenshots, icons.

Pointer Events

CSS property controlling whether an element receives mouse/touch events. pointer-events: none makes element click-through. Useful for overlay effects.

Polyfill

Code providing modern functionality in older browsers. core-js polyfills ES6+ features. Polyfill.io served targeted polyfills. Less needed as browser support improves.

Popover

A floating element appearing above page content. HTML popover attribute (native). Tooltips, dropdowns, and menus. Floating UI library handles positioning and collisions.

Popover API

Native HTML popover attribute. Browser-managed positioning and dismissal.

Popup Blocker

Browser feature preventing unwanted popups. User interaction required.

Portal

Rendering children into a different DOM location. React createPortal for modals and tooltips. Content renders in a different DOM node but behaves as part of the React tree.

Position

CSS property controlling element placement. static (default), relative, absolute, fixed, and sticky. Understanding position is fundamental to CSS layout.

Post Message

Browser API for cross-origin communication between windows/iframes. window.postMessage() sends data. Event listener receives. Secure alternative to accessing other origin's DOM.

Preconnect

Browser hint to establish early connections to important origins. <link rel='preconnect' href='https://cdn.example.com'>. Saves DNS, TCP, and TLS time for cross-origin resources.

Prefetch

Loading resources before they're needed. <link rel=prefetch> for likely next pages, dns-prefetch for external domains. Improves perceived performance for navigation.

Preflight Request

An HTTP OPTIONS request browsers send before certain cross-origin requests. Checks if the actual request is allowed. CORS headers in the preflight response grant permission.

Preload

Loading resources early. <link rel=preload>. Fonts, critical images, scripts.

Prerender

Generating static HTML at build time or on demand. Prerendered pages load instantly from CDN. Next.js ISR and Astro prerender by default.

Preview (Web)

Showing content before publishing. CMS previews, deployment previews.

Print CSS

Styles for printed pages. @media print. Hide nav, adjust fonts.

Print Stylesheet

CSS for print media. @media print hides navigation, adjusts fonts, and ensures readability. display: none for interactive elements. break-inside: avoid prevents bad page breaks.

Privacy Policy

Page describing data collection and use. Legal requirement.

Progress Bar

A UI element showing completion status. HTML <progress> element or custom styled div. Determinate (known completion) or indeterminate (unknown duration).

Progressive Enhancement

Building a base experience that works everywhere, then adding features for capable browsers. HTML first, CSS enhances, JS enriches. Opposite of graceful degradation.

Progressive Image

Image loading in stages. Blurry placeholder to full quality.

Prototyping

Creating an early version of a product to test concepts and UX. Low-fidelity (wireframes) to high-fidelity (interactive prototypes). Figma and Framer are popular.

Pseudo Class

CSS selector for element states. :hover, :focus, :first-child, :nth-child(2n), and :not(). Targets elements based on state, position, or user interaction.

Pseudo Element

CSS virtual elements for styling. ::before and ::after insert content. ::placeholder styles input placeholders. ::selection styles highlighted text. Decorative without extra HTML.

Public Directory

Static files served directly. /public folder. Images, fonts, robots.txt.

Pull to Refresh

Mobile pattern refreshing content by pulling down. Native feel.

PWA

Progressive Web App — a web app with native capabilities: offline, push notifications, device installation. Combines the best of web and native apps.

QR Code

Machine-readable matrix code. Links, payments, auth. qrcode.js generates.

Query String

The part of a URL after ? containing key-value parameters. ?page=2&sort=date. Used for search, filtering, and tracking. URLSearchParams API parses them in JS.

Radio Button

HTML input for single selection from options. <input type='radio' name='group'>. Same name groups buttons. Only one selected at a time. Fieldset and legend for grouping.

Range Input

HTML <input type='range'> for numeric slider. min, max, and step attributes. Custom styling with CSS. Used for volume, brightness, and filter controls.

Rate Limiting

Controlling the number of requests a client can make in a time window. Prevents abuse and ensures fair usage. Token bucket and sliding window are common algorithms.

React

JavaScript UI library by Meta. Components, hooks, JSX. Most popular frontend library.

React Query

Data fetching and caching library. useQuery, useMutation. TanStack Query.

React Router

Routing library for React SPAs. BrowserRouter, Route, Link.

Reactive

Automatically updating UI when data changes. Vue reactivity, signals, observables.

Readme

Documentation file. README.md in project root. Setup, usage, contribution guide.

Real-Time

Instant data delivery. WebSocket, SSE, WebRTC. Chat, notifications, collaboration.

Redirect

Sending users from one URL to another. 301 (permanent), 302 (temporary), 307 (preserve method). Used for URL changes, authentication flows, and A/B testing.

Reducer

Pure function computing new state from previous state and action. Redux reducer pattern.

Referrer Policy

HTTP header controlling how much referrer information is shared. Referrer-Policy: strict-origin-when-cross-origin is recommended. Protects user privacy from third-party tracking.

Rel Attribute

HTML attribute defining relationship between current document and linked resource. rel='stylesheet', rel='noopener', rel='nofollow'. Communicates link purpose to browsers and crawlers.

Relative URL

URL without domain, relative to current page. /about, ../images/logo.png.

Render

The process of converting code into visual output. Browser rendering (HTML/CSS to pixels), server rendering (data to HTML), and React rendering (JSX to DOM updates).

Render Blocking

Resources preventing page rendering until loaded. CSS and synchronous JS in <head> are render-blocking. Async, defer, and critical CSS strategies minimize blocking.

Repaint

Browser redrawing visual properties without layout changes. Color, visibility, and shadow changes trigger repaints. Less expensive than reflow but still impacts performance.

Resize Observer

Browser API detecting element size changes. Fires callback when observed element's dimensions change. Better than window resize event — works for any element. Responsive components.

Resource Hint

HTML directives helping browsers prioritize resource loading. preconnect, prefetch, preload, and dns-prefetch. Small additions with big performance impact.

Resource Priority

Browser heuristics and hints determining resource loading order. fetchpriority=high for critical resources. Largest Contentful Paint image should be high priority.

Response Time

The duration between sending a request and receiving the first byte (TTFB). Under 200ms for static, under 600ms for dynamic. CDNs and edge computing reduce response time.

Responsive Design

Design that adapts layout to different screen sizes (desktop, tablet, mobile). CSS media queries and frameworks like Tailwind facilitate responsive design.

Responsive Image

Image adapting to device. srcset, sizes, <picture>. Optimal size and format.

REST

Representational State Transfer — an architectural style for APIs. Stateless, resource-based URLs, standard HTTP methods. The dominant API paradigm for web services.

REST API

API following REST principles. Resources, HTTP methods, stateless. JSON responses.

Retargeting

Showing ads to people who already visited the site or interacted with the brand. Tracking pixels (Meta, Google) allow targeting warm audiences.

Rich Text Editor

WYSIWYG content editing. TipTap, ProseMirror, Slate. Format text visually.

Robots.txt

A file at the site root instructing crawlers which pages they can or cannot index. Disallow blocks, Allow permits. Not security, it's a suggestion.

Root Element

The topmost element in a document tree. <html> in web pages. CSS :root pseudo-class targets it. Custom properties on :root are globally available.

Route

URL path mapping to content/handler. /blog/:slug. File-based or config-based.

Router

Component handling URL navigation. React Router, Vue Router. Client or server routing.

Routing

Mapping URLs to pages/handlers. File-based (Next.js) or declarative (Express).

RSS

Really Simple Syndication — XML format for content feeds. Blogs, podcasts, and news sites publish RSS feeds. Feed readers (Feedly, Miniflux) aggregate subscriptions.

RTL

Right-to-Left text direction for Arabic, Hebrew, and Persian. dir='rtl' attribute. CSS logical properties handle RTL automatically. unicode-bidi and direction properties.

Safe Area

The visible area of a screen excluding notches, rounded corners, and home indicators. env(safe-area-inset-top) CSS function. Essential for modern mobile web design.

Sales Funnel

A model representing the customer journey: awareness → interest → decision → action. Each stage has metrics and optimization strategies.

Same Site Cookie

Cookie attribute controlling cross-site sending. SameSite=Strict (never cross-site), Lax (safe methods only), None (always with Secure). CSRF protection mechanism.

Same-Origin Policy

A browser security policy restricting requests to different domains. CORS is the mechanism to relax this policy when needed.

Sandbox Attribute

HTML attribute restricting iframe capabilities. sandbox='allow-scripts allow-same-origin'. Blocks forms, popups, and navigation by default. Defense against malicious embedded content.

SASS

Syntactically Awesome Style Sheets — a CSS preprocessor adding variables, nesting, mixins, and functions. Compiles to standard CSS. Less needed with CSS variables and nesting.

Sass

CSS preprocessor. Variables, nesting, mixins, functions. Compiles to CSS.

Schema Markup

Structured data (JSON-LD) helping search engines understand content. Rich snippets, FAQs, reviews, and events on Google result from Schema.

Schema Validation

Verifying data conforms to a defined structure. JSON Schema, Zod, and Yup. API request/response validation. Form validation. Database schema enforcement.

Scope (CSS)

The CSS @scope rule limiting style application to a subtree. Scoped styles don't leak to unrelated elements. Native CSS alternative to CSS Modules and styled-components.

Scope (Web)

Where variables/styles are accessible. CSS scope, JS scope, component scope.

Screen Reader

Assistive technology reading screen content aloud. VoiceOver, NVDA, JAWS.

Script Element

HTML <script> for JavaScript. src for external, inline for embedded. async, defer.

Scroll Behavior

CSS property controlling scroll animation. scroll-behavior: smooth enables animated scrolling. JavaScript scrollIntoView({ behavior: 'smooth' }) for element-specific scrolling.

Scroll Event

JavaScript event fired during scrolling. Performance sensitive. Passive option.

Scroll Performance

Maintaining 60fps during page scrolling. Heavy paint operations, layout thrashing, and event handlers can cause jank. passive event listeners and will-change CSS help.

Scroll Snap

CSS feature for controlled scrolling positions. scroll-snap-type: x mandatory snaps to items. Used for carousels, image galleries, and paginated content. Native, no JS needed.

Search Engine

System indexing and searching web content. Google, Bing, DuckDuckGo.

Search Engine Optimization

SEO — improving search visibility. Content, technical, links.

Search Input

HTML <input type='search'> with built-in clear button. Semantically represents search fields. Mobile keyboards show search button. screen readers announce as search field.

Section Element

HTML <section> for thematic grouping of content. Should have a heading. Multiple sections per page. More specific than <div>. Improves document outline and accessibility.

Security Header

HTTP headers improving security. CSP, HSTS, X-Frame-Options.

Select Element

HTML <select> for dropdown selection. <option> elements define choices. optgroup for grouping. Custom selects with Radix or Headless UI for styling flexibility.

Self-Closing Tag

HTML tags not requiring a closing tag. <img />, <br />, <input />, and <meta />. In HTML5, the slash is optional: <img> is valid. Required in JSX/React.

Semantic Versioning

SemVer — version numbering: MAJOR.MINOR.PATCH. Major = breaking changes, minor = new features, patch = bug fixes. npm, cargo, and most package managers follow SemVer.

SEO

Search Engine Optimization — practices to improve visibility in search engines. Includes content, meta tags, speed, mobile-friendly, and backlinks.

Server

A computer or software providing services to other computers (clients). Web servers (Nginx, Caddy), database servers (PostgreSQL), email servers, etc.

Server Action

Next.js function executing on server from form.

Server Component

React components rendering only on the server. Zero client-side JavaScript. Access databases and APIs directly. Next.js App Router uses Server Components by default.

Server-Sent Events

SSE — a one-way streaming protocol from server to client over HTTP. EventSource API. Simpler than WebSocket for server-push scenarios like notifications and live feeds.

Service Worker

A script running in the browser background, independent of the page. Intercepts requests, enables offline, push notifications, and caching. The foundation of PWAs.

Session

Period of user activity. Session storage, server sessions, session cookies.

Shadow DOM

Browser API encapsulating a component's DOM and styles from the rest of the page. Web Components use Shadow DOM for style isolation. No CSS leaking in or out.

Single Page Application

SPA — loads once, dynamic updates. React, Vue. No page reloads.

Single Sign-On

SSO lets you authenticate once and access multiple applications. SAML and OIDC are protocols. Authelia, Keycloak, and Auth0 implement SSO.

Sitemap

An XML file listing all pages of a site for search engines. Helps crawlers discover and index content efficiently.

Skeleton Loading

Placeholder UI showing layout while content loads. Better than spinners.

Skeleton Screen

A placeholder UI showing the layout structure while content loads. Gray boxes mimicking the final layout. Better UX than spinners. Used by Facebook, YouTube, LinkedIn.

Skip Link

A hidden link becoming visible on focus, allowing keyboard users to skip navigation and jump to main content. <a href='#main'>Skip to content</a>. Essential accessibility feature.

Slot

A placeholder in a component for inserting content. Web Components <slot>, Vue <slot>, and React children prop. Enables flexible, composable component APIs.

Slug

URL-friendly string. my-blog-post from My Blog Post. Lowercase, hyphens.

Smooth Scroll

Animated scrolling between page sections. CSS scroll-behavior: smooth or JavaScript scrollIntoView. Improves UX for anchor links and back-to-top buttons.

SMTP

Simple Mail Transfer Protocol — the standard for sending email. Port 25 (relay), 587 (submission). Sendgrid, Resend, and AWS SES are modern SMTP services for apps.

Snap Scroll

CSS scroll-snap-type creating pagination-like scroll behavior. Items snap to defined positions. Horizontal carousels, vertical page sections, and image galleries.

Snapshot Testing

Comparing rendered output against saved snapshot. Jest, Vitest.

Social Meta Tags

HTML meta tags for social media sharing previews. Open Graph (og:) for Facebook/LinkedIn, Twitter Cards (twitter:) for X. Image, title, and description.

Social Sharing

Buttons/links for sharing on social media. Share API, platform-specific URLs.

Source Element

HTML <source> providing multiple media resources. Inside <picture> for images, <video> for video, and <audio> for audio. Browser selects the best supported format.

Source Map

A file mapping minified/compiled code back to original source. Enables debugging production code in browser DevTools. Generated by bundlers. Keep private in production.

SPA

Single Page Application — loads once and dynamically updates content without full page reloads. React, Vue, and Angular build SPAs. Fast navigation but SEO challenges.

SPA Router

Client-side routing in Single Page Apps. Intercepts navigation, renders components.

Spacer

An element creating empty space between content. CSS gap, margin, and padding are preferred. Utility classes like .mt-4 in Tailwind. Avoid empty divs as spacers.

Speed Index

Metric measuring how quickly page content is visually displayed.

Spinner

A loading indicator showing indeterminate progress. CSS animation rotating an element. Used while waiting for data. Skeleton screens are often better UX than spinners.

Sprite

A single image containing multiple icons or graphics. CSS background-position shows specific regions. Reduces HTTP requests. SVG sprites using <symbol> and <use> are modern.

Srcset

HTML attribute providing multiple image sources for different screen densities. srcset='img-1x.jpg 1x, img-2x.jpg 2x'. Browser selects appropriate image. Responsive images.

SRI

Subresource Integrity — verifying CDN resources haven't been tampered with. The integrity attribute contains a hash. Browsers reject resources not matching the hash.

SSG

Static Site Generation — HTML generated at build time. Fastest and most secure. Astro, Hugo, and 11ty are static generators. Ideal for blogs and docs.

SSL Certificate

A digital certificate enabling HTTPS. Issued by Certificate Authorities. Let's Encrypt provides free certificates. Contains public key and domain verification.

SSL/TLS

Secure Sockets Layer / Transport Layer Security — encryption protocol for secure internet communication. SSL certificates are issued by CAs like Let's Encrypt.

SSR

Server-Side Rendering — HTML generated on the server per request. Better SEO and First Contentful Paint. Next.js, Nuxt, and SvelteKit support SSR.

State (Web)

Current data values in application. Component state, URL state, server state.

State Management (Web)

Managing app data flow. Redux, Zustand, Signals, Context API.

Static Analysis

Analyzing code without executing it to find bugs, security issues, and style problems. ESLint, TypeScript compiler, and SonarQube perform static analysis.

Static File

Unchanging file served as-is. HTML, CSS, JS, images. CDN cacheable.

Static Site

Pre-built HTML pages. No server rendering. Astro, Hugo, Jekyll. Fast and secure.

Static Site Generator

SSG tool building HTML at build time. Astro, Next.js, Hugo.

Status Code

HTTP response codes indicating result. 200 OK, 301 redirect, 404 not found, 500 server error. 2xx success, 3xx redirect, 4xx client error, 5xx server error.

Sticky Position

CSS position: sticky — element becomes fixed when reaching a scroll threshold. Sticky headers, sidebar navigation. Combines relative and fixed positioning behavior.

Storage Event

JavaScript event fired when localStorage changes in another tab. Enables cross-tab communication. Same-origin only. Used for login/logout synchronization.

Streaming (Web)

Sending response incrementally. React streaming SSR. Chunked transfer.

Streaming SSR

Server sends HTML chunks as they're generated, not waiting for the complete page. Users see content progressively. React 18 Suspense and streaming support this.

Style Guide

Documentation of design and code conventions. Colors, typography, components.

Style Tag

HTML <style> element for inline CSS within the document. Used for critical CSS and component-scoped styles. External stylesheets preferred for cacheability.

Styled Components

CSS-in-JS library. Tagged template literals for scoped styles.

Subgrid

CSS Grid feature where a child grid inherits parent grid tracks. Enables aligned layouts across nested grid containers. Supported in all modern browsers.

Submit Event

JavaScript event fired when a form is submitted. event.preventDefault() stops default submission. Enables custom validation and AJAX submission. Works with Enter key.

Suspense

React component for loading states. Wraps async children. Shows fallback.

SvelteKit

Svelte framework with SSR, routing. Vite-based. Alternative to Next.js.

SVG

Scalable Vector Graphics — XML-based vector image format. Scales without quality loss. Inline SVG enables CSS styling and animation. Icons, logos, and illustrations.

SVG Animation

Animating SVG elements with CSS or SMIL. CSS transforms, transitions, and keyframes work on SVG. Libraries like GSAP add advanced SVG animation capabilities.

Syntax Highlighting

Coloring code by token type. Keywords, strings, comments. Shiki, Prism.

Tab Bar

Mobile navigation at screen bottom. iOS tab bar, Android bottom navigation.

Tab Index

HTML attribute controlling keyboard focus order. tabindex='0' adds to natural order. tabindex='-1' allows programmatic focus only. Avoid positive tabindex values.

Table Element

HTML <table> for tabular data. <thead>, <tbody>, <tr>, <td>, <th>. Responsive tables with overflow-x: auto. Don't use tables for layout — use CSS Grid/Flexbox.

Tag (HTML)

HTML element marker. <div>, </div>, <img />. Opening, closing, self-closing.

Tailwind CSS

Utility-first CSS framework with pre-defined classes. Rapid development, consistent design, small production builds via purging. The most popular CSS framework today.

Template Literal

JavaScript string with backticks allowing expressions and multi-line. `Hello ${name}`. Tagged templates (html`...`) enable custom processing. Used in CSS-in-JS and GraphQL queries.

Test (Web)

Verifying web application works correctly. Unit, integration, E2E tests.

Testing Library

Framework for testing. React Testing Library, Vitest, Playwright.

Text Direction

Reading direction of text. LTR or RTL. dir attribute, CSS direction.

Text Overflow

CSS property handling text exceeding container width. text-overflow: ellipsis shows ... for clipped text. Requires overflow: hidden and white-space: nowrap.

Textarea

HTML <textarea> for multi-line text input. rows and cols attributes for initial size. resize CSS property controls resizability. Auto-growing textareas improve UX.

Theme

A visual customization of a website or app. Light/dark themes, brand themes. CSS custom properties enable dynamic theming. prefers-color-scheme detects system preference.

Theme Switching

Toggling between visual themes. Light/dark mode. CSS custom properties.

Third Party Script

External JavaScript loaded on page. Analytics, ads, widgets. Performance impact.

Throttle

Limits function execution to once per time interval, regardless of how often it's triggered. Used for scroll and resize events. Ensures consistent performance.

Thumbnail

Small preview image. Grid displays, search results. Optimized for size.

Time Element

HTML <time> with machine-readable datetime attribute. <time datetime='2024-01-15'>January 15</time>. Helps search engines understand dates. Used for articles, events, and schedules.

Time Picker

UI for selecting times. <input type=time> or custom.

Title Tag

HTML <title> in <head> defining page title. Displayed in browser tabs and search results. Under 60 characters. Unique per page. Critical for SEO and user navigation.

Toast Message

Brief non-blocking notification. Success, error, info. Auto-dismisses.

Toast Notification

A brief, non-blocking message appearing temporarily on screen. Success, error, info, and warning types. Auto-dismisses after a few seconds. react-hot-toast is popular.

Toggle

A UI control switching between two states. On/off switches, theme toggles, and expandable sections. Accessible: use <button> with aria-pressed or checkbox with switch role.

Token (Web)

Authentication credential. JWT, session token, API key.

Toolbar

UI bar with action buttons. Text formatting, navigation, filters.

Tooltip (Detail)

A small overlay showing additional information on hover/focus. CSS-only tooltips or JavaScript libraries. Must be accessible: keyboard-triggerable, screen reader-announced.

Touch Event

JavaScript events for touch interactions. touchstart, touchmove, and touchend. Pointer Events API unifies touch, mouse, and pen input. Used for gestures and swipe handling.

Tracking

Monitoring user behavior. Analytics, session recording. Privacy considerations.

Transition

CSS animated change between property values. transition: all 0.3s ease. Individual properties: transition: opacity 0.2s, transform 0.3s. GPU-accelerated for transform and opacity.

Tree Shaking

Eliminating unused code during build. Import only what you use and the bundler removes the rest. Vite and Rollup do tree shaking automatically.

Truncate

Cutting text to fit. text-overflow: ellipsis. Single-line or multi-line.

TTL

Time to Live — how long a cached resource remains valid. DNS TTL, CDN TTL, and cache headers. Short TTL = fresh content; long TTL = better performance.

Turbo

Hotwire library for SPA-like speed with HTML.

Typeface

A family of fonts with shared design. Roboto, Inter, and Geist are typefaces. Font is a specific weight/style within a typeface. Web fonts loaded via @font-face or Google Fonts.

TypeScript (Web)

Typed JavaScript for web development. Catches errors early. Industry standard.

TypeScript Strict

TypeScript's strict mode enabling all strict type-checking options. noImplicitAny, strictNullChecks, and more. Catches more bugs at compile time.

Typography

The art of text presentation. Font selection, sizing, spacing, and hierarchy. Good typography improves readability and aesthetics. CSS: font-size, line-height, letter-spacing.

UI

User Interface — visual elements users interact with: buttons, forms, menus, colors, typography. Design systems like Tailwind and shadcn/ui standardize UI.

UI Component

Self-contained visual building block. Button, card, modal, table.

UI Framework

Pre-built component set. React, Vue, Angular, Svelte.

Uncontrolled Component

Form element managing own state via DOM. useRef to access values.

Unit Test

Testing individual function/component. Vitest, Jest. Fast, isolated.

URL

Uniform Resource Locator — the complete address of a web resource. Includes protocol (https://), domain, path, and query parameters.

URL Encoding

Converting special characters to percent-encoded format. Spaces become %20, & becomes %26. encodeURIComponent() in JavaScript. Required for query parameters with special characters.

User Agent

String identifying browser/device. Request header. Feature detection preferred.

UX

User Experience — how a user feels when using a product. Involves research, usability, accessibility, and interaction design.

Validation

Checking data meets requirements. Client and server side. Zod, Yup.

Variable Font

Single font file with adjustable weight, width, slant. Reduces file count.

Version (Web)

Release identifier. SemVer for packages. URL versioning for APIs.

Video Element

HTML <video> for embedding video. Controls, poster, multiple sources.

View Transition

CSS API for animated page transitions.

Viewport

The visible area of a web page in the browser. <meta name=viewport> controls mobile rendering. Viewport units (vw, vh, dvh) size elements relative to the viewport.

Virtual DOM

An in-memory representation of the real DOM. React diffs the virtual DOM with the previous version and applies minimal real DOM updates. Improves rendering performance.

Virtual Scroll

Rendering only visible list items. Handles millions of rows. TanStack Virtual.

Visibility

CSS property controlling element visibility. visibility: hidden hides but maintains space (unlike display: none). Content hidden from screen readers when combined with aria-hidden.

Visual Regression

Unintended visual changes in the UI. Detected by screenshot comparison testing. Percy, Chromatic, and Playwright visual comparisons. Catches CSS side effects.

Vite (Build Tool)

Next-generation build tool. Dev server with native ES modules (instant start) and Rollup-based builds. Created by Evan You (Vue). The new standard.

Vue.js

Progressive JavaScript framework. Reactivity, single-file components, Composition API.

WAI-ARIA

W3C accessibility standard. Roles, states, properties for dynamic content.

Web Accessibility

A11y — inclusive design for people with disabilities. WCAG defines standards. Semantic HTML, alt text, keyboard nav, and screen readers are fundamental.

Web Animation API

JavaScript API for performant animations. Complements CSS animations with dynamic control: play, pause, reverse, and timing manipulation. animate() method on elements.

Web API

Browser-provided JavaScript APIs. DOM, Fetch, Canvas, Geolocation, Storage.

Web App

An application running in the browser without installation. Gmail, Figma, and Notion are web apps. Technologies: React, Vue, Svelte.

Web Assembly

WASM — binary format running near-native speed in browser. C/Rust compiled.

Web Component

Custom reusable HTML element. Shadow DOM, Custom Elements. Framework-agnostic.

Web Components

Browser-native custom elements with encapsulated HTML, CSS, and JS. Shadow DOM, Custom Elements, and HTML Templates. Framework-agnostic, work everywhere.

Web Font

A font file loaded by the browser for rendering text. WOFF2 format for best compression. Hosted or from services like Google Fonts. font-display controls loading behavior.

Web Framework

Tool for building web apps. Next.js, Nuxt, SvelteKit, Remix, Astro.

Web Manifest

A JSON file describing a Progressive Web App. name, icons, start_url, display, and theme_color. Required for PWA installation. <link rel='manifest' href='manifest.json'>.

Web Performance

The discipline of optimizing web speed. Includes code splitting, compression, caching, lazy loading, and image optimization. Measured by Lighthouse and WebPageTest.

Web Scraping

Extracting data from websites programmatically. Beautiful Soup (Python), Puppeteer (JS), and Playwright. Respect robots.txt and rate limits. Legal gray area varies.

Web Security

Protecting web apps. HTTPS, CSP, CORS, input validation, auth.

Web Server

Software serving HTTP responses. Nginx, Caddy, Apache. Static files and proxying.

Web Socket

A persistent bidirectional communication channel between browser and server. Full-duplex — both can send anytime. Used for real-time features: chat, live updates, gaming.

Web Storage

Browser APIs for client-side storage. localStorage persists across sessions. sessionStorage clears on tab close. Both store key-value string pairs. 5-10MB limit.

Web Stream

Streaming API. ReadableStream, WritableStream.

Web Vitals

Google's metrics for web page quality. Core Web Vitals (LCP, INP, CLS) affect search ranking. Measured via Chrome UX Report and PageSpeed Insights.

Web Worker

JavaScript running in a background thread. Heavy computations without blocking UI. Communicate via postMessage. SharedWorker shares across tabs. Service Worker for offline/caching.

WebAssembly

A binary format enabling C, C++, Rust code to run in the browser at near-native speed. Used in games, editors, and heavy processing on the web.

WebGL

Web Graphics Library — JavaScript API for rendering 2D and 3D graphics in browsers using GPU. Three.js and Babylon.js abstract WebGL. Powers web-based games and visualizations.

WebP

Image format by Google offering 25-35% smaller files than JPEG at equivalent quality. Supports transparency and animation. Universally supported by modern browsers.

Webpack

Pioneering module bundler in the JavaScript ecosystem. Loaders, plugins, and code splitting. Being replaced by Vite in new projects for being slower.

WebRTC

Web Real-Time Communication — browser API for peer-to-peer audio, video, and data. No plugins needed. Powers video calls (Google Meet), screen sharing, and P2P file transfer.

WebSocket

A bidirectional real-time communication protocol between browser and server. Used in chats, games, live dashboards, and real-time collaboration.

WebTransport

Modern transport API. HTTP/3 based. Bidirectional.

White Space (CSS)

CSS white-space property. nowrap, pre-wrap. Controls wrapping and whitespace.

Whitespace

Empty space in design and code. Visual whitespace improves readability and aesthetics. Code whitespace (indentation, blank lines) improves code readability. CSS white-space controls wrapping.

Widget

A self-contained UI component. Calendar widgets, weather widgets, and embedded chat widgets. HTML Web Components or JavaScript widgets embedded via script tags.

Window Object

The global JavaScript object in browsers representing the browser window. Contains document, location, history, localStorage, and all global variables and functions.

Wireframe

A low-fidelity visual skeleton of an interface. Defines layout, hierarchy, and flow without visual design. The first step in interface design.

Wizard

Multi-step form guiding users through process. Progress indicator, next/back.

Worker Thread

Background threads in web and Node.js. Web Workers for CPU-intensive browser tasks, Worker Threads for Node.js parallelism. Communicate via message passing.

WYSIWYG

What You See Is What You Get. Rich text editors showing formatted output.

XML

eXtensible Markup Language — a structured data format with tags. Predecessor to JSON. Still used in RSS feeds, SOAP APIs, and configuration.

YAML

Human-readable data format. Key: value pairs. Config files, CI/CD, K8s.

Z-Index

CSS property controlling element stacking order. Higher z-index appears on top. Only works with positioned elements. Stacking contexts create isolated z-index groups.

Zod

A TypeScript-first schema validation library. Define schemas, infer types, validate data. Popular for form validation, API responses, and environment variables.

Active-Active

Deployment where all nodes handle traffic simultaneously. No idle standby.

Active-Passive

Standby nodes activate only when primary fails. Simpler than active-active.

Admission Controller

K8s webhook validating or mutating resources on create.

Affinity

Scheduling preference for placing workloads on specific nodes. Node affinity and pod affinity in Kubernetes. Ensures pods run near related services or on preferred hardware.

Affinity Rule

Scheduling preference for placing workloads together.

Air-Gapped Cluster

K8s cluster without internet access for security.

Air-Gapped Network

Network physically isolated from internet. Maximum security for sensitive systems.

Alert Manager

Prometheus component routing alerts to Slack, PagerDuty based on severity.

Allocation

Reserving compute resources. CPU/memory in K8s. Over-allocation wastes, under-allocation throttles.

Amazon EKS

AWS managed Kubernetes. Handles control plane. Integrates IAM, VPC, ALB.

Amazon RDS

AWS managed database. PostgreSQL, MySQL, Aurora. Automated backups and patching.

Ambassador Pattern

Sidecar handling network communication for main container.

Ansible (Tool)

Agentless IT automation using YAML playbooks. No software needed on managed servers — just SSH. Idempotent: running twice gives the same result.

Anti-Affinity

Scheduling constraint spreading workloads across nodes.

Apache

Pioneering open-source web server (1995). .htaccess for per-directory config. Lost share to Nginx but still widely used, especially with PHP.

API Gateway

A single entry point for multiple APIs. Rate limiting, authentication, routing, and request transformation. Kong, AWS API Gateway, and Traefik.

API Rate Limiting

Controlling API request frequency. Token bucket, sliding window algorithms.

API Server

K8s central component processing REST operations.

Application Gateway

Cloud L7 load balancer with WAF capabilities.

Application Load Balancer

Layer 7 LB routing by HTTP content. Path, headers, host-based routing.

Argo Workflows

A Kubernetes-native workflow engine for complex job orchestration. DAG-based pipelines for CI/CD, ML training, and data processing. Each step runs in a container.

Artifact Registry

Storing container images, packages, Helm charts.

Auto Discovery

Automatically finding services and resources. Service mesh, monitoring.

Auto Healing

System automatically recovering from failures. K8s restarts crashed pods.

Auto Recovery

Cloud instances automatically restarting on hardware failure.

Auto Scaling

Automatic resource adjustment based on load. Horizontal (more instances) or vertical (more CPU/RAM). K8s HPA and cloud auto-scaling groups.

Auto Scaling Group

AWS resource managing instance count automatically.

Availability Set

Azure grouping VMs across fault and update domains.

Availability Zone

Physically separate data center within cloud region. Multi-AZ survives facility failures.

Azure

Microsoft's cloud platform. Second largest. Strong enterprise integration. AKS, Cosmos DB.

Backend Pool

Group of servers behind a load balancer.

Backup

A safety copy of data for recovery in case of loss. 3-2-1 strategy: 3 copies, 2 different media, 1 offsite. Restic and Borg are popular tools.

Backup Strategy

Data protection plan. 3-2-1: 3 copies, 2 media, 1 offsite. RTO and RPO define frequency.

Bare Metal

Physical servers without virtualization. Maximum performance, no hypervisor overhead. Hetzner and OVH offer bare metal. Used for databases, HPC, and latency-sensitive workloads.

Bare Metal Server

Physical server without virtualization layer.

Bastion Host

A hardened server as the single entry point to a private network. SSH jump host for accessing internal servers. Reduces attack surface. Also called jump box.

Batch Job

One-time workload running to completion. K8s Job.

BGP

Border Gateway Protocol — internet routing protocol. Determines packet paths across networks.

Binary Authorization

Requiring signed images for deployment. Supply chain.

Binary Log

Database log of data changes. MySQL binlog. Replication and point-in-time recovery.

Block Storage

Storage as raw disk volumes. EBS, Persistent Disks. Single instance attachment. Fast for databases.

Blue-Green (Infra)

Two identical environments for zero-downtime deployment.

Blue-Green Deployment

Maintaining two identical environments (blue and green). Deploy to the inactive one, test, and switch traffic. Instant rollback — just switch back.

Boot Time

Time to operational state. VMs minutes, containers seconds, serverless milliseconds.

Buildpack

Auto-detect and build apps without Dockerfiles. Heroku, Cloud Native Buildpacks.

Bulkhead Pattern

Isolating components so failure doesn't cascade. Like ship bulkheads preventing flooding.

Burst Capacity

Temporary resource increase beyond baseline.

Cache Layer

Intermediate store for frequent data. Redis between app and DB. Reduces response time.

Cache Warming

Pre-loading cache with expected data. After deployment or cache clear.

Canary Deployment

Releasing a new version to a small percentage of users before full rollout. Detects problems early with minimal impact. Flagger and ArgoCD automate this.

Canary Release

Gradual rollout to detect issues. 1%, 5%, 25%, 100%. Monitor at each stage.

Capacity

Maximum workload a system handles. CPU, memory, bandwidth, IOPS.

Capacity Reservation

Pre-reserving compute capacity for future needs.

Cattle vs Pets

A DevOps philosophy: servers should be cattle (identical, replaceable) not pets (unique, irreplaceable). Containers and IaC enable treating infrastructure as cattle.

CD Pipeline

Automated deployment to staging or production environments.

CDK

Cloud Development Kit — defining cloud infrastructure using programming languages (TypeScript, Python, Go) instead of YAML/JSON. AWS CDK and Pulumi CDK are popular.

Cert Manager

A Kubernetes add-on automating TLS certificate management. Integrates with Let's Encrypt for automatic certificate issuance and renewal. Essential for HTTPS in K8s.

Certificate Manager

Automating TLS certificate lifecycle.

Certificate Renewal

Replacing expiring TLS certs. cert-manager automates. Expired certs cause outages.

Change Management

Process controlling infrastructure changes. Approvals, change windows, rollback plans.

Chaos Engineering

Injecting failures to test resilience. Netflix Chaos Monkey, Litmus, Gremlin.

Chroot

Unix operation changing apparent root directory. Early container-like isolation.

CI Pipeline

Automated build and test on code commit. GitHub Actions, GitLab CI.

CI/CD

Continuous Integration / Continuous Delivery — automation of build, test, and deployment. GitHub Actions, GitLab CI, and Jenkins are popular pipelines.

Circuit Breaker

A pattern preventing cascading failures. When a service fails repeatedly, the circuit 'opens' and returns errors immediately instead of waiting. Prevents system-wide outages.

Circuit Breaking (Infra)

Stopping cascading failures between services.

Cloud Access

Methods for accessing cloud resources. Console, CLI, SDK, API.

Cloud Armor

GCP web application firewall and DDoS protection.

Cloud Billing

Tracking and managing cloud costs. Budgets, alerts, cost allocation tags.

Cloud Burst

Extending on-premises to public cloud during demand spikes. Hybrid cloud strategy.

Cloud CDN

Cloud-native content delivery. CloudFront, Cloud CDN.

Cloud Computing

Delivery of computing resources (servers, storage, databases) over the internet on demand. AWS, Azure, and GCP dominate the market.

Cloud Console

Web UI for managing cloud resources. AWS Console, GCP Console, Azure Portal.

Cloud Cost Optimization

Strategies reducing cloud spend: right-sizing, reserved instances, spot instances, and auto-scaling. Kubecost and Infracost track costs. Typical savings of 30-50%.

Cloud DNS

Managed DNS service. Route53, Cloud DNS.

Cloud Endpoint

API management and gateway service.

Cloud Formation

AWS IaC service using JSON/YAML templates.

Cloud Foundry

Open-source PaaS. cf push deploys. Alternative to K8s for simpler deployments.

Cloud Function

Serverless function triggered by events. Lambda, Cloud Functions, Cloudflare Workers.

Cloud IAM

Identity and Access Management. Users, roles, policies. Least privilege.

Cloud Init

System for initializing cloud instances on first boot. User data scripts.

Cloud Interconnect

Dedicated connection between on-prem and cloud.

Cloud Key Management

Managing encryption keys. AWS KMS, GCP KMS. Rotate, audit.

Cloud Load Balancer

Managed traffic distribution service.

Cloud Logging

Centralized log collection. CloudWatch Logs, Cloud Logging, Azure Monitor.

Cloud Marketplace

Pre-configured software from vendors. AWS Marketplace, GCP Marketplace.

Cloud Migration

Moving from on-prem to cloud. Lift-and-shift, re-platform, or re-architect.

Cloud Monitoring

Tracking cloud resource health. CloudWatch, Cloud Monitoring. Alerts.

Cloud NAT

Managed NAT gateway for private instance internet access.

Cloud Native

An approach to building applications that leverage cloud advantages: containers, microservices, CI/CD, and dynamic infrastructure. CNCF defines the ecosystem.

Cloud Network

Virtual networking in cloud. VPC, subnets, routing, peering. Software-defined.

Cloud Provider

Company offering cloud services. AWS, Azure, GCP, DigitalOcean, Hetzner.

Cloud Run

GCP serverless container platform. Deploy containers without managing servers.

Cloud Scheduler

Managed cron job service. Triggers functions or HTTP.

Cloud Security Posture

CSPM — monitoring cloud configuration for misconfigurations.

Cloud Shell

Browser-based terminal in cloud providers. Pre-installed tools. Instant access.

Cloud Spending

Money spent on cloud services. Often exceeds budget. Optimization important.

Cloud SQL

Managed relational database service. PostgreSQL, MySQL.

Cloud Storage

On-demand internet-accessible storage. Object (S3), block (EBS), file (EFS).

Cloud Tasks

Distributed task queue for async work execution.

Cloud Template

Reusable infrastructure definition. CloudFormation, ARM templates, Terraform modules.

Cloud Trace

Distributed tracing service for latency analysis.

Cloud VPN

VPN connecting on-premises to cloud. Site-to-site, client VPN.

Cluster Autoscaler

Automatically adjusts the number of nodes in a Kubernetes cluster based on pending pods. Scales up when pods can't be scheduled, scales down when nodes are underutilized.

Cluster DNS

Internal DNS for K8s service discovery. CoreDNS.

Cluster Federation

Managing multiple K8s clusters as one.

Cluster IP

K8s service accessible only within cluster. Default type. Internal load balancing.

Cluster Management

Managing groups of servers. Scheduling, scaling, monitoring, upgrading.

Cluster Upgrade

Updating K8s version across control and data planes.

CNAME

DNS record mapping domain to domain. www → apex. Used for CDN and SaaS custom domains.

Cold Start

Delay when a serverless function runs for the first time or after idle. Provisioning the execution environment takes 100ms-several seconds. Keep-alive and provisioned concurrency reduce it.

Cold Storage (Cloud)

Cheapest storage tier for rarely accessed data. Glacier, Archive.

Compose File

A YAML file (docker-compose.yml) defining multi-container applications. Services, networks, volumes, and environment variables in one declarative file.

Compute Instance

Virtual cloud server. EC2, Compute Engine, Droplet. On-demand or reserved pricing.

Compute Optimizer

Recommendation engine for right-sizing resources.

Config Connector

Managing cloud resources via K8s manifests.

Config Management

Consistent configuration across servers. Ansible, Chef, Puppet. Idempotent operations.

Config Map

K8s resource for non-sensitive configuration data.

ConfigMap

A Kubernetes object storing non-sensitive configuration as key-value pairs. Injected into pods as environment variables or mounted as files. Separates config from code.

Connection Draining

Completing in-flight requests before removing server. Prevents dropped connections.

Connection Pooling

Reusing database connections. PgBouncer, HikariCP. Reduces overhead.

Consul

HashiCorp service discovery and config. Health checking, KV store. Multi-datacenter.

Container Image

Read-only template for containers. Dockerfiles, layers, registries. Base images.

Container Networking

How containers communicate. Bridge, overlay, host networking. CNI plugins: Calico, Cilium.

Container Orchestration

Managing container lifecycle. Kubernetes, Docker Swarm, Nomad.

Container Registry

A repository for storing and distributing container images. Docker Hub, GitHub Container Registry, and AWS ECR. Private registries for proprietary images.

Container Runtime

Software executing containers. containerd and CRI-O are Kubernetes container runtimes. Docker uses containerd internally. OCI standard ensures compatibility.

Container Security

Securing containers. Image scanning, runtime protection, least privilege.

Containerization

Packaging applications with dependencies in isolated containers. Docker is the standard. Containers share the host kernel, making them lighter than VMs.

Content Delivery

Distributing content via geo-distributed servers. CDNs cache at edge.

Control Loop

K8s reconciliation cycle comparing desired vs actual state.

Control Plane

The brain of a Kubernetes cluster managing state: API server, scheduler, controller manager, and etcd. Worker nodes communicate with the control plane.

Copy-on-Write (Storage)

Writes create new copies, not modify originals. Docker layers, ZFS snapshots.

CoreDNS

The default DNS server in Kubernetes. Resolves service names to cluster IPs. Plugin-based architecture. Handles service discovery within the cluster.

Cost Allocation

Tagging resources to track costs by team, project, environment.

Cost Explorer

Tool analyzing cloud spending. AWS Cost Explorer, GCP Cost Management.

Cost Management

Tools and practices for controlling cloud spending.

cPanel

Web hosting control panel. Domains, email, databases. Popular with shared hosting.

CPU Credit

Burstable instance pricing. Earn credits at baseline, spend on burst. AWS T-series.

CPU Throttling

Reducing speed for heat or resource limits. K8s CPU limits throttle pods.

CRD

Custom Resource Definition — extending Kubernetes API with custom object types. Operators use CRDs to manage complex applications (databases, message queues) as native K8s objects.

Cron Expression

Syntax defining scheduled times. '0 */6 * * *' = every 6 hours. Five fields.

Cron Job (K8s)

K8s scheduled recurring task. Same as Unix cron.

CronJob (K8s)

A Kubernetes resource running jobs on a schedule (cron syntax). Database backups, report generation, and cleanup tasks. Creates a new pod for each execution.

Cross-Account

Accessing resources across cloud accounts. IAM roles, resource policies.

Cross-Region

Resources across multiple regions. Replication for DR. Adds latency, improves availability.

Custom Controller

K8s controller implementing custom reconciliation logic.

Custom Metric

App-specific measurements beyond system metrics. Business KPIs, queue depth.

Custom Resource

K8s API extension for domain-specific objects.

DaemonSet

A Kubernetes resource ensuring a pod runs on every node. Used for logging agents, monitoring, and network plugins. Automatically adds pods to new nodes.

Data Center

A physical facility housing servers, storage, and networking equipment. Hetzner, Equinix, and AWS operate global data centers.

Data Disk

Secondary storage volume for data separate from boot.

Data Locality

Processing data near its storage. Reduces network transfer. Edge computing.

Data Plane

The component handling actual traffic/data flow, as opposed to the control plane. In service mesh, Envoy sidecars are the data plane processing requests.

Data Replication

Copying data across nodes. Synchronous (strong consistency) or async (eventual).

Data Retention

Policies for how long data is stored. Compliance, costs, operational needs.

Data Sovereignty

Legal requirement keeping data within geographic boundaries. Cloud regions address this.

Data Transfer

Moving data between regions or providers. Egress costs.

DDoS Protection

Defending against distributed denial of service. CloudFlare, AWS Shield.

Declarative Config

Specifying desired state, not steps. K8s manifests, Terraform. System reconciles.

Dedicated Host

Physical server exclusively for one customer. Compliance.

Deployment Automation

Scripted deployment processes. Terraform, Ansible, CI/CD pipelines.

Deployment Controller

K8s controller managing ReplicaSets for deployments.

Deployment Manifest

File describing how to deploy. K8s Deployment YAML, Docker Compose.

Deployment Slot

Azure feature for staging deployments. Swap between slots for zero downtime.

Deployment Strategy

How new versions replace old ones. Rolling update (gradual), blue-green (instant switch), canary (percentage), and recreate (downtime). Choice depends on risk tolerance.

Desired State

Declared target configuration. K8s reconciles actual to desired state.

DHCP

Auto-assigns IP addresses to devices. Server manages pools. Every router runs DHCP.

Disaster Recovery

Plans and processes for restoring systems after a disaster. Includes RPO (tolerable data loss) and RTO (maximum recovery time).

Disk Encryption

Encrypting storage device. LUKS, BitLocker, FileVault. Protects against theft.

Distribution

Packaged software version. Linux distros, K8s distros (K3s, RKE2).

DNS Management

Managing domain name records. Route53, Cloudflare DNS, Google Cloud DNS.

DNS Record

Entry mapping names to values. A, CNAME, MX, TXT, NS records.

Docker Build

Creating image from Dockerfile. Layer caching. Multi-stage reduces final size.

Docker Hub

Default container registry. Public/private repos. Official images. Rate limits.

Docker Network

Virtual networks connecting Docker containers. Bridge (default), host, overlay (multi-host), and macvlan. Containers on the same network communicate by name.

Docker Registry

Storage for container images. Docker Hub, ECR, GCR, Harbor.

Docker Swarm

Docker's native orchestration. Simpler than K8s. Services, stacks. Smaller deployments.

Docker Volume

Persistent storage for Docker containers that survives container restarts. Named volumes, bind mounts, and tmpfs. Essential for databases and stateful applications.

Downscaling

Reducing resources when demand decreases. K8s HPA scales down. Saves costs.

Drain

Gracefully removing workloads from node before maintenance.

Drift

When actual infrastructure state differs from declared state. Manual changes cause drift. Terraform plan detects drift. GitOps prevents drift through continuous reconciliation.

EBS

Elastic Block Store — AWS persistent block storage for EC2. Like virtual hard drives. Snapshots for backup. gp3, io2, and st1 types for different performance needs.

EBS Volume

AWS block storage. gp3, io2 types. Snapshots.

ECS

AWS container orchestration. Task definitions, Fargate serverless. AWS-native alternative to EKS.

Edge Computing

Processing data close to the user instead of a central data center. Reduces latency. Cloudflare Workers and Vercel Edge Functions.

Edge Location

CDN point of presence near users. Caches content for fast delivery.

Edge Network

A distributed network of servers at the periphery, close to users. Cloudflare, AWS CloudFront, and Vercel Edge. Reduces latency and improves performance.

Egress

Outbound traffic leaving network. Cloud charges for egress. CDNs reduce origin egress.

EKS Anywhere

Running EKS on-premises or other clouds.

Elastic Block Store

AWS persistent block storage for EC2 instances.

Elastic Compute

Cloud instances scaling automatically. EC2 Auto Scaling, GCP MIGs.

Elastic File System

AWS managed NFS. Shared across instances.

Elastic IP

Static public IP in AWS reassignable between instances. Consistent endpoints.

Elastic Load Balancing

AWS managed load balancer service. ALB, NLB, CLB.

Elasticity

The ability to automatically expand and contract resources based on demand. Different from scalability which is the ability to grow. Cloud is elastic by nature.

Endpoint (K8s)

K8s object listing IP addresses backing a service.

Environment

Deployment stage: dev, staging, prod. Each has own config. Parity minimizes surprises.

Envoy Proxy

A high-performance L7 proxy designed for service mesh. Sidecar in Istio. Advanced load balancing, circuit breaking, and observability. Written in C++ by Lyft.

Ephemeral Container

Temporary K8s container for debugging running pods.

Ephemeral Storage

Temporary storage that disappears when a container restarts. Container filesystem and emptyDir volumes. Not for persistent data. Fast for scratch space and caching.

etcd

A distributed key-value store used as Kubernetes' backing store. Stores all cluster state: configs, secrets, and service discovery. Raft consensus ensures consistency.

Event Bridge

AWS service for event routing between services. Event-driven architecture.

Eviction

K8s removing pod from node due to resource pressure.

External DNS

A Kubernetes add-on synchronizing DNS records with service endpoints. Automatically creates Route53, Cloudflare, or other DNS records when services are exposed.

External Secrets

K8s operator syncing secrets from external vaults.

Failover

Automatic transfer to a backup system when the primary fails. Database replicas, load balancers, and multi-AZ ensure failover in cloud.

Fargate

AWS serverless compute for containers. No server management. Per-task pricing.

Fault Injection

Deliberately causing failures for resilience testing. Network delays, crashes.

Fault Tolerance

Continuing operation despite failures. Redundancy, replication, graceful degradation.

Feature Gate

A mechanism enabling or disabling features at runtime without deployment. Kubernetes uses feature gates for beta features. LaunchDarkly and Flagsmith for applications.

File Storage

Network-accessible storage with filesystem. NFS, EFS. Shared across instances.

Finalizer

K8s mechanism ensuring cleanup before object deletion.

Firewall (Cloud)

Network security filtering. Security groups, NACLs, WAF, Cloud Armor.

Firewall Rule

Policy allowing/denying traffic. Source/dest IP, port, protocol. Default deny best.

Fleet Management

Managing multiple clusters or servers as a group.

Floating IP

Public IP movable between servers. Used for failover. DigitalOcean, Hetzner.

Fluentd

An open-source log collector and aggregator. Unified logging layer. Collects from multiple sources, transforms, and routes to destinations (Elasticsearch, S3, Loki).

Flux CD

A GitOps tool continuously reconciling cluster state with Git. CNCF graduated project. Alternative to ArgoCD. Watches Git repos and applies changes automatically.

Function as a Service

FaaS — serverless execution model. Lambda, Cloud Functions. Event-triggered.

Gateway API

K8s next-gen Ingress replacement. More expressive routing. HTTPRoute.

GCP

Google Cloud Platform. BigQuery, GKE, Cloud Run. Strong in data and ML.

Geo-Distributed

Deployed across multiple geographic regions. Global availability.

Git Repository

Storage for code and history. GitHub, GitLab, Bitbucket, CodeCommit.

GitOps

An operational framework using Git as the single source of truth for infrastructure. Changes via pull requests, automated sync. ArgoCD and Flux CD implement GitOps.

GKE Autopilot

Google K8s where Google manages nodes. Per-pod billing.

Golden Image

Pre-configured machine template. OS, software, config. Packer builds golden images.

GPU Instance

Cloud VM with GPU acceleration. ML training, rendering.

Graceful Degradation

System continues with reduced functionality when parts fail.

Graceful Degradation (Infra)

Continued operation with reduced capability.

Grafana

Open-source visualization platform. Dashboards for Prometheus, Loki. Metrics and logs.

gRPC

A high-performance RPC framework by Google using Protocol Buffers. Strongly typed, HTTP/2 based, bidirectional streaming. Popular for microservice communication. Faster than REST.

HAProxy

A high-performance TCP/HTTP load balancer and proxy. Used by GitHub, Reddit, and Stack Overflow. Advanced health checking, SSL termination, and rate limiting.

Harbor

An open-source container registry with security scanning, RBAC, and replication. Enterprise-grade alternative to Docker Hub for private images. CNCF graduated project.

Health Check

An endpoint reporting if a service is functioning correctly. Load balancers and orchestrators use health checks to route traffic only to healthy instances.

Health Check (Cloud)

Monitoring if service is alive and ready. HTTP probes, TCP checks.

Health Endpoint

API reporting service health. GET /health. Load balancers poll it.

Heartbeat

Periodic alive signal. Missing heartbeats trigger failover in distributed systems.

Helm

The package manager for Kubernetes. Helm charts bundle K8s manifests into reusable, versioned packages. Install complex applications with a single command.

Helm Chart

Kubernetes package manager template for deployments

High Availability

System design minimizing downtime. Redundancy, automatic failover, and multi-region ensure 99.9%+ uptime. Measured in nines (99.99% = 4 nines).

High Performance Computing

HPC — massive parallel processing. Scientific simulations, genomics.

Horizontal Pod Autoscaler

HPA — a Kubernetes resource automatically scaling pod replicas based on CPU, memory, or custom metrics. Scales up under load, scales down when idle.

Horizontal Scaling

Adding more machines to handle increased load. Stateless services scale horizontally easily. Kubernetes HPA automates horizontal scaling. Also called scaling out.

Host Network

Container sharing host's network namespace. No isolation. Maximum performance.

Host Path

K8s volume mounting host filesystem directory into pod.

Host-Based Routing

Load balancer routing by hostname. Multiple domains to different backends.

Hot Standby

A backup system running simultaneously with the primary, ready for instant failover. Database replicas in hot standby receive real-time updates. Minimizes recovery time.

HTTP Health Check

Verifying service by sending HTTP request to endpoint.

HTTP Load Balancer

Layer 7 load balancer. Routes by URL, headers. AWS ALB, GCP HTTP LB.

HTTP/2 Push

Server proactively sending resources. Deprecated but concept lives in preload.

Hybrid Cloud

Combining public cloud with private infrastructure (on-premises or private cloud). Sensitive data stays private, variable workloads go to public cloud.

Hybrid Cloud (Detail)

Combining on-premises and public cloud infrastructure.

Hyperscaler

Large-scale cloud providers. AWS, Azure, GCP. Massive global infrastructure.

Hypervisor

Software creating and managing virtual machines. Type 1 (bare-metal): VMware ESXi, KVM. Type 2 (hosted): VirtualBox, Parallels. Allocates CPU, memory, and I/O to VMs.

IaaS

Infrastructure as a Service — virtual infrastructure on demand. AWS EC2, Google Compute, Hetzner. The user manages the OS and applications.

IAM

Identity and Access Management — managing who can access what. AWS IAM, Azure AD, and Okta control identities, roles, and permissions.

IAM Policy

JSON document defining permissions. Actions, resources, conditions. Least privilege.

IAM Role

Set of permissions assignable to users or services. Temporary credentials.

Idle Instance

Running instance with low or no utilization. Waste.

Image Pull Policy

K8s policy for pulling container images. Always, IfNotPresent, Never.

Image Pull Secret

K8s secret for accessing private container registries.

Image Registry

Service storing container images. Docker Hub, ECR, Harbor. Vulnerability scanning.

Image Tag

A label identifying a specific version of a container image. 'latest' is the default but pinning specific tags (v1.2.3) ensures reproducible deployments.

Immutable Deployment

Replacing entire infrastructure instead of modifying. No drift.

Immutable Infrastructure

Servers are never modified after deployment — replaced entirely with new versions. Prevents configuration drift. Containers and VM images enable immutable infrastructure.

Incident Management

Detecting, responding to, resolving disruptions. On-call, runbooks, post-mortems.

Infrastructure as Code

IaC — managing infrastructure through config files instead of manual processes. Terraform (HCL), Pulumi (code), and Ansible (YAML) are IaC tools.

Infrastructure Drift

Actual state diverging from declared IaC state.

Infrastructure Monitoring

Tracking health and performance of servers, networks, and services. CPU, memory, disk, network metrics. Prometheus + Grafana, Datadog, and Netdata are popular stacks.

Ingress

A Kubernetes resource managing external HTTP/HTTPS access to services. Defines routing rules, TLS termination, and virtual hosts. Nginx and Traefik are popular controllers.

Ingress Controller

K8s component implementing Ingress rules. Nginx, Traefik. TLS, routing.

Ingress Traffic

Inbound traffic entering a network or service.

Init Container

A Kubernetes container running before the main app container. Performs setup: downloading configs, waiting for dependencies, running migrations. Runs to completion then exits.

Instance Metadata

Cloud VM info available at 169.254.169.254.

Instance Type

Cloud VM specification. CPU, memory, storage, network. t3.large, n1-standard-4.

Integration Testing

Testing interactions between services. After unit tests, before E2E.

Internal DNS

DNS resolution within private networks. Route53 private zones, CoreDNS.

Internal Load Balancer

Load balancer within private network. K8s ClusterIP services.

Internet Gateway

Cloud component enabling VPC internet access. Attached to public subnets.

IOPS

I/O Operations Per Second. SSDs: 10K-100K+. HDDs: 100-200. Critical for databases.

IP Address

Device identifier on network. IPv4 (32-bit), IPv6 (128-bit). Public and private.

Istio

The most popular service mesh for Kubernetes. Traffic management, security (mTLS), and observability between microservices. Envoy sidecars handle the data plane.

Jaeger

Open-source distributed tracing. Request journeys across services. CNCF graduated.

Job (K8s)

A Kubernetes resource running a pod to completion. One-off tasks: database migrations, batch processing, reports. Tracks success and allows retries on failure.

Job Controller

K8s managing batch jobs to completion.

Jump Server

Hardened server for internal network access. SSH gateway. Also called bastion host.

K3s

Lightweight Kubernetes distribution by Rancher. Single binary under 100MB. Perfect for edge, IoT, and development. Full K8s API compatible. Runs on Raspberry Pi.

Kernel

Core of operating system. Manages hardware, processes, memory. Linux kernel.

Key Rotation

Regularly changing encryption and access keys. Automated via KMS.

Kube Proxy

K8s network proxy on each node. Service routing.

Kubelet

Agent on each K8s node. Ensures containers running. Communicates with API server.

Kubernetes Cluster

A set of nodes running containerized applications managed by Kubernetes. Control plane manages the cluster; worker nodes execute pods.

Kustomize

A Kubernetes-native configuration management tool. Overlays customize base manifests without templates. Built into kubectl. Alternative to Helm for simpler use cases.

Label (K8s)

Key-value pairs on K8s objects. app:nginx, env:prod. Selectors target labels.

Lambda Layer

Shared code package for AWS Lambda. Common dependencies across functions.

Latency

Time between a request and response. Measured in milliseconds. P50, P95, P99 are common percentiles. CDNs and edge computing reduce latency.

Layer 4 Load Balancer

TCP/UDP load balancing. Faster than L7 but less routing flexibility.

Least Connection

LB routing to fewest connections. Better than round-robin for varied durations.

Lifecycle Hook

K8s container callback on start or stop.

Linkerd

An ultralight service mesh for Kubernetes. Written in Rust for performance. Simpler than Istio with automatic mTLS, metrics, and retries. CNCF graduated project.

Linux Container

Process isolated via namespaces, cgroups, union FS. Docker, LXC. Lighter than VMs.

Live Migration

Moving running VM between hosts without downtime. Maintenance operations.

Liveness Probe

A Kubernetes check determining if a pod is alive. If it fails, K8s restarts the pod. Detects deadlocks and hung processes that health checks might miss.

Load Average

Unix system load metric over 1/5/15 min. Above CPU count = overloaded.

Load Balancer

Distributes network traffic across multiple servers to optimize performance and availability. Nginx, HAProxy, and cloud load balancers.

Load Balancer Service

K8s service exposing pods via cloud load balancer.

Load Balancing Algorithm

Traffic distribution strategy. Round-robin, least connections, IP hash.

Load Shedding

Rejecting excess traffic to protect service. Circuit breaker, rate limiting.

Load Testing

Testing system performance under expected load. Identifies bottlenecks before production. k6, JMeter, and Artillery are popular tools.

Local Volume

K8s volume using node local storage for performance.

Log Aggregation

Collecting logs from multiple services into a centralized system. ELK (Elasticsearch, Logstash, Kibana), Loki + Grafana, and Datadog. Essential for distributed debugging.

Log Driver

Container logging mechanism directing stdout/stderr.

Log Level

Severity: DEBUG, INFO, WARN, ERROR, FATAL. Adjustable at runtime.

Log Rotation

Archiving old logs for disk space. Size or time based. logrotate on Linux.

Log Shipping

Sending logs to central location. Fluentd, Filebeat, Vector.

Logging

Recording events and information during software execution. Structured logging (JSON) facilitates analysis. ELK Stack, Loki, and Datadog Logs are platforms.

Loki

A log aggregation system by Grafana Labs. Indexes only labels, not log content, making it efficient and cheap. Pairs with Grafana for visualization. Like Prometheus but for logs.

Machine Image

Template for launching VMs. AMI, Compute Engine image. Golden images.

Maintenance Window

Scheduled time for system maintenance. Updates, patches, restarts.

Managed Certificate

Cloud-provided auto-renewing TLS certificate.

Managed Database

Cloud-provider managed database with automated operations

Managed Kubernetes

Cloud-operated K8s control plane. EKS, GKE, AKS.

Managed Service

Cloud service with provider handling infra. RDS, EKS, ElastiCache.

Max Pods

Maximum pods per K8s node. Varies by CNI and instance type.

Memory Limit

Max memory for process/container. K8s OOMKill when exceeded.

Memory Request

K8s minimum guaranteed memory for pod. Scheduler uses for placement.

Message Queue

Async communication between services. RabbitMQ, SQS, NATS. Decouples services.

MetalLB

A bare-metal load balancer for Kubernetes. Provides LoadBalancer service type in environments without cloud load balancers. Layer 2 and BGP modes.

Metric

A numerical measurement over time. Request latency, error rate, CPU usage, and memory consumption. Prometheus collects metrics. RED (Rate, Error, Duration) and USE methods organize metrics.

Microservice Architecture

System of small independent services. Own databases, APIs. Scale independently.

Migration Strategy

Plan for moving between systems. Lift-shift, re-platform, re-architect, replace.

MinIO

An S3-compatible object storage server. Self-hosted, high-performance, Kubernetes-native. Used for ML data, backups, and data lakes. Drop-in replacement for AWS S3.

Monitoring

Collecting and analyzing metrics from production systems. CPU, memory, latency, errors. Prometheus, Grafana, and Datadog are popular monitoring stacks.

Monitoring Stack

Combined tools: Prometheus + Grafana + Alertmanager.

Mount Point

Directory where filesystem/volume attached. /mnt/data. K8s volumeMounts.

Multi-Cloud

Using multiple cloud providers to avoid vendor lock-in, improve resilience, and optimize costs. Terraform facilitates multi-cloud management.

Multi-Region

Deploying across geographic regions for availability.

Multi-Stage Build

A Dockerfile technique using multiple FROM statements. Build in one stage, copy only artifacts to the final slim image. Dramatically reduces image size.

Multi-Tenant

Single system serving multiple customers. Data isolation, fair resources.

Namespace

A virtual cluster within Kubernetes for resource isolation. Teams, environments (dev/staging/prod), or applications get separate namespaces with their own RBAC.

Namespace (K8s)

K8s virtual cluster within physical cluster.

NAT

Network Address Translation. Private to public IP. NAT gateways in VPCs.

Network ACL

Stateless firewall at subnet level. Allow/deny by IP, port, protocol.

Network Interface

Virtual network card. ENI in AWS. Security groups attached. Multiple IPs.

Network Latency

Time for data between two points. CDNs and edge computing minimize.

Network Load Balancer

Layer 4 LB. TCP/UDP. Millions of requests/sec. Low latency.

Network Policy

Kubernetes resource controlling pod-to-pod communication. Allow or deny traffic based on labels, namespaces, and ports. Zero trust within the cluster.

NFS

Network File System. Shared remote storage. K8s PersistentVolumes.

Nginx (Server)

High-performance web server and reverse proxy serving 35%+ of websites. Event-driven, non-blocking. Configuration via .conf files.

Node (Compute)

Server in cluster. K8s worker nodes run pods. Physical, VM, or cloud.

Node (K8s)

A machine (physical or virtual) in a Kubernetes cluster. Runs pods and is managed by the control plane. Kubelet is the agent on each node.

Node Affinity

Kubernetes scheduling constraint placing pods on specific nodes based on labels. Required (hard) or preferred (soft) rules. Schedule GPU workloads on GPU nodes.

Node Drain

Gracefully removing workloads from K8s node before maintenance.

Node Group

Collection of similar compute nodes managed together.

Node Pool

A group of nodes with identical configuration in a Kubernetes cluster. Different pools for different workloads: GPU nodes for ML, high-memory for databases.

Node Selector

Simple K8s scheduling by node labels. nodeSelector: gpu: 'true'.

Node Taint

K8s marking node to repel pods without matching toleration.

NodePort

K8s service on each node's IP at static port. 30000-32767. Simple external access.

Object Lock

Preventing deletion for retention period. S3 Object Lock for compliance. WORM storage.

Object Storage

Storage for unstructured data accessed via HTTP APIs. S3, R2, and MinIO. Cheap, infinitely scalable, and durable (99.999999999%). For files, backups, and static assets.

Object Versioning

Keeping all versions of stored objects. S3 versioning. Accidental delete recovery.

Observability

The ability to understand a system's internal state from its outputs: metrics, logs, and traces. The three pillars of modern observability.

On-Demand Instance

Cloud VM billed per hour/second. No commitment.

On-Premises

Infrastructure in own data center. Full control, capital expense. Hybrid with cloud.

OOM Kill

Linux killing process exceeding memory. K8s pods killed at memory limit.

OPA

Open Policy Agent for declarative policy enforcement.

OpenTelemetry

A CNCF standard for distributed tracing, metrics, and logs. Vendor-neutral instrumentation. SDKs for all major languages. Export to Jaeger, Prometheus, Datadog, etc.

Operator Pattern

A Kubernetes pattern automating complex application management. Custom controllers watch CRDs and reconcile desired state. PostgreSQL Operator, Prometheus Operator.

Orchestration

Automated management of containers in production: scheduling, scaling, networking, and health checks. Kubernetes is the dominant orchestrator.

Orchestrator

System managing container lifecycle. Kubernetes, Docker Swarm, Nomad.

Origin Server

The source server behind CDN or proxy. Serves original content.

Outage

Period service unavailable. Post-mortems identify root cause and prevention.

Over-Provisioning

Allocating more than needed for headroom. Wastes money. Auto-scaling reduces need.

Overlay Network

Virtual network spanning multiple hosts for containers.

PaaS

Platform as a Service — a managed platform for development and deployment. Vercel, Railway, and Heroku. Abstracts servers and operating systems.

Packet

Unit of network data. Header (routing) and payload (data). IP packets, TCP segments.

Page Cache

OS caching disk data in memory. Frequently accessed files from RAM.

Partition

Division of disk, database, or queue. Sharding, Kafka partitions for parallelism.

Path-Based Routing

Load balancer routing by URL path. /api → backend, /app → frontend.

PDB

Pod Disruption Budget. K8s minimum availability guarantee.

Peering

Direct network connection between networks. Reduces latency and costs.

PersistentVolume

Kubernetes storage abstraction decoupling storage provisioning from consumption. PVs represent physical storage; PVCs are requests. Dynamic provisioning creates PVs on demand.

PersistentVolumeClaim

K8s request for storage. References StorageClass. Binds to PersistentVolume.

Ping

Testing connectivity via ICMP echo. Measures round-trip time. Basic diagnostic.

Pipeline

An automated sequence of stages: build → test → deploy. Defined in YAML. Each stage contains jobs running in parallel or sequentially.

Platform as a Service

PaaS — abstracts infra. Push code, platform deploys. Heroku, Railway.

Platform Engineering

Building internal developer platforms and tooling

Pod

The smallest unit in Kubernetes. Contains one or more containers sharing network and storage. Pods are ephemeral — created and destroyed dynamically.

Pod Affinity

K8s scheduling pods near related pods. Co-locate for performance.

Pod Disruption Budget

PDB — a Kubernetes resource ensuring minimum availability during voluntary disruptions. Prevents too many pods from being evicted simultaneously during node maintenance.

Pod Security

K8s pod security controls. Security contexts, restricted/baseline/privileged standards.

PodSpec

The specification defining a Kubernetes pod: containers, volumes, environment variables, resource limits, and scheduling. The fundamental building block of K8s workloads.

Policy as Code

Defining policies in code. Open Policy Agent, Kyverno. Automated enforcement.

Port Forwarding

Redirecting network traffic from one port to another. kubectl port-forward for accessing K8s services locally. SSH tunneling for remote access. Docker -p flag maps ports.

Preemptible VM

Cheap cloud instance reclaimable anytime. Spot Instances. For batch and CI/CD.

Preemption

K8s removing lower-priority pods for higher-priority ones.

Priority Class

Kubernetes resource defining pod scheduling priority. Higher priority pods preempt lower ones when resources are scarce. Critical system pods should have highest priority.

Private Cloud

Cloud infrastructure dedicated to a single organization. Proxmox, OpenStack, and VMware enable private cloud. More control but higher operational cost.

Private DNS

DNS resolving only within private network. Internal service discovery.

Private Endpoint

Cloud service accessible only within private network.

Private Link

Direct private connectivity to cloud services.

Private Subnet

Network without direct internet. Backend services, databases. NAT for outbound.

Process (Infra)

Running program instance. PID identifies. Isolated memory space.

Prometheus

Open-source monitoring. Pull-based metrics. PromQL. CNCF graduated. K8s standard.

Prometheus (Detail)

Pull-based metrics. PromQL. K8s monitoring standard.

Protocol

Rules governing communication. HTTP, TCP, UDP, gRPC, MQTT.

Provisioning

The process of preparing and configuring infrastructure for use. Terraform provisions cloud resources; Ansible configures servers after provisioning.

Proxy Server

Intermediary between client and destination. Forward (client), reverse (server).

Public Cloud

Cloud resources shared among multiple customers, managed by the provider. AWS, Azure, GCP. Pay-as-you-go, global scale, no CAPEX.

Public Subnet

Network with direct internet via gateway. Web servers, load balancers.

Pulumi

Infrastructure as Code using real programming languages (TypeScript, Python, Go, C#). Alternative to Terraform's HCL. Full IDE support, testing, and abstraction capabilities.

Queue Worker

Process consuming queue messages. Runs continuously. Sidekiq, Celery, Bull.

RAID

Redundant disk array. RAID 0 striping, 1 mirroring, 5 parity, 10 stripe+mirror.

Rate Limit (Infra)

Controlling request frequency to protect services. Token bucket, leaky bucket, and fixed window algorithms. Implemented at API gateway, load balancer, or application level.

RBAC

Role-Based Access Control — assigning permissions to roles instead of individual users. Admin, editor, viewer are common roles. Kubernetes uses RBAC.

Read Replica

Database copy for read queries. Offloads primary. Async replication, slight delay.

Readiness Probe

A Kubernetes check determining if a pod is ready to receive traffic. Fails during startup or when overloaded. Traffic is only sent to pods passing readiness probes.

Redis

In-memory data store. Caching, sessions, queues. Sub-millisecond latency.

Region

Geographic area with cloud data centers. us-east-1, europe-west1. Choose near users.

Replica

A copy of data or service for redundancy and performance. Database read replicas offload queries. K8s ReplicaSets maintain desired pod count. More replicas = higher availability.

ReplicaSet

K8s resource maintaining desired number of pod replicas.

Replication Controller

Legacy K8s resource maintaining pod replicas. Replaced by ReplicaSet.

Request Routing

Directing requests to appropriate service. Path, header, weight-based.

Reserved Instance

Cloud capacity pre-purchased at discount. 1-3 year terms. 30-70% savings.

Resource Limit

Max CPU/memory for container. K8s requests and limits. Prevents starvation.

Resource Quota

Kubernetes mechanism limiting resource consumption per namespace. CPU, memory, storage, and object count limits. Prevents one team from consuming all cluster resources.

Resource Request

K8s minimum guaranteed CPU/memory for scheduling.

Resource Tag

Key-value metadata on cloud resources. Env:prod, Team:backend. Cost allocation.

Reverse DNS

IP to domain mapping. PTR records. Email validation. Mismatched causes issues.

Reverse Proxy

An intermediary server between clients and backend. Nginx, Caddy, and Traefik do load balancing, SSL termination, caching, and routing.

Role-Based Access

RBAC — permissions based on user roles. Admin, editor, viewer.

Rollback

Reverting to previous deployment version.

Rolling Restart

Restarting instances one at a time. Zero downtime for config changes.

Rolling Update

A deployment strategy updating instances gradually: remove one old, add one new. Zero downtime. Kubernetes does rolling updates by default.

Root Volume

Primary storage volume for instance boot. OS and essential files.

Round Robin

Equal request distribution in order. Simple LB. Weighted for unequal servers.

Route Table

Rules directing network traffic. VPC routes map CIDRs to targets.

Run Book

Step-by-step operational procedures. Restart, alerts, maintenance. Automate over time.

Runbook Automation

Executing operational procedures automatically. PagerDuty, Rundeck.

Runtime

Environment where code executes. Node.js, JVM, containerd.

S3

Simple Storage Service — AWS object storage, the de facto standard. Buckets store objects (files). 11 nines durability. R2, MinIO, and Backblaze B2 are S3-compatible alternatives.

SaaS

Software as a Service — software delivered via browser with a subscription. Examples: Notion, Slack, Figma. The user doesn't manage infrastructure.

Savings Plan

AWS flexible pricing with commitment to usage amount.

Scalability

A system's ability to handle increasing load. Horizontal (more machines) vs vertical (bigger machine). Kubernetes facilitates horizontal scalability.

Scale In

Removing instances when demand decreases. Cost saving.

Scale Out

Adding instances when demand increases. Handle more traffic.

Scale Set

Azure resource for managing identical VM instances.

Scaling Policy

Rules for when/how to scale. CPU-based, custom metrics. Cooldown prevents oscillation.

Scheduler

Component deciding workload placement. K8s scheduler, OS CPU scheduler.

Sealed Secret

Encrypted K8s secret that can be safely stored in Git.

Secret (K8s)

A Kubernetes object storing sensitive data: passwords, tokens, and certificates. Base64 encoded (not encrypted by default). External Secrets Operator syncs from Vault or AWS.

Secret Manager

Service storing and accessing sensitive configuration.

Secrets Management

Secure management of credentials, tokens, and keys. Never in code. HashiCorp Vault, AWS Secrets Manager, and Doppler centralize and rotate secrets.

Security Group

Virtual firewall for cloud resources. Inbound/outbound rules. Stateful.

Server Capacity

Maximum requests/connections a server handles. Determined by CPU, RAM, IO.

Server Rack

Standard 42U frame for data center equipment. 19-inch width. Power, cooling.

Serverless

A model where the cloud provider manages servers. The developer only writes functions executing in response to events. AWS Lambda, Cloudflare Workers, Vercel Functions.

Serverless Framework

Tool deploying serverless functions. Serverless, SAM, SST.

Service Account

A Kubernetes identity for pods to authenticate with the API server and external services. Workload identity maps K8s service accounts to cloud IAM roles.

Service Discovery

Auto-detecting services. DNS-based, Consul, K8s. Dynamic, no hardcoded addresses.

Service Endpoint

Network endpoint where service is accessible.

Service Mesh

An infrastructure layer managing communication between microservices. Istio and Linkerd add observability, security, and traffic management transparently.

Service Registry

Database of available services and locations. Consul, etcd. Service discovery.

Service Type

K8s service exposure method: ClusterIP, NodePort, LoadBalancer.

Session Affinity

Routing user requests to same server. Cookie or IP based. For stateful apps.

Shard

Horizontal data partition across databases. Each holds subset. Scales writes.

Shared Storage

Storage accessible by multiple instances. NFS, EFS. Shared data.

Shared VPC

VPC shared across multiple cloud projects.

Sidecar Container

Container alongside main app. Logging agents, proxies. Service mesh sidecars.

Sidecar Pattern

An auxiliary container running alongside the main container in a Pod. In service mesh, the sidecar proxy (Envoy) intercepts all service traffic.

Single Point of Failure

SPOF — component whose failure causes entire system failure.

Site Reliability Engineering

SRE — applying software engineering to operations. Google originated.

SLA

Service Level Agreement — a contract defining uptime guarantees. 99.9% (8.7h downtime/year), 99.99% (52min/year). Financial penalties for violations. SLO is the internal target.

SLA (Cloud)

Service Level Agreement defining uptime guarantees. 99.99% = 52min downtime/year.

SLI

Service Level Indicator — quantitative measure: latency, error rate, throughput.

SLO

Service Level Objective — target for SLI. 99.9% availability. Internal targets.

Snapshot

A point-in-time copy of a disk, VM, or database state. Allows restoring to a specific moment. Faster than full backup.

Snapshot (Detail)

Point-in-time volume copy for backup and cloning.

Snapshot Policy

Automated schedule for creating volume snapshots.

SNAT

Source NAT modifying outgoing packet source IP. Load balancers, NAT gateways.

Software-Defined Networking

SDN — managing networks through software. Cloud VPCs are SDN.

Spot Instance

Spare cloud capacity available at 60-90% discount. Can be reclaimed with 2-minute notice. Ideal for batch processing, CI/CD, and fault-tolerant workloads. AWS Spot, GCP Preemptible.

SSH Key

Cryptographic key pair for SSH access. ssh-keygen. Public key on server.

SSL Termination

Decrypting TLS at load balancer. Offloads encryption from backend.

Staging Environment

Pre-production environment for final testing. Mirrors production.

Startup Probe

K8s check for slow-starting containers. Prevents liveness probe killing during startup.

State File

Terraform state tracking deployed resources. Remote state in S3 for teams.

StatefulSet

A Kubernetes resource for stateful applications. Guarantees ordered deployment, stable network identities, and persistent storage. Used for databases and message queues.

Stateless Service

Service storing no local state. All state in external stores. Easy to scale.

Static IP

IP address that doesn't change. Elastic IP, reserved IP. For DNS and whitelisting.

Step Function

AWS workflow orchestration. State machines. Sequential, parallel, error handling.

Storage Account

Azure service for blobs, files, queues, tables.

Storage Class

K8s resource defining storage tiers. Standard SSD, premium IOPS, economy HDD.

Storage Gateway

Bridge between on-premises and cloud storage. Cache locally, store in cloud.

Stream Processing

Continuous real-time data processing. Kafka Streams, Flink, Spark Streaming.

Stress Test

Testing a system beyond normal load to find the breaking point. Reveals how the system fails and recovers. Essential for critical systems.

Subnet

IP network subdivision. 10.0.1.0/24 = 256 addresses. Public and private in VPCs.

Subnetting

Dividing network into smaller segments. CIDR notation. Security and organization.

Surge Upgrade

K8s adding extra nodes during cluster upgrade.

Swap Memory

Disk overflow when RAM full. Much slower. K8s typically disables swap.

Syslog

Standard log transmission protocol. Centralized logging from devices and servers.

System Administrator

Person managing IT infrastructure. Servers, networks, security. SysAdmin.

System Namespace

K8s kube-system namespace for core components.

Tag (Cloud)

Key-value metadata on resources for organization, billing, automation.

Taint and Toleration

Kubernetes mechanism preventing pods from scheduling on certain nodes. Nodes are tainted; only pods with matching tolerations can run there. Used for specialized hardware.

Target Group

AWS group of instances receiving load balancer traffic.

TCP

Reliable ordered connection protocol. Acknowledgments and retransmission. HTTP, SSH.

TCP Health Check

Verifying service by attempting TCP connection.

TCP Load Balancer

Layer 4 LB routing TCP connections. Database, MQTT, non-HTTP protocols.

Tekton

A cloud-native CI/CD framework for Kubernetes. Pipeline resources are K8s CRDs. Serverless, runs only when triggered. Foundation for many K8s-native CI/CD solutions.

Terraform

Infrastructure as Code tool. HCL language. Plan, apply. Multi-cloud.

Terraform (Tool)

HashiCorp's IaC tool using HCL language to provision resources on AWS, Azure, GCP, and 3,000+ providers. Plan before apply for safety.

Terraform Module

A reusable, self-contained package of Terraform configuration. Modules encapsulate infrastructure patterns. The Terraform Registry hosts thousands of community modules.

Terraform Provider

Plugin managing resources in platform. AWS, Azure, GCP. 3000+ providers.

Terraform State

A file tracking the current state of managed infrastructure. Maps resources to real-world objects. Remote state (S3, Terraform Cloud) enables team collaboration.

Throttling

Limiting request rate to prevent overload.

Throughput

The amount of work processed per unit of time. Requests/second, transactions/second, bytes/second. A key performance metric.

Time to Recovery

TTR — time to restore service after failure. Part of SLA.

TLS

Cryptographic protocol for secure communication. TLS 1.3 current. Encryption and auth.

Topology Spread

K8s distributing pods across zones/nodes evenly.

Trace

Record of request journey through distributed system. Spans for individual operations.

Traffic Management

Controlling request flow. Routing, load balancing, rate limiting.

Traffic Shaping

Controlling network flow. Rate limiting, QoS, bandwidth allocation.

Tunnel

Encrypted channel through network. VPN tunnel, SSH tunnel, GRE tunnel.

Twelve-Factor App

A methodology for building modern, scalable SaaS applications. 12 principles including config in environment, stateless processes, and disposability. Heroku co-founder authored it.

UDP

Connectionless fast protocol. No delivery guarantee. DNS, video streaming, gaming.

Under-Provisioning

Insufficient resources causing performance issues. Monitor and scale.

Upgrade Strategy

Plan for updating software versions. Rolling, blue-green. Backward compatibility.

Uptime

Percentage system is operational. 99.9% = 8.77h/year downtime.

Usage Monitoring

Tracking resource consumption. CPU, memory, network, storage. Cost control.

Vault

HashiCorp secret management. Dynamic secrets, encryption, PKI.

Velero

A Kubernetes backup and disaster recovery tool. Backs up cluster resources and persistent volumes. Restores to same or different cluster. Scheduled backups to S3.

Vertical Pod Autoscaler

K8s auto-adjusting pod CPU/memory requests.

Vertical Scaling

Adding more resources (CPU, RAM) to an existing machine. Limited by hardware maximum. Simpler than horizontal scaling but has a ceiling. Also called scaling up.

Virtual IP

IP address not tied to specific hardware. VIPs for load balancing and failover.

Virtual Machine

Emulation of a complete computer inside another. Has its own OS, RAM, and virtual storage. More isolated but heavier than containers.

Virtual Network

Software-defined network in cloud. VPCs, VNets. Isolated with subnets.

Virtualization

Technology creating virtual versions of physical resources. Enables running multiple OSes on a single hardware. Proxmox, VMware, KVM.

VLAN

Virtual LAN — logically segmenting physical network. Isolates traffic.

Volume Mount

Attaching storage to a container at a specific path. Docker -v flag, K8s volumeMounts. Persists data beyond container lifecycle. Essential for databases and configs.

VPC

Virtual Private Cloud — an isolated virtual network within the public cloud. Subnets, routing tables, and security groups control traffic.

VPC Peering

Direct network connection between two VPCs.

VPN Tunnel

An encrypted connection between two networks over the internet. Site-to-site VPNs connect offices. WireGuard and IPSec are tunneling protocols. Ensures private communication.

Warm Pool

Pre-initialized instances for quick scaling. Reduces cold start time.

Warm Standby

Scaled-down copy of production for DR. Quick scale-up when needed.

Webhook (Infra)

HTTP callback for event notification. Git push triggers CI/CD.

Weighted Routing

Distributing traffic by percentage. 90% v1, 10% v2. Canary deployments.

Well-Architected

Cloud best practice frameworks. AWS: ops excellence, security, reliability, perf, cost.

Worker Node

Server executing workloads in cluster. Runs pods. Managed by control plane.

Workload

Application running on infrastructure. Web servers, batch jobs, databases.

Workload Identity

K8s pods assuming cloud IAM roles. No static credentials.

Write-Ahead Log

WAL — recording changes before applying. Crash recovery via replay.

Zero Downtime Deployment

Deploying new versions without service interruption. Rolling updates, blue-green, and canary deployments achieve zero downtime. Essential for production services.

Zero Trust Network

Security model verifying every access request

Zone Transfer

Copying DNS zone data between servers. Authoritative DNS replication.

2FA

Two-Factor Authentication — requires two verification methods: something you know (password) + something you have (TOTP app, FIDO2 key). Much more secure than password alone.

Abuse Detection

Identifying misuse of services or platforms by users or bots

Access Control List

ACL — a list specifying which users or systems are granted or denied access to resources. File ACLs, network ACLs, and cloud security groups.

Access Management

Controlling who can access what resources.

Access Review

Periodic verification of user permissions for compliance

Access Token

Short-lived credential for API access. OAuth access tokens. JWT common format.

Account Lockout

Disabling account after failed login attempts. Prevents brute force.

Account Recovery

Regaining access to locked account. Email verification, security questions.

Account Takeover

Attacker gaining control of user account.

Active Directory

Microsoft directory service managing network identities and policies

Adaptive Authentication

Adjusting auth requirements by risk. New device requires 2FA.

Advanced Persistent Threat

APT long-term targeted attack by nation-states.

Adversary

Threat actor: script kiddies, hacktivists, organized crime, nation-states.

Air Gap

Physically isolating a network from the internet. Used for critical infrastructure, military systems, and cold cryptocurrency storage. Most secure but least convenient.

Allow List

Explicitly permitted items. IP, application, email allowlists. Default deny.

Anti-Forensics

Techniques used to evade or disrupt digital forensic investigation

Anti-Malware

Software detecting various malware types. Broader than antivirus.

Anti-Phishing

Technologies detecting and blocking phishing attempts.

Anti-Spam

Filtering unwanted bulk email messages before delivery

Antivirus

Software detecting, preventing, and removing malware. Signature-based and behavioral detection. Windows Defender, ClamAV (open-source). Less effective against zero-days.

API Key

A simple authentication token identifying the calling application. Passed in headers or query params. Less secure than OAuth — no user context. Easy to implement.

API Security

Protecting APIs from abuse: authentication (OAuth, API keys), rate limiting, input validation, and encryption. OWASP API Security Top 10 lists common API vulnerabilities.

Application Firewall

WAF protecting web apps from attacks.

Application Security

Securing apps throughout lifecycle. SAST, DAST, code review.

Application Whitelisting

Only pre-approved applications allowed to execute on systems

Asset Classification

Categorizing assets by sensitivity and business criticality

Asset Inventory

Complete catalog of IT assets. Can't protect what you don't know about.

Assume Breach

Security posture assuming network is compromised.

Asymmetric Encryption

Public/private key pair. Public encrypts, private decrypts. RSA, Ed25519.

Attack Surface

The total number of points where an attacker could enter a system. Minimizing attack surface through hardening, closing ports, and removing unused services improves security.

Attack Tree

Hierarchical model of potential attacks. Visual threat analysis tool.

Attack Vector

The method an attacker uses to breach a system. Email (phishing), web (XSS), network (MITM), physical (USB drops). Understanding vectors helps prioritize defenses.

Attribute-Based Access Control

ABAC permissions based on user and resource attributes

Audit Log

A chronological record of system activities. Who did what, when, and from where. Required for compliance (SOC 2, GDPR). Tamper-proof storage is essential.

Auth Token

Authentication credential proving identity. Session tokens, JWTs, API keys.

Authentication

The process of verifying a user's identity. Methods: password, biometrics, magic link, passkeys. OAuth and OIDC are standard protocols.

Authentication Factor

Evidence proving identity: knowledge, possession, inherence, location.

Authentication Protocol

Standardized method for verifying identity like Kerberos

Authorization

The process of determining what actions an authenticated user can perform. RBAC (role-based), ABAC (attribute-based), and ACLs control permissions.

Authorization Code

OAuth grant type. Server exchange code for token. Most secure flow.

Backdoor

Secret method bypassing auth. Planted by attackers or devs. Code review detects.

Backup Encryption

Encrypting backup data. Protect against backup theft.

Bearer Token

An access token included in the Authorization header (Bearer xyz...). The server trusts whoever bears the token. JWTs are commonly used as bearer tokens.

Behavioral Analysis

Detecting threats by anomalous behavior patterns.

Binary Analysis

Examining compiled software without source. IDA Pro, Ghidra.

Biometric Data

Physical measurements for identity. Fingerprints, face geometry, iris patterns.

Biometrics

Authentication based on physical characteristics: fingerprint, facial recognition, iris. Touch ID and Face ID are biometrics. Convenience vs privacy.

Block Cipher

An encryption algorithm processing fixed-size blocks. AES encrypts 128-bit blocks. Modes of operation (CBC, GCM) handle data larger than one block.

Block Cipher Mode

Algorithm using block cipher on data. CBC, GCM, CTR modes.

Block List

Explicitly denied items. IP, domain blocklists. Less secure than allowlists.

Blue Team

The defensive security team responsible for protecting systems. Monitors, detects, and responds to threats. Opposite of Red Team (attackers). Purple Team combines both.

Bot Detection

Identifying automated requests. CAPTCHA, behavioral analysis, fingerprinting.

Botnet

A network of compromised devices controlled by an attacker. Used for DDoS attacks, spam, and cryptocurrency mining. Mirai botnet infected IoT devices.

Breach Notification

Informing parties after data breach. GDPR: 72 hours. Varies by jurisdiction.

Break Glass Procedure

Emergency access bypassing normal security controls

Bring Your Own Device

BYOD policy allowing personal devices on corporate network

Browser Fingerprinting

Identifying users by browser characteristics without cookies.

Brute Force Attack

Trying every possible combination to crack a password or key. Rate limiting, account lockout, and long passwords mitigate brute force. bcrypt slows attempts.

Buffer Overflow

Writing beyond allocated memory. Classic C vulnerability. Memory-safe langs prevent.

Bug Bounty

A program rewarding ethical hackers for reporting vulnerabilities. HackerOne and Bugcrowd are platforms. Google, Apple, and Microsoft pay thousands for critical bugs.

Business Continuity

Plans for critical functions during disruption. DR, communication, alt sites.

Business Email Compromise

Targeted email fraud impersonating executives

CA

Certificate Authority — a trusted entity issuing digital certificates. Let's Encrypt (free), DigiCert, and Sectigo. Browsers trust certificates signed by recognized CAs.

Canary Token

A hidden tripwire that alerts when accessed. Fake credentials, documents, or DNS entries. When an attacker uses them, you know you've been breached. Thinkst Canary.

CAPTCHA Bypass

Techniques for defeating CAPTCHA automated bot challenges

CASB

Cloud Access Security Broker controlling cloud access.

CCPA

California Consumer Privacy Act for data protection rights

Certificate

Digital document binding identity to public key. X.509 format. TLS certs.

Certificate Authority

CA trusted entity that issues digital certificates

Certificate Pinning

Associating a specific certificate or public key with a domain, rejecting all others. Prevents MITM attacks with fraudulent certificates. Used in mobile apps.

Certificate Transparency

A public log of all issued SSL certificates. Detects rogue or misissued certificates. Certificate monitors alert domain owners to unauthorized certificate issuance.

Chain of Custody

Documentation tracking evidence handling in forensics.

Challenge-Response

Auth where server sends challenge, client proves knowledge.

CIDR

Classless Inter-Domain Routing — IP address notation specifying network ranges. 10.0.0.0/24 means 256 addresses. Used in VPC subnets, security groups, and firewall rules.

CIDR Notation

IP address range notation like 10.0.0.0/24 for 256 addresses

Cipher

Algorithm for encryption/decryption. Block (AES) and stream (ChaCha20).

Cipher Suite

Combined algorithms for TLS. Key exchange, encryption, MAC.

Cleartext

Unencrypted readable data. Never store passwords in cleartext.

Clickjacking

Tricking users into clicking hidden elements by overlaying transparent iframes. X-Frame-Options and CSP frame-ancestors headers prevent clickjacking.

Cloud Access Broker

CASB — security policy between cloud and users. Visibility, compliance, protection.

Cloud Security

Protecting cloud infra and data. Shared responsibility model.

Cloud Workload Protection

Securing cloud compute workloads.

Code Injection

Malicious input altering execution. SQL, OS command, LDAP injection.

Code Review (Security)

Reviewing code specifically for vulnerabilities.

Cold Storage

Offline storage for highly sensitive data or cryptocurrency. Hardware wallets, air-gapped systems, and offline backups. Maximum security, minimum accessibility.

Cold Storage (Security)

Offline storage for sensitive keys and backup data

Common Weakness Enumeration

CWE standardized software weakness catalog.

Compliance

Conformity with regulations and standards: GDPR, SOC 2, ISO 27001, HIPAA. Involves policies, audits, and technical and organizational controls.

Compliance Audit

Formal verification of regulatory requirement adherence

Container Escape

Breaking out of container isolation to access host system

Container Security

Securing containerized applications. Image scanning (Trivy), runtime protection, network policies, and least-privilege. Never run containers as root.

Containment

Isolating compromised systems during incident.

Content Filtering

Blocking inappropriate or malicious content.

Content Security Policy

CSP — an HTTP header controlling which resources a page can load. Prevents XSS by whitelisting script sources. Strict CSP blocks inline scripts and eval().

Cookie Security

Securing cookies. Secure, HttpOnly, SameSite, short expiration.

Credential Rotation

Regularly changing passwords and access keys.

Credential Stuffing

Using stolen credentials from one breach on other services.

Cross-Origin

Requests between different domains, protocols, or ports. Same-origin policy blocks them by default. CORS headers selectively allow cross-origin access.

Cross-Site Scripting

XSS — injecting scripts into web pages. Reflected, stored, DOM-based.

Cryptanalysis

Study of breaking cryptographic systems and ciphers

Crypto Agility

Ability to quickly switch crypto algorithms. Post-quantum readiness.

Cryptographic Key

A piece of data used with an algorithm to encrypt/decrypt data. Symmetric (shared secret) or asymmetric (public/private pair). Key length determines security strength.

Cryptojacking

Unauthorized crypto mining using computing resources.

CSRF

Cross-Site Request Forgery — an attack forcing an authenticated user to perform unwanted actions. CSRF tokens and SameSite cookies are standard defenses.

CVE

Common Vulnerabilities and Exposures — a standardized identifier for known security vulnerabilities. CVE-2021-44228 is Log4Shell. NVD rates severity with CVSS scores.

CVSS

Vulnerability severity scoring 0-10. Critical 9+, High 7-8.9, Medium 4-6.9.

Cyber Insurance

Insurance covering financial losses from cyberattacks.

Cyber Kill Chain

Lockheed Martin's model of cyberattack stages: reconnaissance, weaponization, delivery, exploitation, installation, command & control, actions on objectives.

Cyber Range

Simulated environment for security training.

Dark Web

Part of the internet accessible only via Tor. Illegal markets but also secure communication for journalists and activists. Only ~3% of the internet.

Data Anonymization

Removing personally identifiable information from datasets

Data at Rest

Stored data on disk. Encrypt with AES-256.

Data at Rest Encryption

Protecting stored data with AES-256 encryption

Data Breach

Unauthorized access to sensitive data. Mandatory notification under GDPR (72h). Equifax, Yahoo, and LinkedIn suffered massive breaches.

Data Classification

Categorizing data by sensitivity: public, internal, confidential, restricted. Determines handling, storage, and access requirements. Foundation of data governance.

Data Destruction

Securely erasing data beyond recovery.

Data Encryption at Rest

Encrypting stored data on disk. AES-256 is standard. Full disk encryption (LUKS, BitLocker) and database-level encryption. Protects against physical theft.

Data Encryption in Transit

Encrypting data during transmission. TLS/SSL for web, SSH for terminal, WireGuard for VPN. Prevents eavesdropping on network traffic.

Data Exfiltration

Unauthorized transfer of data out of a system. Via email, USB, cloud uploads, or DNS tunneling. DLP (Data Loss Prevention) tools detect and block exfiltration.

Data in Transit

Data moving between systems. TLS protects. Unencrypted can be intercepted.

Data in Use

Data in memory being processed. Most vulnerable state. Confidential computing.

Data Loss Event

Incident where sensitive data is lost or exposed.

Data Loss Prevention

DLP tools preventing sensitive data from leaving organization

Data Masking

Replacing sensitive data with realistic but fake values. Production data masked for dev/test environments. PII like names, emails, and SSNs are masked.

Data Minimization

Collecting only necessary data. GDPR principle. Reduces breach impact.

Data Protection

Safeguarding personal and sensitive data. Encryption, access control, retention.

Data Sanitization

Cleaning data to prevent injection attacks.

DDoS

Distributed Denial of Service. Overwhelming target with traffic from many sources.

DDoS Attack

Distributed Denial of Service — overwhelms a server with massive traffic from multiple sources. Cloudflare and AWS Shield protect against DDoS.

DDoS Mitigation

Defending against DDoS. Rate limiting, traffic scrubbing, CDN absorption.

Deception Technology

Fake systems detecting attackers. Honeypots, honey tokens, canary files.

Decoy

Fake resource designed to detect or delay attackers.

Decryption

Converting encrypted data back to plaintext. Requires correct key.

Deep Packet Inspection

Examining packet content beyond headers. Firewalls, IDS.

Deep Web

Internet content not indexed by search engines: emails, databases, content behind logins. ~96% of the internet. Different from the Dark Web.

Default Credentials

Factory-set login credentials. Must change.

Defense in Depth

Layered security approach where multiple controls protect assets. If one layer fails, others still provide protection. Network, application, data, and physical layers.

Denial of Service

Attack overwhelming service to make it unavailable

Device Trust

Verifying device security posture before access.

DevSecOps

Integrating security into DevOps. Security in CI/CD. Everyone responsible.

Dictionary Attack

A brute force variant using common passwords and words. 'password123' and 'qwerty' are tried first. Strong, unique passwords and salted hashes prevent this.

Digest (Hash)

Fixed-size output of hash function. SHA-256 produces 256-bit digest.

Digital Certificate

An electronic document validating a website's identity and enabling HTTPS. Issued by Certificate Authorities. Let's Encrypt offers free certificates.

Digital Forensics

Investigating cybercrimes by collecting, preserving, and analyzing digital evidence. Disk imaging, memory analysis, and log examination. Chain of custody is critical.

Digital Signature

Cryptographic proof of authenticity. Private key signs, public key verifies.

Directory Traversal

Accessing files outside intended dirs using ../. Sanitize inputs.

Disaster Recovery Plan

Procedures for restoring systems after catastrophe. RTO and RPO targets.

Disclosure Policy

Rules for vulnerability reporting. Responsible disclosure gives vendors time.

DKIM

DomainKeys Identified Mail — email authentication adding a digital signature to outgoing emails. Receiving servers verify the signature against DNS records. Prevents email spoofing.

DLP

Data Loss Prevention — tools and policies preventing sensitive data from leaving the organization. Monitors email, file transfers, and cloud storage for PII and classified data.

DMARC

Domain-based Message Authentication, Reporting, and Conformance. Builds on SPF and DKIM. Tells receivers what to do with unauthenticated emails: none, quarantine, or reject.

DMZ

Demilitarized Zone — network between internal and internet. Public servers here.

DNS Filtering

Blocking malicious domains at DNS level.

DNS over HTTPS

DoH — encrypting DNS queries over HTTPS. Prevents ISP and network snooping on browsing activity. Cloudflare 1.1.1.1 and Google 8.8.8.8 support DoH.

DNS Poisoning

Corrupting DNS cache with fraudulent address records

DNS Security

Protecting DNS infrastructure. DNSSEC, DoH, DoT, monitoring.

DNSSEC

DNS Security Extensions — adds cryptographic signatures to DNS records. Prevents DNS spoofing and cache poisoning. Validates that DNS responses are authentic.

Domain Fronting

Technique hiding true destination of network traffic

Downgrade Attack

Forcing system to use weaker vulnerable protocol version

Dual Control

Requiring two people for sensitive operations.

Dynamic Analysis

Testing running software for vulnerabilities.

EDR

Endpoint Detection and Response. Monitoring devices.

Egress Filtering

Controlling outbound traffic. Prevents exfiltration and C2.

Elliptic Curve

Math structure for modern crypto. ECDSA, Ed25519. Smaller keys, same security.

Email Encryption

Encrypting email content. S/MIME, PGP.

Email Filtering

Blocking unwanted or malicious email. Spam filters, phishing detection.

Email Security

SPF, DKIM, DMARC prevent spoofing. Anti-phishing filters.

Encrypted Backup

Backup data protected by encryption.

Encrypted Communication

Messages protected from eavesdropping. Signal protocol, TLS.

Encryption

The science of protecting information by transforming it into an unreadable format. Symmetric (AES) uses one key; asymmetric (RSA, Ed25519) uses a public/private pair.

Encryption Key Rotation

Regularly changing encryption keys to limit exposure from compromised keys. Automated rotation with services like AWS KMS and HashiCorp Vault.

Endpoint

Any device connecting to the network: laptops, smartphones, servers, IoT. Endpoint security protects these devices against threats.

Endpoint Detection

EDR continuously monitoring endpoints for threat indicators

Endpoint Security

Protecting devices connecting to network. EDR, antivirus, device management.

Entropy

A measure of randomness in data. High entropy = truly random, good for cryptographic keys. Low entropy passwords are easily cracked. /dev/urandom provides system entropy.

Eradication

Removing threat from compromised system.

Ethical Hacking

Authorized testing of security. Bug bounties, pen testing. Legal and contracted.

Event Correlation

Linking related security events for analysis.

Exploit

Code exploiting vulnerability. RCE, privilege escalation.

Exploit Chain

Multiple vulnerabilities used together for access.

Exposure Management

Identifying and reducing attack surface.

Fail Closed

System denying access when security check fails.

Fail Open

System allowing access when security check fails.

False Positive

Security alert that's not actually a threat. Wastes analyst time. Tuning reduces.

FIDO2

Fast Identity Online 2 — passwordless authentication standard. WebAuthn and CTAP protocols. Hardware security keys (YubiKey) and biometrics. Phishing-resistant.

File Encryption

Encrypting individual files for protection.

File Integrity Monitoring

Detecting unauthorized file changes. AIDE, OSSEC.

Firewall

A system filtering network traffic based on security rules. Network firewalls (iptables, nftables) and application firewalls (WAF) protect against attacks.

Firmware Security

Protecting firmware. UEFI Secure Boot. Supply chain risk.

Forensic Analysis

Investigating digital evidence after incident.

Fraud Detection

Identifying fraudulent activity using pattern analysis

Full Disk Encryption

Encrypting entire device. LUKS, BitLocker, FileVault.

GDPR

General Data Protection Regulation — EU data protection regulation. Right to be forgotten, consent, and portability. Fines up to 4% of global revenue.

Hardening

The process of reducing a system's attack surface. Disabling unnecessary services, patching, secure configuration, and principle of least privilege.

Hardware Security Module

HSM — tamper-resistant device for cryptographic operations.

Hash

A function transforming data into a fixed-size string. Irreversible and deterministic. SHA-256, bcrypt, and Argon2 are used for passwords and data integrity.

Hash Function

Fixed output from any input. One-way, deterministic. SHA-256, BLAKE3.

Hash Salt

Random data added to password before hashing for uniqueness

Hashing Algorithm

A function producing a fixed-size output from variable input. MD5 (broken), SHA-256 (standard), bcrypt/Argon2 (passwords). Used for integrity, signatures, and password storage.

HIPAA

US healthcare data protection law. PHI safeguards, breach notification.

Homomorphic Encryption

Computing on encrypted data without decrypting it. The result, when decrypted, matches computation on plaintext. Enables private cloud computing. Still computationally expensive.

Honey Pot

Decoy system attracting attackers. Detects intrusions, gathers intelligence.

Honeypot

A fake system deliberately exposed to attract and study attackers. Collects intelligence about adversary tactics, techniques, and procedures (TTPs).

Hot Fix

Emergency patch for critical vulnerability.

HSTS

HTTP Strict Transport Security — a header telling browsers to only use HTTPS. Prevents downgrade attacks and cookie hijacking. Preload lists hardcode HSTS in browsers.

HTTP Security Headers

HSTS, CSP, X-Content-Type-Options. Easy security wins.

Identity Governance

Policies managing identity lifecycle and access.

Identity Management

Managing user identities and access. IAM systems, provisioning.

Identity Provider

Service authenticating users. Okta, Auth0, Keycloak. SAML, OIDC.

IDS

Intrusion Detection System — monitors network traffic for suspicious activity. Signature-based (known patterns) and anomaly-based (unusual behavior). Snort and Suricata are popular.

Immutable Audit Log

Append-only audit trail that cannot be modified

Incident

A security event requiring response. Data breach, malware, DDoS, unauthorized access.

Incident Commander

Person leading incident response efforts.

Incident Response

Structured approach to handling security breaches: preparation, identification, containment, eradication, recovery, and lessons learned. Every org needs an IR plan.

Incident Response Plan

Documented steps for handling security incidents

Incident Timeline

Chronological record of incident events.

Indicator of Compromise

IOC — breach evidence. Malicious IPs, file hashes, domains.

Information Security

Protecting info: CIA triad — confidentiality, integrity, availability.

Input Sanitization

Cleaning input to prevent injection. Server-side mandatory. DOMPurify.

Insecure Deserialization

A vulnerability where untrusted data is deserialized, potentially executing arbitrary code. OWASP Top 10 item. Validate and sanitize all serialized data.

Insider Threat

Risk from people within org. Intentional or negligent.

IP Allowlist

Restricting access to specific approved IP addresses

IP Blocking

Denying network access from specific IP addresses.

IP Spoofing

Forging source IP address in network packets.

IPS

Intrusion Prevention System — like IDS but actively blocks detected threats. Inline with network traffic. Can drop malicious packets in real-time.

ISO 27001

International standard for information security management

Isolation

Separating compromised systems from network.

JSON Web Encryption

JWE — encrypted JWT. Protects token payload contents.

Juice Jacking

Stealing data or installing malware through public USB charging ports. Use charge-only cables or portable batteries. USB data blockers prevent data transfer.

Just-In-Time Access

Granting temporary elevated permissions on request.

Kerberos

Network authentication protocol using tickets and trusted third party

Key Exchange

Securely establishing shared keys. Diffie-Hellman, ECDHE. TLS handshake.

Key Management

Practices for handling cryptographic keys throughout their lifecycle: generation, distribution, storage, rotation, and destruction. AWS KMS, Vault, and SOPS.

Key Pair

Public and private key together. SSH keys, TLS certs, PGP.

Keylogger

Malware recording all keystrokes. Captures passwords, messages, and sensitive data. Can be software or hardware. 2FA mitigates the risk.

Kill Chain

Stages of cyberattack from recon to action.

Kill Switch

Emergency mechanism to immediately disable compromised system

Lateral Movement

An attacker moving through a network after initial breach, accessing additional systems. Network segmentation and zero trust limit lateral movement.

Least Functionality

Disabling unnecessary features and services.

Least Privilege

Security principle granting minimum permissions needed for a task. Reduces blast radius of compromised accounts. Apply to users, services, and API keys.

Lessons Learned

Post-incident review of what could be improved.

LGPD

Brazil's General Data Protection Law — the Brazilian version of GDPR. Regulates collection, use, and storage of personal data in Brazil. ANPD is the regulatory authority.

Log Analysis

Examining logs for patterns and anomalies. SIEM, Splunk, ELK.

Log Integrity

Ensuring logs cannot be tampered with.

Logging (Security)

Recording security events for analysis. Centralized, tamper-proof.

MAC Address

Unique hardware network identifier. 48-bit hex. Can be spoofed.

MAC Address Spoofing

Changing hardware network identifier to impersonate device

Magic Link

Passwordless authentication via one-time email link

Malicious Code

Software designed to harm systems or steal data.

Malware

Malicious software designed to damage or gain unauthorized access. Includes viruses, trojans, spyware, adware, and ransomware.

Malware Analysis

Examining malicious software. Static and dynamic analysis.

Man Trap

Physical security with two interlocking doors for access control

Man-in-the-Browser

An attack using browser malware to modify web pages and transactions in real-time. Different from MITM — the attack is inside the browser itself.

Man-in-the-Middle

Attack intercepting communication between two parties

Man-in-the-Middle Attack

An attacker intercepts communication between two parties without their knowledge. HTTPS and VPNs prevent MITM. Public Wi-Fi networks are especially vulnerable.

Managed Detection

MDR outsourced threat monitoring and response.

Mean Time to Detect

MTTD average time to identify security incident.

Mean Time to Respond

MTTR average time to resolve security incident.

Memory Safety

Protection against buffer overflows and use-after-free errors

MFA

Multi-Factor Authentication. 2+ factors from different categories.

Micro Segmentation

Granular network segmentation at workload level. Limits lateral movement.

MITRE ATT&CK

Knowledge base of adversary tactics and techniques. Industry standard.

Monitoring (Security)

Continuous security observation. SOC, SIEM, SOAR, EDR.

mTLS

Mutual TLS — both client and server authenticate with certificates.

Multi-Factor Authentication

MFA requires 2+ verification factors from different categories: something you know (password), have (TOTP/key), or are (biometrics). Much more secure.

Mutual TLS

mTLS — both client and server authenticate each other with certificates. Used in service-to-service communication, zero trust networks, and API security.

Network Access Control

NAC — controlling device network access. 802.1X auth.

Network Forensics

Capturing and analyzing traffic. tcpdump, Wireshark.

Network Monitor

Tool observing network traffic for anomalies.

Network Segmentation

Dividing a network into isolated segments. Limits blast radius of breaches — an attacker in one segment can't reach others. VLANs, subnets, and firewalls implement segmentation.

Network Tap

Hardware capturing network traffic for analysis.

Next-Gen Firewall

NGFW combining traditional firewall with IPS, DPI.

NIST Framework

Cybersecurity framework: Identify, Protect, Detect, Respond, Recover.

Nonce

A number used once in cryptographic communication. Prevents replay attacks. Used in authentication protocols, encryption (AES-GCM), and blockchain mining.

OAuth 2.0

Authorization framework. Delegated access. Grant types for different scenarios.

OAuth Scope

Permissions in OAuth. read:user, write:repo. Least privilege.

Obfuscation

Making code difficult to understand. Anti-reverse.

OCSP

Certificate revocation checking. OCSP stapling reduces latency.

OIDC

OpenID Connect. Identity layer on OAuth 2.0. ID tokens, userinfo endpoint.

One-Time Password

OTP — single-use password. TOTP (Google Auth), HOTP.

Open Redirect

A vulnerability where the app redirects to an attacker-controlled URL. Used in phishing. Validate redirect URLs against a whitelist of allowed destinations.

OSINT

Open Source Intelligence — gathering information from publicly available sources. Social media, DNS records, company filings, and code repositories. Used by attackers and defenders.

OWASP

Open Web Application Security Project — publishes the Top 10 web vulnerabilities. Injection, Broken Auth, and XSS consistently rank in the top.

OWASP Top 10

Most critical web security risks. Injection, broken auth, XSS, etc.

Packet Filtering

Firewall examining packet headers to allow or block traffic

Packet Sniffer

Capturing network packets. Wireshark, tcpdump.

PAM

Privileged Access Management for admin accounts.

Passkey

A FIDO2-based passwordless credential stored on your device. Replaces passwords with biometrics or device PIN. Synced via iCloud Keychain or Google Password Manager.

Passphrase

Long memorable password more secure than short complex ones

Password Cracking

Attempting to recover passwords from hashes.

Password Hash

Hashed password storage. bcrypt, Argon2. Salt prevents rainbow tables.

Password Manager

Software generating and storing unique, strong passwords for every account. 1Password, Bitwarden, and KeePass. Essential security tool. Never reuse passwords.

Password Policy

Rules for passwords. Modern: long passphrases over complex short.

Password Spray

Trying common passwords against many accounts. Avoids lockout.

Patch

A software update fixing bugs or vulnerabilities. Patch management is critical — most attacks exploit vulnerabilities that already have patches available.

Patch Management

Identifying and applying patches. Most breaches exploit known vulns.

Patch Tuesday

Microsoft monthly security update release.

Payload (Security)

Malicious component of exploit or malware.

PCI DSS

Payment Card Industry Data Security Standard — requirements for handling credit card data. 12 requirements covering network security, encryption, access control, and monitoring.

Penetration Test

An authorized simulation of an attack to discover vulnerabilities. White-hat hackers use tools like Burp Suite, Metasploit, and nmap.

Penetration Testing

Authorized simulated attack testing security. White/black/gray box.

Perfect Forward Secrecy

New key per session so past sessions stay secure

Permission

Authorization to perform specific action. Read, write, execute, admin.

Personally Identifiable Information

PII — data identifying individual. Name, email, SSN.

PGP

Pretty Good Privacy — encryption system for email and files. Public key encryption and digital signatures. GPG is the open-source implementation. Used for signing Git commits.

Phishing

A social engineering attack where the attacker impersonates a legitimate entity to steal credentials. Fake emails, cloned sites, and SMS are common vectors.

Phishing Kit

A pre-built package for creating phishing sites. Sold on dark web. Includes cloned login pages, credential capture, and hosting setup. Lowering the barrier for attackers.

Phishing Simulation

Testing employees with fake phishing. Measures awareness.

Physical Security

Protecting physical assets. Access controls, surveillance.

PII

Personally Identifiable Information like name email or SSN

Policy Engine

System evaluating access requests against rules.

Port Scanning

Probing a server to discover open network ports and running services. Nmap is the standard tool. Used in reconnaissance phase of attacks and security audits.

Post-Exploitation

Actions after gaining access. Privilege escalation, lateral movement.

Post-Mortem

Analysis after incident. What happened, why, how to prevent.

Post-Quantum Cryptography

Algorithms resistant to quantum computer attacks

Principle of Least Authority

Components given minimum capabilities needed

Privacy

Right to control personal information. GDPR, CCPA, LGPD.

Privacy by Design

Integrating privacy into system design from start. GDPR mandates.

Privilege Escalation

Gaining higher access than authorized. Vertical (user to admin) or horizontal (accessing another user's data). Proper RBAC and input validation prevent this.

Privileged Access Management

PAM controlling and auditing admin access

Protected Health Information

PHI — HIPAA-regulated health data. Encrypted, access-controlled.

Public Key Infrastructure

PKI — system managing digital certificates and public key encryption. CAs issue certificates, browsers verify trust chains. Foundation of HTTPS.

Purple Team

Combined offensive and defensive security exercises

Rainbow Table

A precomputed table mapping hashes to passwords for fast cracking. Salting passwords makes rainbow tables useless as each hash is unique.

Ransomware

Malware that encrypts files and demands payment to decrypt. WannaCry and LockBit are notorious examples. Regular backups are the best protection.

Ransomware Prevention

Backups, training, patching, segmentation, endpoint protection.

Rate Limiting (Security)

Throttling requests to prevent brute force.

RBAC

Role-Based Access Control. Permissions assigned via roles.

Reconnaissance

First attack phase — gathering target information. OSINT techniques.

Recovery Point

RPO maximum acceptable data loss in time.

Recovery Time

RTO maximum acceptable downtime after failure.

Red Team

Offensive security team simulating real attacks to test defenses. Ethical hackers finding vulnerabilities through the attacker's lens. Complements the defensive Blue Team.

Refresh Token

Long-lived token for obtaining new access tokens. Stored securely.

Regulatory Compliance

Adhering to laws and regulations governing data handling

Replay Attack

Intercepting and retransmitting valid data to trick a system. Timestamps, nonces, and sequence numbers prevent replays. Critical for authentication and financial transactions.

Reverse Engineering

Analyzing software or hardware to understand its design without source code. Decompilers, debuggers, and disassemblers. Used in security research and malware analysis.

Right to Be Forgotten

GDPR right to request personal data deletion.

Risk Assessment

Systematic process identifying, analyzing, and evaluating security risks. Likelihood × impact = risk score. Prioritizes security investments. Required for compliance frameworks.

Risk Management

Identifying, assessing, mitigating security risks.

Root Cause Analysis

Determining fundamental reason for incident.

Root of Trust

Foundation component trusted by all other security components.

Rootkit

Malware gaining privileged (root) access and hiding from the OS. Extremely difficult to detect. Can persist after OS reinstallation.

Rubber Ducky

USB device that emulates keyboard to inject malicious commands

Runbook (Security)

Step-by-step incident response procedures.

Runtime Security

Protecting during execution. Anomaly detection, exploit blocking. Falco.

Salt

Random data added to a password before hashing. Makes identical passwords produce different hashes. Each user gets a unique salt. bcrypt includes salt automatically.

SAML

Security Assertion Markup Language. Enterprise SSO. XML-based.

Sandbox

An isolated environment for running potentially malicious code without affecting the system. Browsers use sandboxing for tabs. Malware analysis uses sandboxes.

Sandbox (Security)

Isolated environment for running untrusted code safely.

Sandbox Escape

Breaking out of isolated execution environment.

SBOM

Software Bill of Materials — a complete inventory of components in software. Required by US executive order for federal suppliers. SPDX and CycloneDX are standard formats.

SBOM Compliance

Meeting requirements for software component transparency

Scan Policy

Rules defining vulnerability scan scope and frequency.

SCAP

Security Content Automation Protocol. Compliance checks.

SCIM

System for Cross-domain Identity Management — standard for automating user provisioning. Create, update, and delete user accounts across services automatically.

Secret Key

Symmetric encryption key. Must remain confidential. KMS protects.

Secret Scanning

Automatically detecting exposed credentials in code repositories. GitHub secret scanning, GitGuardian, and TruffleHog. Catches API keys, passwords, and tokens committed accidentally.

Secure Boot

Firmware verification of boot software integrity. UEFI feature.

Secure Coding

Writing code resistant to attacks. Input validation, output encoding.

Secure Development Lifecycle

SDL integrating security into each dev phase

Secure Random

Cryptographically secure random number generator. /dev/urandom, crypto.randomBytes.

Security Architecture

Design of security controls. Segmentation, auth flows, encryption.

Security Audit

Systematic evaluation of an organization's security posture. Reviews policies, configurations, and controls. Internal or third-party. Required for SOC 2, ISO 27001.

Security Awareness Training

Educating employees on threats. Phishing, passwords.

Security Baseline

Minimum security configurations. CIS Benchmarks.

Security by Design

Integrating security from the start of development, not as an afterthought. Threat modeling during design, secure defaults, and security testing in CI/CD.

Security Champion

Developer advocate for security practices within team

Security Clearance

Authorization level for classified information.

Security Control

Measure reducing risk. Preventive, detective, corrective, deterrent.

Security Group (Detail)

Cloud virtual firewall. Inbound/outbound rules.

Security Headers

HTTP response headers improving security: HSTS, CSP, X-Content-Type-Options, X-Frame-Options, Referrer-Policy. Easy wins for web application security.

Security Incident

Event compromising confidentiality, integrity, availability.

Security Information and Event Management

SIEM collecting and analyzing security data.

Security Information Management

SIEM collecting and analyzing security data

Security Monitoring

Continuous observation of systems for security events

Security Operations

Day-to-day monitoring and response. SOC analysts, SIEM, SOAR.

Security Orchestration

SOAR automating security workflows.

Security Patch

Software update fixing vulnerability.

Security Policy

Document defining security rules. Acceptable use, access control.

Security Posture

Overall security strength of organization.

Security Questionnaire

Assessment evaluating vendor or partner security practices

Security Review

Systematic evaluation of system security.

Security Scanning

Automated vulnerability identification.

Security Standards

Frameworks like ISO 27001, NIST, CIS Benchmarks.

Security Token

Physical or digital credential. Hardware tokens, software tokens, smart cards.

Sensitive Data

Information requiring protection. PII, PHI, financial.

Separation of Duties

No single person controls entire critical process.

Server Hardening

Securing server by removing unnecessary services.

Session Fixation

Attack forcing known session ID on user.

Session Hijacking

Stealing a user's session token to impersonate them. Via XSS, network sniffing, or session fixation. Secure cookies (HttpOnly, Secure, SameSite) prevent this.

Session Management

Creating, maintaining, destroying user sessions securely.

Session Token

Unique identifier maintaining user state. Cookies or storage.

Side Channel Attack

Exploiting implementation leaks like timing or power usage

SIEM

Security Information and Event Management — a platform aggregating and analyzing security logs from across the infrastructure. Splunk, Elastic SIEM, and Sentinel.

Signature-Based Detection

Identifying threats by known patterns.

SIM Swapping

Fraudulently transferring phone number to attacker SIM

Single Sign-On

SSO — one authentication for multiple services. SAML, OIDC.

Smishing Attack

Phishing conducted through SMS text messages

SOAR

Security Orchestration Automation and Response.

SOC

Security Operations Center — a team and infrastructure dedicated to monitoring, detecting, and responding to security incidents 24/7.

SOC 2

System and Organization Controls 2 — audit framework for service organizations. Trust principles: security, availability, processing integrity, confidentiality, privacy.

SOC 2 Type II

Audit evaluating security controls effectiveness over time

Social Engineering

Psychological manipulation to obtain confidential information or access. Phishing, pretexting, baiting, and tailgating are common techniques.

Software Vulnerability

Weakness exploitable by attackers. Buffer overflow, injection, logic flaws.

Spear Phishing

Targeted phishing aimed at specific individuals.

SPF

Sender Policy Framework — email authentication specifying which mail servers can send email for a domain. DNS TXT record lists authorized IPs. Prevents email spoofing.

SPF Record

DNS record specifying authorized email sending servers

Spoofing

Impersonating a legitimate entity. IP spoofing, DNS spoofing, email spoofing, and caller ID spoofing. SPF, DKIM, and DMARC prevent email spoofing.

Spyware

Software secretly monitoring user activity. Collects browsing history, passwords, and personal data. Pegasus is the most notorious spyware.

SQL Injection

Injection of malicious SQL code through unsanitized inputs. Can read, modify, or delete data. Prepared statements and ORMs prevent SQL injection.

SSH

Secure Shell — encrypted protocol for remote server access. Key-based authentication preferred over passwords. SSH tunneling enables secure port forwarding. OpenSSH is standard.

SSH Tunneling

Encrypted channel through SSH for secure data transfer

SSL/TLS

Protocols encrypting network communication. TLS 1.3 current standard.

Static Analysis (Security)

SAST scanning source code for vulnerabilities.

Steganography

Hiding data within other data — images, audio, or video. A message invisible to the eye can be encoded in pixel values. Used for covert communication.

Stream Cipher

Encrypts data bit-by-bit. ChaCha20, RC4 (broken). Fast for streaming.

Subdomain Takeover

Claiming abandoned subdomain through DNS misconfiguration

Subresource Integrity

SRI — verifies that fetched resources (CDN scripts) haven't been tampered with. The HTML includes a hash of the expected content. Browsers refuse modified resources.

Supply Chain Attack

Compromising software by targeting its dependencies or build process. SolarWinds and npm package attacks are examples. Lock files and SRI help mitigate.

Suspicious Activity

Behavior indicating potential security threat.

Symmetric Encryption

Same key for encrypt and decrypt. AES. Faster than asymmetric.

Tabletop Exercise

Simulated incident scenario for team practice.

Third-Party Risk

Security risk from vendors and partners.

Threat Actor

Entity attempting to compromise systems.

Threat Hunting

Proactively searching for hidden threats.

Threat Intelligence

Collection and analysis of cyberthreat information. IOCs (Indicators of Compromise), TTPs, and threat feeds inform proactive defenses.

Threat Modeling

Identifying potential threats to a system during design. STRIDE framework: Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, Elevation of Privilege.

Threat Surface

Total exposure to potential attacks.

Time-Based OTP

TOTP code changing every 30 seconds. Google Auth.

TLS Handshake

The process establishing a secure connection. Client and server negotiate cipher suite, exchange certificates, and derive session keys. Takes 1-2 round trips (TLS 1.3 = 1 RTT).

Token-Based Auth

Using tokens instead of sessions. JWT, API keys. Stateless.

Tokenization

Replacing sensitive data with non-sensitive tokens. Payment tokens replace card numbers. Different from encryption as it's irreversible without the mapping table.

Transport Security

Encrypting data in transit. TLS, SSH.

Trojan

Malware disguised as legitimate software. When executed, opens backdoors, steals data, or installs more malware. Named after the Trojan Horse.

Trusted Platform Module

TPM — hardware security chip. Key storage, attestation, boot integrity.

Two-Factor Authentication

2FA — two different auth factors. Password + TOTP/SMS/hardware key.

Typosquatting

Registering domains with common typos (gooogle.com) to capture mistyped traffic. Used for phishing, malware distribution, and ad revenue. Brand monitoring detects it.

URL Filtering

Blocking access to malicious or inappropriate URLs. Web proxy, DNS filtering.

User Activity Monitoring

Tracking user actions for security.

User Permission

Specific action a user is authorized to perform. Granted via roles.

Virus

Malware that self-replicates by attaching to other programs

Vishing

Voice phishing via phone calls.

VLAN Security

Securing virtual LANs. VLAN hopping prevention, ACLs, private VLANs.

VPN

Virtual Private Network — creates an encrypted tunnel between device and remote server. Protects privacy and allows access to private networks. WireGuard is the modern protocol.

Vulnerability Assessment

Systematic identification of weaknesses.

Vulnerability Disclosure

Process for reporting found vulnerabilities.

Vulnerability Management

Continuous process of finding and fixing vulns.

Vulnerability Scanner

Automated tool identifying known vulnerabilities in systems. Nessus, Qualys, and OpenVAS scan networks. Trivy and Snyk scan containers and code.

WAF

Web Application Firewall — filters HTTP traffic to protect web apps. Blocks XSS, SQL injection, and DDoS at the application layer. Cloudflare WAF and AWS WAF are popular.

Watering Hole

An attack compromising a website frequently visited by targets. The attacker infects the site, which then infects visitors. Targeted alternative to mass phishing.

Watering Hole Attack

Compromising website frequently visited by target group

Web Application Firewall

WAF filtering malicious web application traffic

Web Filter

Controlling web access. Category blocking, URL filtering, malware scanning.

Web Security Scanner

Automated tool testing web app security.

Whaling

Phishing targeting senior executives.

Whitelist

List of explicitly allowed items. IPs, applications, email senders.

Wireless Security

Protecting wireless networks. WPA3, hidden SSID.

Worm

Self-replicating malware spreading without user interaction. Network propagation.

XDR

Extended Detection and Response — unified security platform correlating data across endpoints, networks, cloud, and email. Broader than EDR. CrowdStrike and SentinelOne offer XDR.

XSS

Cross-Site Scripting — injection of malicious code into web pages executing in other users' browsers. Input sanitization and Content Security Policy prevent XSS.

XSS Filter

Browser or WAF mechanism blocking cross-site scripting

YARA Rules

Pattern matching rules for malware identification.

Zero Day

Unknown vulnerability with no available patch. Most dangerous. Detection based defense.

Zero Knowledge Proof

Cryptographic method proving knowledge of something without revealing it. Used in privacy-preserving authentication and blockchain. You prove you know the password without sending it.

Zero Trust

A security model that trusts no user or device by default, even inside the network. Continuously verifies: never trust, always verify.

Zero-Day

A vulnerability unknown to the vendor with no patch available. Extremely valuable to attackers. Zero-day exploits are sold on the black market.