Glossary

Programming & Software Engineering

967 terms in this category.

Abstract Base Class

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

A class that cannot be instantiated directly, only subclassed. Defines a contract with abstract methods that subclasses

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.

The principle of hiding complexity and exposing only what's necessary. Classes, interfaces, and APIs are forms of abstra

Access Modifier

Keywords controlling visibility of class members. Public (anywhere), private (same class), protected (subclass). TypeScr

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.

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

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

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

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

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 clie

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

Address Space Layout Randomization

ASLR memory security technique randomizing locations.

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

Iterative software development methodology valuing individuals, working software, collaboration, and responding to chang

Agile Manifesto

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

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.

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

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

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

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

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.

Advanced Message Queuing Protocol. RabbitMQ implements it.

Words with same letters rearranged. Classic interview problem.

Metadata attached to code elements. Java @Override, Python decorators, TypeScript decorators. Processed by compilers, fr

Anonymous Function

A function without a name, defined inline. Arrow functions (() => {}) in JS, lambdas in Python. Used for callbacks, even

Anti-Corruption Layer

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

A common but counterproductive programming practice. God class, spaghetti code, and premature optimization are anti-patt

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

Application Programming Interface — a set of rules enabling communication between different software. REST and GraphQL A

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

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

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

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

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.

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.

An ordered collection of elements accessed by index. Fixed-size in C/Java, dynamic in JavaScript/Python. O(1) access by

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.

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

Aspect Ratio (Code)

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

Translates assembly language to machine code.

Assembly Language

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

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

A statement verifying a condition is true during execution. Used in tests (expect/assert) and runtime checks. Fails loud

Assertion Library

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

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

Abstract Syntax Tree — a tree representation of source code structure. Compilers, linters, and formatters parse code int

Async Generator

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

An iterator that yields values asynchronously using for-await-of in JavaScript. Useful for streaming data, paginated API

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

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

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

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

Atomic Operation

An operation that completes entirely or not at all, with no intermediate state visible. Database transactions and concur

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

Automatic primitive to wrapper conversion. Java int to Integer.

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

Automatic Memory Management

Runtime handling allocation and deallocation. GC.

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

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

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

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

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.

A flow control mechanism where consumers signal producers to slow down. Prevents memory overflow in streams. Node.js str

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

Backward Compatibility

New version working with old data and interfaces.

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

Unordered collection allowing duplicates. Multiset.

Bare Metal Programming

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

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

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

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

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.

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

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

Breadth-First Search — a graph/tree traversal exploring all neighbors before going deeper. Uses a queue. Finds shortest

Most significant byte first in memory. Network byte order.

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

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.

An efficient algorithm finding elements in sorted arrays. Divides search space in half each step. O(log n) time complexi

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

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

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

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

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 AN

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

Integer using individual bits as boolean flags.

Bitwise Operation

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

Black Box Testing

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

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.

I/O operations that halt execution until complete. A thread waits idle during disk reads or network calls. Non-blocking

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

Blue-Green Deployment

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

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

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

Boolean Expression

Expression evaluating to true or false.

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

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

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

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

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.

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

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.

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

Broadcast (Code)

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

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.

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

A temporary memory area holding data during transfer between systems. Node.js Buffer handles binary data. Ring buffers a

Buffer Underrun

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

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

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

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

Build Automation

Automated compilation and packaging. CI/CD builds.

Incrementing identifier for each build. Version tracking.

Tool automating compilation, testing, and packaging. Make, Gradle, Bazel, and Turborepo. Incremental builds only recompi

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 enabl

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

Inserting many records at once. Much faster than individual.

Total JavaScript sent to browser. Smaller is faster.

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

Temporary spike in activity. Burst capacity, burst writes.

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

Intermediate code between source and machine code. JVM bytecode (Java), WASM, and Python .pyc files. Portable across pla

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

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

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

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

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

Smallest unit CPU transfers between cache and memory.

Requested data not in cache. Requires slower fetch.

Many cache misses overwhelming backend simultaneously.

Evaluating argument expression each time accessed.

Graph of function calling relationships.

A stack data structure tracking function calls. Each call pushes a frame; returns pop it. Stack overflow occurs when too

A function passed as an argument to another function, executed when an operation completes. Fundamental pattern in async

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

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.

Standard representation removing ambiguity.

Capacity Planning

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

Number of elements or unique values in set/column.

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

Cascading Delete

Automatically deleting child records when parent deleted.

Switch case selecting code branch by value.

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

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

Handler matching all remaining cases. Default route.

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

Ceiling Function

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

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.

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

Character Encoding

Mapping characters to bytes. UTF-8, ASCII.

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

Checked Exception

Exception that must be caught or declared. Java.

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

Process created by another process. Fork, spawn.

Portion of data processed together. Chunked transfer.

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.

A blueprint for creating objects with shared properties and methods. Supports inheritance and encapsulation. ES6 classes

UML diagram showing classes, attributes, methods, relationships.

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 o

Building from scratch without cached artifacts.

Well-written, readable, and maintainable code. Principles include descriptive names, small functions, and single respons

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

Removing all elements from collection or display.

Command Line Interface — text-based interface for interacting with software. Terminal commands, shell scripts, and CLI t

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

Software development kit for API consumers.

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

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

Time difference between clocks. Impacts distributed systems.

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

A function that retains access to variables from its outer scope even after the outer function returns. Fundamental in J

Closure (Detail)

Function capturing variables from outer scope.

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

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

Combining multiple operations into one. Batch operations.

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

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

Systematic code examination for quality and security.

Complete source code of a project or organization.

Duplicated code in different locations. Clone detection.

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

Code Duplication

Same logic in multiple places. DRY violation.

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 genera

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

Sequence of executed statements through program.

Numeric value assigned to character in Unicode.

The process of reviewing code by other developers before merge. Improves quality, shares knowledge, and reduces bugs. Pu

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

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

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

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

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

Tool generating code from specifications.

Automatic type conversion by the language runtime. JavaScript coerces '5' + 3 to '53' (string). Source of bugs. TypeScri

Coercion (Detail)

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

Mental effort to understand code. Reduce with simplicity.

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

Collaboration Tool

Software enabling team work. GitHub, Slack, Figma.

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

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

Vertical data field in table or database.

Comma-Separated

Data delimited by commas. CSV format.

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

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

Queue of commands for sequential processing.

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

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

Reducing size by removing unused space.

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

Checking equality or ordering between values.

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

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

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

Compiler Optimization

Automatic code improvement during compilation.

Compiler Warning

Non-fatal issue detected during compilation.

Completion Handler

Callback called when async operation finishes.

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

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

Testing component with its dependencies.

Composite Pattern

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

Building complex objects from simpler ones instead of inheritance. 'Has-a' vs 'is-a' relationship. Composition over inhe

Composition Root

Single location where dependencies are composed. Application entry point.

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

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

GPU program for general computation. GPGPU.

Computed Property

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

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

Execution of multiple tasks progressing at the same time. Threads, goroutines, and async/await are concurrency mechanism

Concurrency Control

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

Condition Variable

Thread synchronization waiting for state change.

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

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

Centralized configuration management. Spring Cloud.

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

Company behind Kafka. Managed streaming platform.

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

Connection Pool

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

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.

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

Constant Folding

Compiler evaluating constant expressions at compile time.

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

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

Constraint Satisfaction

Finding values meeting all constraints.

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

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

Set of consumers sharing message processing load.

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

Container (Code)

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

Hash of file content for cache invalidation.

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

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

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 e

Continuous Integration

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

Contract Testing

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

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

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

Convention Over Configuration

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

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

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.

Compiler optimization avoiding unnecessary copies.

Rules for copying objects. C++ copy constructor.

An optimization delaying data copying until modification. Both references share data until one writes. Used in fork(), G

A function that can suspend and resume execution. Python async/await, Kotlin coroutines, and Go goroutines. Enable coope

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

Variable tracking count. Increment, decrement, reset.

Counting Semaphore

Semaphore allowing N concurrent accesses.

The degree of dependency between software modules. Low coupling (loose coupling) is desirable — allows changing one modu

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

Command Query Responsibility Segregation — separating read and write models. Different data stores optimized for each. C

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

Critical Path (Code)

Longest execution path determining minimum time.

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 exc

Cross-Cutting Concern

Functionality spanning multiple modules. Logging, auth.

Cross-Reference

Link between related data or documentation.

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

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.

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

NVIDIA GPU processing unit for parallel computation.

Current Directory

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

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

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

Custom Allocator

User-defined memory allocation strategy.

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

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

Custom Iterator

User-defined sequential access implementation.

Cyclomatic Complexity

Code complexity measuring decision paths.

A background process running without user interaction. System daemons (cron, sshd), Docker daemon (dockerd). Named after

Data Access Object

DAO pattern encapsulating data source operations.

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

A class primarily holding data with minimal behavior. Python @dataclass, Kotlin data class, TypeScript interfaces. Auto-

Object holding structured data for transfer.

Agreement on data format between components.

Data Definition Language

DDL SQL creating schema. CREATE TABLE.

Data Encapsulation

Hiding data behind methods. Private fields.

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

Structure for data representation. JSON, XML, YAML.

Maintaining accuracy and consistency of data.

Component batching and caching data fetches.

ORM pattern separating domain from persistence.

Object primarily holding data. DTO, record, struct.

Dividing data across storage locations.

Data Serialization

Converting objects for storage. JSON, protobuf.

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

System storing data. Database, cache, file system.

An organized way to store and access data efficiently. Arrays, linked lists, trees, graphs, hash tables, stacks, and que

Data Transfer Object

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

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

Data Validation

Verifying data meets rules and constraints.

An organized system for storing and querying data. Relational (PostgreSQL, MySQL) use tables; NoSQL (MongoDB, Redis) use

Database Connection

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

Database Driver

Library connecting application to specific database.

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

Preventing concurrent data modification.

Database Migration

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

Reusing pre-created database connections.

Database Schema

Structure definition. Tables, columns, relationships.

Database Transaction

Atomic unit of database operations. ACID.

Standard date representation. ISO 8601, locale-specific.

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

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

Code that can never be executed or whose result is never used. Tree shaking removes dead code from bundles. Increases ma

Dead Letter Queue

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

A state where two or more processes wait for each other indefinitely, unable to proceed. Occurs when locks are acquired

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 s

The process of finding and fixing bugs in code. Debuggers, console.log, breakpoints, and stack traces are essential tool

Verbose output for troubleshooting issues.

Tool for stepping through code execution.

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.

A pattern that adds behavior to functions or classes without modifying them. Python @decorators, TypeScript decorators,

Decorator Pattern

Adding behavior to object without modifying class. Wrapping objects.

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

Creating a completely independent copy of an object and all nested objects. structuredClone() in JS, copy.deepcopy() in

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

Handler when no other conditions match.

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

Default Parameter

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

Value used when none provided.

Defensive Programming

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

Declaration providing implementation details.

Waiting specified time before proceeding.

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

Delete Operation

Removing data from storage.

Difference between two values or states.

Denormalization

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

External code a project relies on. Managed by package managers (npm, pip, cargo). Direct vs transitive dependencies. Loc

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 coup

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

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.

Marking code as outdated and discouraged. Warns developers to migrate before removal. @deprecated annotation, console wa

Depth-First Search

Traversal exploring deep before backtracking.

Class inheriting from base class. Subclass.

Deserialization

Converting stored format back to object.

Design Document

Written description of planned implementation.

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, Stra

Evaluating proposed design before implementation.

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

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

Desktop Application

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

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

A process always producing the same output for the same input. Builds, tests, and deployments should be deterministic. N

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.

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

Depth-First Search — a graph/tree traversal exploring as deep as possible before backtracking. Uses a stack. Application

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

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

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

Computing differences between data. Myers diff.

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.

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

Folder organizing files. Hierarchical file system.

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

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

Routing operation to handler. Dynamic dispatch.

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.

Client looking up domain name to IP address.

Containerization platform that packages applications into portable containers. Docker Compose orchestrates multi-contain

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

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

Documentation embedded in source code. Python triple-quote strings, JSDoc comments, Javadoc. Generates API documentation

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

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

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

Business rules and operations.

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

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 bus

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

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

Double-Ended Queue

Deque — add/remove from both ends.

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

Software enabling hardware communication.

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

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

Executing without making actual changes.

Domain-Specific Language — a language designed for a specific domain. SQL for databases, CSS for styling, Terraform HCL

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

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

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

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

Duplicate Detection

Finding identical records in data.

Data surviving system failures. ACID D.

Array automatically resizing. ArrayList, vector.

Dynamic Configuration

Changing settings without restart.

Dynamic Dispatch

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

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)

Proxy created at runtime. Java InvocationHandler.

SQL constructed at runtime. Risk of injection.

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

Eager Evaluation

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

Loading all related data upfront in one query. Prevents N+1 query problem. Prisma include, SQLAlchemy joinedload. Opposi

Exiting function early for invalid state.

Outputting received input. Echo server, shell echo.

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

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

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.

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

Empty Collection

Collection with zero elements. [], {}.

String with length zero. '' or "".

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

Activating feature or setting.

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

Converting data from one format to another. UTF-8 encodes text, Base64 encodes binary, URL encoding handles special char

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

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

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

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

Enterprise Software

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

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

Entity Framework

Microsoft ORM for .NET applications.

Single item in collection or data store.

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

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

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 developm

Short-lived, temporary. Ephemeral containers, storage.

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

Implementing equality comparison. Equatable protocol.

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

Error Boundary (Detail)

React fallback UI for component tree errors.

Linking errors showing root cause chain.

Error Correction

Detecting and fixing data errors. ECC memory.

Strategies for managing failures: try/catch, Result types, error boundaries. Good error handling provides useful message

Error Handling (Detail)

Strategies for managing failures gracefully.

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

Error Propagation

Passing errors up the call stack.

Application state indicating something went wrong.

Mechanism bypassing abstractions when needed.

Executing string as code. Security risk. Avoid.

Computing the value of an expression. Interpreter evaluates code.

Occurrence that triggers response. Click, timer, message.

Event Aggregator

Centralizing event publish/subscribe.

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

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

The mechanism that handles async operations in JavaScript. Checks the call stack, processes microtasks (Promises), then

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

Storing state changes as a sequence of events instead of current state. Enables audit trail, time travel, and event repl

Database of events for event sourcing.

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

An architecture where flow is determined by events (user actions, messages, data changes). Node.js, Apache Kafka, and AW

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.

An error condition disrupting normal program flow. Thrown and caught with try/catch. Checked (Java) vs unchecked excepti

Exception Handling

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

Exception Safety

Guaranteeing state consistency when exceptions occur.

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

Running code or command.

Execution Context

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

Database strategy for query execution. EXPLAIN.

Component running submitted tasks.

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

Increasing capacity or capabilities.

Testing hypothesis with controlled conditions.

Exponential Backoff

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

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

Module's single primary export.

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

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

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 r

Third-party API consumed by application.

Pulling data from source. ETL extraction phase.

Extreme Programming

XP agile method. Pair programming, TDD.

Simplified interface to complex system.

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

Service or utility supporting main functionality.

Object or function creating other objects.

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

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

System defaulting to safe state on failure.

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

One operation triggering multiple downstream operations.

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

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.

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

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

Memory barrier ensuring operation ordering.

Foreign Function Interface — calling code written in one language from another. Python ctypes, Node.js N-API, Rust FFI.

Fibonacci Sequence

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

First-In-First-Out ordering. Queues.

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.

Reference to open file for I/O operations.

Preventing concurrent file access.

Location of file in filesystem hierarchy.

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

Component writing data to file.

Placeholder content. Lorem ipsum, skeleton data.

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

Cannot be overridden or extended. Java final.

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),

First-Class Function

Functions treated as values — assigned to variables, passed as arguments, and returned from functions. JavaScript, Pytho

Exact decimal without floating-point errors.

A boolean variable controlling program behavior. Feature flags toggle features on/off. Command-line flags configure CLI

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

Converting nested structure to single level.

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

Approximate decimal representation. IEEE 754.

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

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

Writing buffered data to destination immediately.

Reducing collection to single value. reduce().

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

Database column referencing another table's primary key.

Creating a copy of a repository or process. GitHub forks copy repos for contribution. Unix fork() creates child processe

Arranging data for display or storage.

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

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

Forward Declaration

Declaring before defining. C header prototypes.

Client-side intermediary for outgoing requests.

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

Fragment (Code)

Partial piece. URL fragment, GraphQL fragment.

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

A reusable software structure providing base functionality. React and Vue for frontend, Express and Django for backend,

Function not attached to any object or class.

Making object immutable. Object.freeze().

Front Controller

Single entry point handling all requests.

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

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

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

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.

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 fun

Fast userspace mutex. Linux synchronization.

Object representing eventual result. Similar to Promise.

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

Unreachable memory ready for collection.

Garbage Collection

Automatic memory management that reclaims unused memory. Java, Go, and JavaScript use GC. Rust uses ownership instead. G

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

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

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

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

Type parameters allowing code to work with multiple types safely. Array<T> in TypeScript, Vec<T> in Rust, List<E> in Jav

A distributed version control system created by Linus Torvalds. Tracks changes, creates branches, and enables collaborat

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

Independent development line. Feature branches, main, develop.

Git Cherry-Pick

Applying specific commit to different branch.

Copying remote repository locally.

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

Competing changes needing manual resolution.

Showing differences between commits or files.

Branching model. feature, develop, release, main.

Chronological commit record.

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

Creating new Git repository.

Viewing commit history.

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

Fetching and merging remote changes.

Uploading local commits to remote.

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

Link to remote repository. origin, upstream.

Undoing commits. Soft, mixed, hard reset.

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

Repository nested inside another repository.

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

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

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

AI pair programmer suggesting code.

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

A wildcard pattern for matching file paths. *.js matches all JS files, src/**/*.ts matches all TS files recursively. Use

State accessible from anywhere in the application. Redux store, React Context, and Zustand manage global state. Overuse

Global Variable

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

Google's language designed for simplicity and concurrency. Goroutines make concurrent programming easy. Fast compilation

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

Go lightweight concurrent function execution.

Recommended standard approach. Convention.

Go's lightweight concurrent function. Cheaper than OS threads — millions can run simultaneously. Communicate via channel

Graceful Shutdown

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

Grafana Dashboard

Visualization panel for metrics and logs.

A data structure with nodes (vertices) connected by edges. Directed or undirected, weighted or unweighted. Used in socia

Nodes connected by edges. Directed or undirected.

Graph Algorithm

Operating on graphs. BFS, DFS, Dijkstra.

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

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

GraphQL Mutation

Write operation in GraphQL.

Read operation in GraphQL.

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.

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

Aggregating data by category. SQL GROUP BY.

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

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

Lossless compression reducing HTTP response size 60-80%.

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

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

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

Numeric value computed from object for hash tables.

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

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

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

A data structure mapping keys to values with O(1) average lookup. JavaScript objects, Python dicts, and Java HashMaps ar

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

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

SQL filter on aggregated results. After GROUP BY.

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

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

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

A tree-based data structure where the parent is always greater (max-heap) or smaller (min-heap) than children. Priority

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.

Dynamic memory allocated at runtime for objects and data. Managed by garbage collector in Java/JS or manually in C/C++.

Heartbeat (Code)

Periodic signal confirming system alive.

Utility function or class supporting main logic.

Helper Function

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

Practical approach finding good enough solution.

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

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. Fundament

Taking control of session, request, or connection.

Frequency distribution visualization. Performance profiling.

Successful cache lookup or search result.

JavaScript behavior where variable and function declarations are moved to the top of their scope. var is hoisted (undefi

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

Side by side. Horizontal scaling, layout.

Machine running services. Hostname identifies.

Frequently executed code deserving optimization.

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

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

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

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

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

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

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

HTTP Status Code

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

Text with links to other content. Web foundation.

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

Integrated Development Environment — an editor with integrated tools: autocomplete, debugging, terminal, Git. VS Code, C

An operation producing the same result regardless of how many times it's executed. PUT and DELETE should be idempotent.

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

Image (Container)

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

Data that cannot be changed after creation. New values require creating new objects. Immutable.js, Immer, and Object.fre

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

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

A browser feature mapping module specifiers to URLs without a bundler. Enables using bare imports (import React from 're

In-Memory Database

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

A data structure improving database query speed. B-tree and hash indexes. CREATE INDEX speeds SELECT but slows INSERT/UP

Index (Database)

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

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

An OOP mechanism where a class inherits properties and methods from another. Enables code reuse. Composition over inheri

Injection Attack

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

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.

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++. Rus

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 pi

Interface (Programming)

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

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

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 yo

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

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

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

JIT Compilation

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

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

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

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.

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

A container orchestration platform that automates deployment, scaling, and management. K8s is the standard for productio

Lambda Function

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

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 a

A component converting source code text into tokens (lexical analysis). The first stage of compilation. Identifies keywo

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

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

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

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.

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

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

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

Map (Data Structure)

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

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

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

Combining changes from one branch into another in Git. Fast-forward, merge commit, and squash merge are strategies. Merg

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

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.

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

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

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

Middleware (Code)

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

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

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

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

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

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

A single repository containing multiple projects or packages. Turborepo and Nx manage monorepos. Shared code, atomic com

Mutual Exclusion — a synchronization primitive preventing concurrent access to shared resources. Only one thread can hol

MVC Architecture

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

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

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

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).

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

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

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'.

Language features preventing null/undefined reference errors. Kotlin nullable types (?), Rust Option<T>, TypeScript stri

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

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, polymorp

Observer Pattern

A design pattern where objects (observers) subscribe to events from a subject. When state changes, all observers are not

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.

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

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

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

Pair Programming

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

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

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

A component analyzing token sequences to build an AST (syntax analysis). The second stage of compilation. Validates synt

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++.

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

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

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.

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

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

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

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

OOP principle where objects of different types respond to the same interface. Method overriding (runtime) and overloadin

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

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

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

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

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,

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

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

Protocol (Code)

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

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

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

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

A request to integrate code from one branch into another. Enables code review, discussion, and CI before merge. GitHub P

A FIFO (First In, First Out) data structure. Enqueue adds to back, dequeue removes from front. Used in task scheduling,

Queue (Data Structure)

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

A bug where behavior depends on the timing of concurrent operations. Two threads modifying the same variable. Mutexes, a

Read-Eval-Print Loop

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

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

A function calling itself to solve a problem by breaking it into smaller subproblems. Requires a base case to stop. Used

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

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

Regular Expression — a pattern for matching text strings. Powerful for validation, search, and replacement. /^[a-z]+@[a-

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

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

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

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

An interface following REST principles: stateless, resources via URLs, HTTP methods (GET, POST, PUT, DELETE). The most c

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

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.

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

Systems programming language focused on safety, speed, and concurrency. No garbage collector, ownership model prevents m

Managing distributed transactions as sequence of local transactions with compensations.

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

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

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

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

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

A synchronization primitive controlling access to a shared resource with a counter. Allows N concurrent accesses (unlike

Converting objects into a format for storage or transmission. JSON.stringify(), Protocol Buffers, and MessagePack. Deser

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

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

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

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

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

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 micr

Five OOP design principles: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency I

SOLID Principles

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

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

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

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

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

Spread Operator

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

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

A LIFO (Last In, First Out) data structure. Push adds, pop removes from the top. The call stack tracks function executio

Stack (Data Structure)

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

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.

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

A model with finite states and transitions between them. Used in UI (loading/error/success), game logic, and workflows.

State Management

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

Static Analysis

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

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

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. P

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

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

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

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

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.

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

A data structure mapping identifiers to their types, scopes, and memory locations. Used by compilers and interpreters. E

Synchronization

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

Operations executed sequentially — each waits for the previous one to finish. Simpler but can block execution on slow op

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

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

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

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

Template Method

Pattern defining algorithm skeleton, letting subclasses override steps.

Ternary Operator

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

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

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

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

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

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

A collection of pre-created threads ready to execute tasks. Avoids the overhead of creating threads for each task. Node.

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

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. Cri

Topological Sort

Ordering directed graph nodes so every edge goes from earlier to later. Used for task scheduling, dependency resolution,

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

Converts source code from one language to another at the same level. TypeScript to JavaScript, Babel for modern JS to ol

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

A tree data structure for efficient string prefix operations. Autocomplete, spell checkers, and IP routing use tries. O(

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

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

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

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

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

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

Ensuring operations are performed on compatible data types. Static typing (TypeScript, Rust) catches errors at compile t

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

A typed superset of JavaScript by Microsoft. Adds static types, interfaces, and enums. Catches bugs at compile time. The

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

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

Unsigned Integer

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

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

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.

The practice of tracking and managing code changes over time. Semantic Versioning (SemVer) uses MAJOR.MINOR.PATCH. Git i

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.

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

Waterfall Model

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

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

An HTTP callback notifying an application when an event occurs in another. Stripe sends webhooks when a payment is proce

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

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

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

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

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

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.

Advertise with Us

Put your brand in front of 10,000+ tech professionals

Native placements that feel like recommendations. Newsletter, articles, banners, and directory features.

Stay ahead of the tech curve

Join 10,000+ professionals who start their morning smarter. No spam, no fluff — just the most important tech developments, explained.