Glossary¶

116 terms. Each is defined twice — a plain-English version you can use in conversation, and a precise version you can rely on in an interview or a design review.

Categories: CI/CD · Concurrency · Containers · Data Structures · Functions · Infrastructure · Interview · OOP · Python Core · Reliability · System Design · Testing · Tooling · Typing · Web / API

*¶

*args / **kwargs¶

Functions

In plain English. Syntax to accept any number of positional or keyword arguments.

Precisely. *args packs extra positionals into a tuple; **kwargs packs keywords into a dict. Also used to unpack when calling.

A¶

ABC¶

OOP

In plain English. An abstract base class that defines an interface subclasses must implement.

Precisely. abc.ABC + @abstractmethod; can't be instantiated directly. Enforces a contract.

API¶

Web / API

In plain English. A defined way for programs to talk to each other.

Precisely. Application Programming Interface; over HTTP it's a set of endpoints with request/response contracts.

Artifact¶

CI/CD

In plain English. The packaged output of a build that gets deployed.

Precisely. Often a container image tagged by commit SHA; built once and promoted unchanged through environments.

async / await¶

Concurrency

In plain English. Keywords for writing concurrent I/O code that looks sequential.

Precisely. Coroutines scheduled by an event loop (asyncio); await yields control while waiting on I/O. Single-threaded concurrency.

B¶

Big-O notation¶

Interview

In plain English. A way to describe how an algorithm's cost grows with input size.

Precisely. Asymptotic upper bound; O(1), O(log n), O(n), O(n log n), O(n²). The shared language of efficiency in interviews.

BLUF¶

Interview

In plain English. "Bottom Line Up Front" — state your conclusion before the supporting detail.

Precisely. Top-down communication (pyramid principle); the most transferable consulting skill from interview to client work.

Bytecode¶

Python Core

In plain English. A lower-level form of your code the Python virtual machine actually executes.

Precisely. Portable instruction set produced by the compiler; inspect via the dis module. Cached in __pycache__.

C¶

Caching¶

System Design

In plain English. Storing results so repeat requests are served fast.

Precisely. Trades freshness for speed/cost; layers from in-process to Redis/CDN. Invalidation is the hard part.

CD¶

CI/CD

In plain English. Continuous Delivery/Deployment — getting changes to production safely and often.

Precisely. Delivery automates release readiness; Deployment pushes every passing change live automatically. Reduces batch size and risk.

CI¶

CI/CD

In plain English. Continuous Integration — merging and automatically testing code changes often.

Precisely. Every push triggers build + test, catching breakage early. Keeps the main branch always releasable.

Class¶

OOP

In plain English. A blueprint for creating objects that bundle data and behaviour.

Precisely. Defines attributes and methods; instances created by calling it. Supports inheritance and special (dunder) methods.

Closure¶

Functions

In plain English. A function that remembers variables from where it was defined.

Precisely. An inner function capturing names from its enclosing scope; the captured environment persists after the outer call returns.

Cloud¶

Infrastructure

In plain English. Computing resources rented on demand from a provider.

Precisely. AWS/GCP/Azure; elastic, pay-as-you-go infrastructure. Scales up and down without owning hardware.

Composition¶

OOP

In plain English. Building objects by combining other objects rather than inheriting.

Precisely. "Has-a" instead of "is-a"; often more flexible than deep inheritance. Favoured for decoupling.

Comprehension¶

Functions

In plain English. A compact way to build a list, dict, or set from a loop in one line.

Precisely. [f(x) for x in xs if cond]. Faster and clearer than manual append loops for simple transforms.

Comprehension vs generator¶

Data Structures

In plain English. List comprehension builds the whole result; a generator yields lazily.

Precisely. [...] materialises in memory; (...) creates a generator that computes on demand — choose by memory and reuse needs.

Concurrency vs parallelism¶

Concurrency

In plain English. Concurrency is juggling many tasks; parallelism is doing many at once.

Precisely. Concurrency = task switching (often I/O-bound); parallelism = simultaneous execution on multiple cores (CPU-bound).

Container¶

Containers

In plain English. A lightweight, isolated package of an app and its dependencies.

Precisely. Shares the host kernel but isolates process, filesystem, and network; far lighter than a VM. Built from an image.

Coroutine¶

Concurrency

In plain English. A function that can pause and resume, enabling cooperative concurrency.

Precisely. Defined with async def; driven by an event loop. Suspends at await points without blocking the thread.

Coverage¶

Testing

In plain English. A measure of how much of your code the tests actually exercise.

Precisely. Line/branch coverage via coverage.py; high coverage doesn't guarantee good tests but reveals untested paths.

D¶

Database replication¶

System Design

In plain English. Keeping copies of data on multiple servers.

Precisely. Primary handles writes; read replicas scale reads and add redundancy. Introduces replication lag to reason about.

Dataclass¶

OOP

In plain English. A decorator that auto-generates boilerplate for classes that mainly hold data.

Precisely. @dataclass writes __init__, __repr__, __eq__; supports defaults, ordering, immutability (frozen).

Decorator¶

Functions

In plain English. A wrapper that adds behaviour to a function without changing its code.

Precisely. Callable taking a function and returning a replacement; @deco syntax. Used for logging, caching, auth, timing.

Dictionary¶

Data Structures

In plain English. A collection of key→value pairs for fast lookup by key.

Precisely. Hash map; average O(1) get/set/delete. Insertion-ordered since 3.7. Keys must be hashable.

Direct Connect / interconnect¶

Infrastructure

In plain English. A private, dedicated network link between cloud and on-prem.

Precisely. High-throughput, low-latency private connectivity (AWS Direct Connect, Azure ExpressRoute, GCP Interconnect); the bridge in hybrid setups.

Distributed tracing¶

Reliability

In plain English. Following a single request as it travels across many services.

Precisely. Correlated spans with a trace ID reveal where latency and errors occur in a microservice call chain (e.g. OpenTelemetry).

Dockerfile¶

Containers

In plain English. A recipe describing how to build a container image.

Precisely. Ordered instructions (FROM, COPY, RUN, CMD); each creates a cached layer. Multi-stage builds keep final images small.

Duck typing¶

Python Core

In plain English. If it behaves like what you need, its actual type doesn't matter.

Precisely. "If it walks like a duck..." — code depends on methods/attributes (a protocol), not on inheritance or a declared type.

Dunder method¶

OOP

In plain English. Special methods with double underscores that hook into Python syntax.

Precisely. e.g. __init__, __len__, __eq__, __iter__. Let your objects work with built-in operations.

Dynamic typing¶

Python Core

In plain English. Variables aren't tied to a type; they're names bound to objects that carry the type.

Precisely. Type checks happen at runtime; names can rebind to objects of any type. Contrast static typing where variables have fixed types.

E¶

Encapsulation¶

OOP

In plain English. Keeping an object's internal details hidden behind a clean interface.

Precisely. Convention-based (_private); properties expose controlled access. Reduces coupling to internals.

Error budget¶

Reliability

In plain English. The amount of unreliability you're allowed before you must slow down.

Precisely. 100% minus the SLO; spending it gates risky releases vs reliability work. Balances velocity and stability.

Event loop¶

Concurrency

In plain English. The scheduler that runs async tasks, resuming each when its I/O is ready.

Precisely. Core of asyncio; multiplexes many coroutines on one thread by switching at await boundaries.

Eventual consistency¶

System Design

In plain English. Replicas converge to the same value over time, not instantly.

Precisely. Trades immediate consistency for availability and partition tolerance; acceptable when slight staleness is fine.

F¶

FastAPI¶

Web / API

In plain English. A modern Python framework for building fast, typed web APIs.

Precisely. ASGI framework using type hints for validation (Pydantic) and auto OpenAPI docs. High performance, async-first.

First-class function¶

Functions

In plain English. Functions are values you can pass around, return, and store.

Precisely. Can be assigned to variables, passed as arguments, returned from other functions, and stored in data structures.

Fixture¶

Testing

In plain English. Reusable setup (and teardown) shared across tests.

Precisely. @pytest.fixture provides resources like a temp dir or DB; injected by parameter name. Scoped per function/module/session.

Formatter¶

Tooling

In plain English. A tool that rewrites code into a consistent style automatically.

Precisely. e.g. ruff/black; removes style debates and diff noise by enforcing one canonical layout.

G¶

Garbage collection¶

Python Core

In plain English. Python automatically frees memory you're no longer using.

Precisely. Primary mechanism is reference counting, with a cyclic collector for reference cycles. Managed by the gc module.

Generator¶

Functions

In plain English. A function that produces values one at a time, on demand, instead of all at once.

Precisely. Uses yield; returns a lazy iterator that suspends and resumes state. Memory-efficient for large or infinite streams.

Generic¶

Typing

In plain English. A type parameterised by another type, like a list of ints.

Precisely. list[int], dict[str, float]. PEP 585 allows builtin generics; TypeVar defines your own.

GIL¶

Concurrency

In plain English. A lock that lets only one thread run Python bytecode at a time.

Precisely. Global Interpreter Lock; simplifies memory management but limits CPU-bound threading. 3.13 introduces an experimental free-threaded build.

GitHub Actions¶

CI/CD

In plain English. GitHub's built-in system for automating CI/CD with YAML workflows.

Precisely. Event-triggered jobs run on hosted or self-hosted runners; reusable actions from a marketplace. Config in .github/workflows.

GitOps¶

Infrastructure

In plain English. Using Git as the single source of truth for infrastructure and deployments.

Precisely. A controller (e.g. Argo CD) continuously reconciles the cluster to match the repo; every change is a reviewed commit.

Golden signals¶

Reliability

In plain English. The four metrics that best summarise service health.

Precisely. Latency, traffic, errors, saturation; alert on these symptoms rather than on low-level causes.

H¶

Hash map pattern¶

Interview

In plain English. Using a dictionary for O(1) lookups to avoid nested loops.

Precisely. Trades space for time; turns many O(n²) brute-force problems into O(n). The most common interview tool.

Hashable¶

Data Structures

In plain English. An object usable as a dict key or set member because it has a stable hash.

Precisely. Implements __hash__ and __eq__; value must not change over its lifetime. Immutables are hashable by default.

HTTP method¶

Web / API

In plain English. The verb describing what a request wants to do.

Precisely. GET (read), POST (create), PUT/PATCH (update), DELETE (remove); each carries semantic and idempotency expectations.

Hybrid¶

Infrastructure

In plain English. An architecture that spans both cloud and on-premises as one system.

Precisely. Place each workload by data gravity and constraints; bridge with a private link, unified identity, and shared observability.

I¶

IaC¶

Infrastructure

In plain English. Infrastructure as Code — defining servers and resources in version-controlled files.

Precisely. Declarative (Terraform) or imperative; reproducible, reviewable, auditable infrastructure. Eliminates manual click-ops.

Idempotency¶

System Design

In plain English. An operation that's safe to repeat without changing the result.

Precisely. Critical for retries and at-least-once delivery; keys dedupe repeated requests so a double-send is harmless.

Image¶

Containers

In plain English. A read-only template used to create containers.

Precisely. Layered filesystem built from a Dockerfile; tagged and stored in a registry. "Build once, run anywhere."

Inheritance¶

OOP

In plain English. A class can build on another, reusing and extending its behaviour.

Precisely. Subclass inherits attributes/methods; override to specialise. Python supports multiple inheritance with MRO.

Instance¶

OOP

In plain English. A concrete object made from a class.

Precisely. Has its own attribute namespace (__dict__); self refers to it inside methods.

Interpreter¶

Python Core

In plain English. The program that reads your Python code and runs it line by line.

Precisely. CPython compiles source to bytecode (.pyc) and executes it on a stack-based virtual machine; no separate compile step is needed.

Iterator¶

Functions

In plain English. An object you can step through one item at a time.

Precisely. Implements __iter__ and __next__; raises StopIteration when exhausted. The protocol behind for.

J¶

JSON¶

Web / API

In plain English. A lightweight, human-readable format for exchanging structured data.

Precisely. Key/value text format; json module parses to dicts/lists. The lingua franca of web APIs.

K¶

Kubernetes¶

Containers

In plain English. A system that runs and manages containers across many machines.

Precisely. Orchestrator handling scheduling, scaling, self-healing, and networking; declarative desired-state via manifests. Often "k8s."

L¶

Lambda¶

Functions

In plain English. A small anonymous function written inline.

Precisely. Single-expression function: lambda x: x + 1. Handy as a short callback; named def preferred for anything non-trivial.

Linter¶

Tooling

In plain English. A tool that flags suspicious or non-idiomatic code without running it.

Precisely. Static analysis for style, unused names, likely bugs. Enforced in CI to keep a codebase consistent.

List¶

Data Structures

In plain English. An ordered, changeable collection of items.

Precisely. Dynamic array; O(1) index and append (amortised), O(n) insert/delete at front. Mutable and ordered.

Load balancer¶

System Design

In plain English. A component that spreads incoming traffic across many servers.

Precisely. Distributes requests for throughput and availability; health-checks backends and removes unhealthy ones.

M¶

Message queue¶

System Design

In plain English. A buffer that decouples producers from consumers of work.

Precisely. e.g. Kafka, SQS, RabbitMQ; absorbs bursts, smooths load, and enables async, resilient processing.

Mock¶

Testing

In plain English. A stand-in object that simulates a real dependency in tests.

Precisely. unittest.mock; records calls and returns canned values. Isolates the unit under test from I/O or services.

Mutable vs immutable¶

Python Core

In plain English. Some objects can be changed in place (lists); others cannot (strings, tuples).

Precisely. Immutables (int, str, tuple, frozenset) are hashable and safe as dict keys; mutables (list, dict, set) are not hashable.

mypy¶

Typing

In plain English. A tool that reads your type hints and flags type mismatches before you run the code.

Precisely. Static type checker; catches a class of bugs at "compile" time. Configurable strictness; integrates with editors and CI.

O¶

Object¶

Python Core

In plain English. Every value in Python — a number, string, function — is an object with identity, type, and value.

Precisely. Has a unique id(), a type, and references. Everything is first-class, including classes and functions.

Observability¶

Reliability

In plain English. Being able to understand a system's internal state from its outputs.

Precisely. The three pillars: metrics, logs, and traces; lets you ask new questions of a live system without redeploying.

On-premises¶

Infrastructure

In plain English. Infrastructure you own and run in your own data center.

Precisely. Full control and data residency; fixed capacity and operational burden. Common for regulated workloads.

OpenTelemetry¶

Reliability

In plain English. A vendor-neutral standard for collecting metrics, logs, and traces.

Precisely. One instrumentation API/SDK that exports to any backend; avoids lock-in across observability vendors.

Optional¶

Typing

In plain English. A value that may be a given type or None.

Precisely. Optional[X] is X | None. Forces explicit handling of the absent case.

Orchestration¶

Containers

In plain English. Coordinating many containers: placement, scaling, healing, and networking.

Precisely. What Kubernetes provides; turns individual containers into a resilient, scalable system.

ORM¶

Web / API

In plain English. A tool that maps database rows to Python objects.

Precisely. Object-Relational Mapper (e.g. SQLAlchemy); write Python instead of raw SQL, with an escape hatch for complex queries.

P¶

Parametrize¶

Testing

In plain English. Running the same test with many input sets.

Precisely. @pytest.mark.parametrize; expands one test into many cases, reducing duplication.

PEP¶

Python Core

In plain English. A Python Enhancement Proposal — the design documents that shape the language.

Precisely. PEP 8 (style), PEP 484 (type hints), PEP 20 (Zen of Python). The process by which Python evolves.

pip¶

Tooling

In plain English. Python's standard package installer.

Precisely. Installs from PyPI into an environment; resolves dependencies. Often paired with a virtual environment.

Pipeline¶

CI/CD

In plain English. The automated sequence a code change flows through to reach production.

Precisely. Stages like build → test → scan → deploy; defined as code. The backbone of modern delivery.

Pod¶

Containers

In plain English. The smallest deployable unit in Kubernetes — one or more containers together.

Precisely. Shares network and storage; usually one main container. Managed by higher-level controllers (Deployments).

Polymorphism¶

OOP

In plain English. Different objects responding to the same call in their own way.

Precisely. Same interface, many implementations; enabled by duck typing or shared base classes/protocols.

Pre-commit¶

Tooling

In plain English. Automated checks that run on your code before each commit.

Precisely. A framework wiring linters/formatters/type-checks into git hooks, catching issues before they reach CI.

Process¶

Concurrency

In plain English. An independent program with its own memory, used for true parallelism.

Precisely. multiprocessing sidesteps the GIL by running separate interpreters; communication via pipes/queues incurs serialisation cost.

Protocol¶

Typing

In plain English. Defines a set of methods a type must have, without requiring inheritance.

Precisely. PEP 544 structural typing; a class satisfies a Protocol just by having the right methods — static duck typing.

Pydantic¶

Web / API

In plain English. A library that validates and parses data using Python type hints.

Precisely. Defines models whose fields are validated at runtime; powers FastAPI request/response handling and settings.

PyPI¶

Tooling

In plain English. The public repository where Python packages are published.

Precisely. Python Package Index; pip install pulls from it. Verify package provenance to avoid supply-chain risks.

pyproject.toml¶

Tooling

In plain English. The single config file describing a modern Python project.

Precisely. PEP 518/621 standard; declares build system, metadata, dependencies, and tool settings. Replaces setup.py for most needs.

pytest¶

Testing

In plain English. The popular framework for writing and running Python tests.

Precisely. Plain assert-based tests, powerful fixtures, parametrisation, and a rich plugin ecosystem.

Q¶

Quality gate¶

CI/CD

In plain English. An automated check that must pass before code can proceed.

Precisely. Tests, linting, type checks, security scans, coverage thresholds; blocks bad changes from advancing.

R¶

Race condition¶

Concurrency

In plain English. A bug where the outcome depends on unpredictable timing between tasks.

Precisely. Occurs when concurrent code reads/writes shared state without synchronisation; fixed with locks, queues, or immutability.

Reference semantics¶

Python Core

In plain English. Assignment copies a reference to an object, not the object itself.

Precisely. b = a makes both names point to one object; mutating through one is visible through the other. Use copy/deepcopy to duplicate.

Registry¶

Containers

In plain English. A store where container images are pushed and pulled.

Precisely. e.g. Docker Hub, GHCR, ECR; the distribution point in a pipeline. Scan images here for vulnerabilities.

REPL¶

Python Core

In plain English. An interactive prompt where you type code and see results immediately.

Precisely. Read-Eval-Print Loop; python or enhanced shells like IPython. Ideal for exploration and debugging.

REST¶

Web / API

In plain English. A common style for web APIs built around resources and HTTP verbs.

Precisely. Representational State Transfer; uses GET/POST/PUT/DELETE on URLs, is stateless, and returns JSON. Conventional, not a strict standard.

Rollback¶

CI/CD

In plain English. Reverting to a previous known-good version when a deploy goes wrong.

Precisely. Re-deploy the prior image/release; fast rollback is why immutable, versioned artifacts matter.

ruff¶

Tooling

In plain English. A very fast linter and formatter that catches style and bug issues.

Precisely. Rust-based; consolidates flake8, isort, black, and many plugins. Runs in milliseconds, ideal for pre-commit and CI.

Runner¶

CI/CD

In plain English. The machine that executes your pipeline jobs.

Precisely. Hosted (provider-managed) or self-hosted (your own hardware, e.g. on-prem). Self-hosted runners enable hybrid reach.

S¶

Scalability¶

System Design

In plain English. A system's ability to handle growing load gracefully.

Precisely. Vertical (bigger machine) vs horizontal (more machines); horizontal scaling underpins most large systems.

Secret management¶

Infrastructure

In plain English. Safely storing and injecting passwords, keys, and tokens.

Precisely. Vaults (HashiCorp Vault, cloud secret managers) keep secrets out of code; injected at runtime with rotation and audit.

Set¶

Data Structures

In plain English. An unordered collection of unique items.

Precisely. Hash-based; O(1) membership tests and fast union/intersection/difference. Elements must be hashable.

Sharding¶

System Design

In plain English. Splitting one large dataset across multiple databases.

Precisely. Partition by a key so each shard holds a slice; scales writes/storage beyond one machine at the cost of complexity.

SLI / SLO / SLA¶

Reliability

In plain English. Indicator (measured), Objective (target), Agreement (contract) for reliability.

Precisely. SLI = a measured signal (e.g. error rate); SLO = the internal target; SLA = the external promise with consequences.

Slice¶

Data Structures

In plain English. A way to grab a sub-section of a sequence.

Precisely. seq[start:stop:step]; produces a new sequence. Negative indices count from the end.

Sliding window¶

Interview

In plain English. Maintaining a moving range over a sequence to track a running property.

Precisely. O(n) for substrings/subarrays with a constraint; expand and shrink the window instead of re-scanning.

SOLID¶

OOP

In plain English. Five design principles for maintainable object-oriented code.

Precisely. Single-responsibility, Open-closed, Liskov substitution, Interface-segregation, Dependency-inversion.

SQL¶

Web / API

In plain English. The language for querying and updating relational databases.

Precisely. Structured Query Language; SELECT/INSERT/UPDATE/DELETE over tables. Parameterise queries to prevent injection.

STAR method¶

Interview

In plain English. A structure for answering behavioural interview questions.

Precisely. Situation, Task, Action, Result; keeps stories concise and focused on your individual contribution and outcome.

Status code¶

Web / API

In plain English. A number summarising how an HTTP request went.

Precisely. 2xx success, 3xx redirect, 4xx client error, 5xx server error. e.g. 200 OK, 404 Not Found, 500 Server Error.

System design interview¶

Interview

In plain English. An open-ended round where you architect a system and defend trade-offs.

Precisely. Framework: requirements → estimate → high-level → deep-dive → scale → wrap-up. Communication weighs as much as the diagram.

T¶

Terraform¶

Infrastructure

In plain English. A popular tool for declaring cloud and on-prem infrastructure as code.

Precisely. Provider-agnostic; you declare desired state and it computes a plan to reach it. State file tracks reality.

Thread¶

Concurrency

In plain English. A lightweight unit of execution sharing memory with others in a process.

Precisely. Good for I/O-bound work; the GIL serialises CPU-bound Python. Shared state needs locks to avoid races.

Tuple¶

Data Structures

In plain English. An ordered collection that can't be changed after creation.

Precisely. Immutable sequence; hashable if its elements are. Used for fixed records and as dict keys.

Two pointers¶

Interview

In plain English. Walking a sequence with two indices to solve it in one pass.

Precisely. O(n) technique for sorted arrays, pair-finding, and in-place partitioning; avoids extra passes.

Type hint¶

Typing

In plain English. Optional annotations that say what type a variable or function expects.

Precisely. PEP 484 syntax (x: int, -> str); ignored at runtime but checked by tools like mypy. Improves tooling and readability.

U¶

Unit test¶

Testing

In plain English. A test of one small piece of code in isolation.

Precisely. Fast, deterministic, dependency-free; the base of the test pyramid. Mocks replace external systems.

uv¶

Tooling

In plain English. A fast, all-in-one tool for managing Python versions, environments, and packages.

Precisely. Rust-based (Astral); replaces pip/venv/pip-tools/pyenv workflows with one fast resolver and installer. Lockfile-driven.

V¶

Virtual environment¶

Tooling

In plain English. An isolated Python with its own packages, separate from the system.

Precisely. Created via venv or uv; prevents dependency conflicts between projects. Activated per shell.