Software engineering glossary

745 short definitions of terms that come up in software engineering interviews.

enter / exit

The two methods that make an object a context manager for with. __enter__ runs at the start; __exit__ always runs at the end, even after an error.

eq / hash

__eq__ defines ==. If you define it, also define __hash__ consistently (equal objects must have equal hashes) or the object misbehaves in sets and as dict keys.

init

The initializer method that runs when a new object is created. It sets the starting attributes: def __init__(self, name): self.name = name.

iter / next

The iterator protocol. __iter__ returns the iterator; __next__ returns the next item and raises StopIteration when there are no more.

repr vs str

__repr__ gives an exact, developer-oriented description of an object; __str__ gives friendly text for users. print() uses __str__; lists and the debugger use __repr__.

slots

A class setting that lists the only attribute names its objects may have. It removes the per-object dictionary to save memory.

.class file

A compiled Java file that contains bytecode. The JVM loads and runs it on any operating system.

@Autowired

Asks Spring to inject a dependency. Prefer constructor injection; with a single constructor @Autowired is optional.

@Cacheable

Caches the result of a method by its arguments. The next call with the same arguments returns the cached value without running the method.

@Configuration

A class that declares beans with @Bean methods.

@ConfigurationProperties

Binds groups of properties from application.yml to a typed Java class, instead of reading single values with @Value.

@ControllerAdvice

A class that applies exception handling (and other advice) to all controllers in one place.

@Entity

Marks a class as a JPA entity: Hibernate maps it to a database table and its fields to columns.

@EntityGraph / JOIN FETCH

Ways to load an entity together with its relations in a single query, which fixes the N+1 problem.

@Override

Tells the compiler that this method must override one from a parent class or interface. If the signature does not match, compilation fails.

@PathVariable

Binds a part of the URL path to a method parameter: /users/{id}.

@property

Turns a method into an attribute you read without parentheses: circle.area. Lets you compute or validate values while keeping simple syntax.

@RequestBody

Binds the HTTP request body (JSON) to a Java method parameter.

@RestController

A controller whose methods return data written straight to the HTTP response body (usually JSON), rather than a view name.

@Transactional

Runs a method inside a database transaction: commit on success, roll back on a RuntimeException by default.

/ vs // vs %

In Python 3, / always gives a float (7 / 2 is 3.5). // is floor division and rounds down (7 // 2 is 3). % gives the remainder (7 % 2 is 1).

`.gitignore`

A file listing patterns of files Git should not track, such as build output, IDE settings and secrets.

== vs === (JavaScript)

== converts types before comparing (0 == "" is true). === compares value AND type without converting (0 === "" is false). Prefer ===.

ABC (Abstract Base Class)

A base class that cannot be instantiated and forces subclasses to implement certain methods (marked with @abstractmethod).

Abstract class

A class that cannot be instantiated directly. It can hold fields, constructors and ready methods, plus abstract methods that subclasses must implement.

Abstract Factory

A pattern with an interface that creates families of related objects without naming their concrete classes.

Abstraction

Showing only what is essential and hiding the details. You drive a car with a wheel and pedals without knowing how the engine works.

Access control

The rules and checks that decide who can see or change which data and features.

Access modifier

A keyword that controls who can see a class member: public (all), protected (package and subclasses), none (package only), private (same class only).

Accessibility (a11y)

Making apps usable by everyone, including people using keyboards, screen readers or with visual impairments.

ACID

Four transaction guarantees: Atomicity (all or nothing), Consistency (rules hold), Isolation (no interference), Durability (committed data survives crashes).

Adapter pattern

A wrapper that converts one interface into another that your code expects, like a travel plug adapter.

Adjacency list

A graph representation where each node maps to a list of its neighbors: {"A": ["B", "C"]}.

AES

Advanced Encryption Standard: the standard symmetric cipher. One key encrypts and decrypts. Used by TLS, disk encryption and cloud storage.

Aggregate function

A function that summarizes many rows into one value: COUNT, SUM, AVG, MIN, MAX.

Agile

A way of building software in short iterations with frequent feedback, valuing working software and responding to change over rigid plans.

AKS

Azure Kubernetes Service: Microsoft's managed Kubernetes. Azure runs the control plane for you.

ALB / NLB

AWS load balancers. ALB works at layer 7 (HTTP) and can route by path or host. NLB works at layer 4 (TCP/UDP) for very high speed.

Algorithm

A finite, ordered set of steps that solves a problem or performs a task.

Amazon EC2

AWS virtual servers (virtual machines) that you configure and manage.

Amazon S3

AWS object storage service for files of any size, organized in buckets.

Amortized cost

The average cost per operation over a long sequence, when rare expensive operations are balanced by many cheap ones.

Annotation

A label starting with @ attached to code (@Override, @Service) that the compiler or a framework reads to change behavior.

AOP (Aspect-Oriented Programming)

A technique to apply cross-cutting behavior (logging, security, transactions) around many methods without editing them.

API

Application Programming Interface: the set of operations a system exposes for other programs, and the format to use them. A web API is used over HTTP.

API gateway

A single entry point in front of backend services that handles routing, authentication, rate limiting and TLS.

API versioning

Labeling API versions (e.g. /v1, /v2) so you can introduce breaking changes without breaking existing clients.

application.yml / application.properties

Spring Boot's main config file: server port, database URL and any custom settings. Profiles can override it for each environment.

Arrange-Act-Assert

A test structure: prepare (arrange), perform the action (act), check the result (assert).

Array

Items stored next to each other in memory, accessed by index in O(1). A Python list is a dynamic array that grows automatically.

ArrayDeque

A fast resizable-array deque in Java. It is the usual choice for a stack or a queue instead of Stack or LinkedList.

ArrayList

A List backed by a resizable array: fast access by index, fast appends, compact memory. The default choice for lists.

Arrow function

Short JS function syntax: x => x * 2. It does not have its own this.

Assertion

A statement in a test that checks a condition; if it is false, the test fails.

Assignment

age = 30 creates the name age and makes it refer to the value 30. Python variables are labels attached to objects, not boxes that hold values.

Asymmetric cryptography

Uses a key pair: a public key (shareable) and a private key (secret). Used for key exchange and digital signatures (RSA, ECDSA).

async / await

async def defines a function that can pause. await pauses it until a slow operation finishes, letting other tasks run meanwhile.

asyncio.gather

Runs several coroutines concurrently and waits for all of them, returning their results in order.

asyncio.to_thread

Runs a blocking function in a worker thread so that it does not freeze the event loop.

Atomic classes

AtomicInteger, AtomicLong... provide thread-safe operations such as incrementAndGet() without explicit locks.

Attribute

A value stored on an object and accessed with a dot: user.name. Methods are attributes too.

Authentication

Verifying who a user or system is (password, token, MFA).

Authorization

Deciding what an authenticated user is allowed to do or access.

Auto-configuration

Spring Boot's mechanism to register beans automatically based on the libraries on the classpath and your properties; it backs off when you define your own.

Autoboxing / unboxing

Automatic conversion between a primitive and its wrapper object (int to Integer and back). Unboxing a null wrapper throws NullPointerException.

AutoCloseable

An interface with one method, close(). Any class implementing it can be used in try-with-resources.

Autoscaling

Automatically adding or removing instances or Pods based on load.

autospec

An option for mocks to copy the real object's method signatures, so invalid calls fail in tests.

Availability

The share of time a system is up and answering requests, often written as 'nines' (99.9%).

Availability Zone

An isolated data center (or group) within a cloud region, with independent power and network.

AWS (Amazon Web Services)

Amazon's cloud platform: rentable servers (EC2), storage (S3), databases (RDS), networking (VPC) and hundreds of other services, billed by usage.

AWS to Azure mapping

EC2 = VM; S3 = Blob Storage; Lambda = Functions; EKS = AKS; RDS = Azure SQL; DynamoDB = Cosmos DB; IAM = Entra ID + RBAC; CloudWatch = Azure Monitor.

Azure resource group

A logical container for resources that share a lifecycle. Subscriptions hold resource groups; resource groups hold resources.

B-tree

The balanced tree structure most database indexes use. It keeps values sorted so lookups, ranges and sorting take about log(n) steps.

Backend

The part of an application that runs on servers: business logic, database access, security checks and APIs. Users never see it directly.

Background job

Work that runs outside the request/response cycle, in a separate worker process, e.g. sending emails or building reports.

Backtracking

Exploring all candidate solutions by making a choice, recursing, then undoing the choice and trying the next one.

Base case

The simplest input of a recursive function, answered directly without another recursive call. It stops the recursion.

Bean

An object created and managed by the Spring container. You get beans by annotating classes (@Component, @Service) or declaring @Bean methods.

Bean scope

How many instances of a bean exist. Default singleton (one per container); also prototype, request, session.

Bean Validation

Declarative rules on fields (@NotBlank, @Email, @Size) checked when you add @Valid to a parameter.

Behavioral interview

Interview questions about how you acted in real past situations. Answer with a structured story such as STAR.

BFS (breadth-first search)

Exploring a graph level by level using a queue: all nodes 1 step away, then 2 steps, etc. Finds shortest paths in unweighted graphs.

Big-O notation

A way to describe how an algorithm's time or memory grows as the input size n grows, ignoring constants: O(1), O(log n), O(n), O(n log n), O(n²).

Binary search

Finding an item in a SORTED list by repeatedly checking the middle and discarding half. O(log n).

Binary search tree (BST)

A tree where each node has up to two children, all smaller keys on the left and bigger keys on the right. Fast search if balanced.

Bit manipulation

Working directly with the binary digits of numbers using operators like & (and), | (or), ^ (xor), << and >> (shifts).

Bitwise operators

& AND, | OR, ^ XOR, << and >> shift bits. n & (n - 1) clears the lowest set bit, so it is 0 only for powers of two.

Blocking call

A call that makes the thread wait and do nothing else until it finishes, like time.sleep() or requests.get(). Inside async code it freezes everything.

Blue-green deployment

Two identical environments; deploy to the idle one, then switch all traffic to it at once. Easy rollback.

BOM / parent POM

A pom that fixes the versions of many libraries so they are compatible and you do not repeat version numbers.

Bottleneck

The slowest or most limited component, which caps the performance of the whole system.

box-sizing: border-box

With border-box, width includes padding and border, so a 200px box stays 200px. With the default content-box, padding and border are added on top.

Branch

An independent line of development in Git. Lets you work on a feature without touching the main code until it is merged.

Branching strategy

A team's rules for branches: Git Flow (develop/release/hotfix) or trunk-based (frequent merges to main).

Brute force

Solving a problem by trying every possibility. Simple and correct, but often too slow for large inputs.

Brute-force attack

Trying huge numbers of possible passwords or keys until one works.

Bug / debugging

A bug is a flaw that makes software behave wrongly. Debugging is finding and fixing its cause.

Builder

A pattern that constructs a complex object step by step: Request().url(u).header(h).timeout(5).build().

Built-in exceptions

ValueError: right type, bad value. TypeError: wrong type. KeyError: missing dictionary key. IndexError: index out of range.

Bundler (Vite, webpack)

A build tool that transpiles, combines and minifies source files into optimized files for the browser, with a hot-reload dev server.

Bytecode

The intermediate, platform-neutral instructions that javac produces from your .java files (stored in .class files). The JVM runs it.

Cache

A fast storage layer (usually memory) holding copies of data that is expensive to fetch or compute.

Cache stampede

Many requests miss the cache at the same moment (often when a hot key expires) and all hit the database together.

Cache-aside

The app checks the cache first; on a miss it loads from the database and saves the result in the cache.

Call stack

The memory area that keeps track of active function calls. Each call adds a frame; returning removes it. Too many nested calls → stack overflow / RecursionError.

Callback

A function you pass to other code so it can call it later, e.g. when a click happens or data arrives.

Canary release

Sending a small percentage of traffic to a new version first, watching metrics, then increasing gradually.

CAP theorem

In a distributed system, during a network partition you must choose between Consistency (everyone sees the latest data) and Availability (every request gets an answer).

Career goals

Answer with growth in skills and responsibility (deeper technical expertise, leading small projects) that fits what the company offers. Be honest, not rehearsed.

CDN

Content Delivery Network: servers around the world that cache static content close to users.

Chain of Responsibility

A request passes through a sequence of handlers; each may process it or pass it on. Servlet filters work this way.

Checked exception

An exception the compiler forces you to catch or declare with throws, such as IOException.

CI/CD pipeline

An automated sequence of steps (lint, test, build, deploy) triggered by code changes.

CI/CD tools

Jenkins, GitHub Actions, GitLab CI and Azure DevOps Pipelines run build, test and deploy steps defined as code.

CIA triad

The three goals of information security: Confidentiality, Integrity, Availability.

CIDR notation

Writing a network range as address/prefix, e.g. 10.0.1.0/24 = 256 addresses. A smaller prefix number means a bigger network.

Circuit breaker

A pattern that stops calling a failing service for a while after repeated errors, failing fast instead of waiting for timeouts.

Class

A blueprint that defines what data (attributes) and behavior (methods) its objects have.

Client-server model

Clients (browsers, apps) send requests over the network; servers process them and send responses.

Client-side vs server-side

Client-side code runs on the user's device (usually the browser). Server-side code runs on a server and answers requests.

Closure

A function that remembers variables from the place where it was created, even after that outer function has finished. It remembers the variable itself, not a frozen copy of its value.

Cloud computing

Renting computing resources and managed services from a provider (AWS, Azure, GCP) on demand over the internet.

Cloud provider

Company that rents computing resources over the internet. Largest: AWS, Microsoft Azure, Google Cloud.

CLS (Cumulative Layout Shift)

A Core Web Vitals metric that measures how much the page layout jumps while it loads. Lower is better.

Cluster / node / Pod

Cluster: the set of machines managed by Kubernetes. Node: one machine. Pod: smallest deployable unit, running one or more containers.

Code review

A teammate reads your changes before they are merged, to catch problems and share knowledge.

Code smell

A sign in the code that suggests a deeper design problem: huge classes, long functions, duplicated logic, too many parameters.

Cohesion

How closely the parts inside a module belong together. High cohesion = a focused module with one clear purpose.

Collections Framework

Java's built-in set of data structures and interfaces: List, Set, Map, Queue, Deque and their implementations (ArrayList, HashSet, HashMap, ArrayDeque...).

Command pattern

Wraps a request as an object, so it can be queued, logged, retried or undone. Natural fit for undo/redo and job queues.

Commit

A saved snapshot of changes in a Git repository, with an ID and a message describing the change.

Communicating with non-technical people

Start from the goal and the impact, avoid jargon, use an analogy or example, and check understanding. Say what you need from them.

Comparable

An interface with compareTo that gives a class its single natural ordering.

Comparator

A separate object with compare(a, b) defining a custom ordering, e.g. sort people by age or by name.

Comparing with NULL

NULL means 'unknown', so = NULL is never true. Use IS NULL and IS NOT NULL.

Compiler

A program that translates source code into another form, for example Java source into bytecode, or TypeScript into JavaScript.

CompletableFuture

A result that will be available later, with methods to chain steps (thenApply, thenCompose, thenCombine) without blocking.

Component

A reusable, self-contained piece of UI. In React, a function that receives props and returns JSX.

Component scan

Spring searching a package and its sub-packages for stereotype-annotated classes to register as beans.

Composite

A tree structure where individual items and groups share one interface, like files and folders.

Composite index

An index on several columns in a specific order, e.g. (last_name, first_name). Useful only when queries filter on its leftmost columns.

Composition

Building an object from other objects it holds as attributes ('has-a'): a Car has an Engine.

Concurrency vs parallelism

Concurrency: handling several tasks in overlapping time by switching between them (one cook, many pots). Parallelism: literally running at the same instant on several CPU cores (many cooks).

ConcurrentHashMap

A thread-safe Map built for many threads at once, with non-blocking reads and fine-grained locking on writes. Offers atomic methods like merge and computeIfAbsent.

ConcurrentModificationException

Thrown when a collection is structurally modified while an iterator is walking it (even in one thread). Use removeIf or Iterator.remove instead.

ConfigMap

A Kubernetes object holding non-sensitive configuration injected into Pods as environment variables or files.

Conflict resolution

Listen first, find the shared goal, separate the problem from the person, bring data, agree on a next step. Show respect and a calm result, not who won.

conftest.py

A pytest file whose fixtures are automatically available to all tests in its folder and subfolders.

Connection pool

A set of already-open database connections that the app borrows and returns, instead of opening a new one for each query.

Consistency (distributed)

Every read sees the most recent write, no matter which server answers.

Consistent hashing

A way to assign keys to servers on a 'ring' so that adding or removing a server moves only a small fraction of keys.

Constructor injection

Providing dependencies as constructor parameters. Allows final fields, clear requirements and easy unit testing.

Container

A lightweight, isolated process packaged with its app and dependencies, sharing the host's operating system kernel.

Container registry

A service storing container images for push/pull: Docker Hub, AWS ECR, Azure ACR.

Content-Security-Policy

An HTTP header listing which sources the browser may load scripts, styles and other content from.

Content-Type header

A header that says what format the body has, such as application/json.

Context manager

An object used with with that runs setup code at the start and cleanup code at the end, even if an error occurs. Files, locks and DB transactions use it.

Continuous Delivery / Deployment

Automating the release process so changes can go (Delivery, with approval) or do go (Deployment, automatically) to production.

Continuous Integration

Automatically building and testing every code change pushed to the shared repository.

Contract test

A test that checks a service's API still matches what its consumers expect.

Controlled input

A form input whose value comes from React state and is updated through onChange.

Core Web Vitals

Google's user-experience metrics: LCP (loading), INP (responsiveness), CLS (visual stability).

Coroutine

The object created by calling an async def function. It is a pausable piece of work that only runs when awaited or scheduled.

CORS

Cross-Origin Resource Sharing: headers by which a server tells browsers which other websites (origins) may read its responses.

COUNT(*) vs COUNT(column)

COUNT(*) counts all rows. COUNT(column) counts only rows where that column is NOT NULL.

Coupling

How much one module depends on the internals of another. Low coupling = you can change one without breaking the other.

Covering index

An index containing all columns a query needs, so the database can answer without reading the table.

CPU

Central Processing Unit: the chip that runs program instructions. 'CPU-bound' work is limited by how fast the chip can calculate.

CPU-bound

Work that spends its time calculating (image processing, math loops, compression). It is limited by processor speed, not by waiting.

CQRS

Command Query Responsibility Segregation: separate models (and often stores) for writing data and for reading it.

CrashLoopBackOff

A Pod state meaning the container keeps crashing and Kubernetes retries with increasing delays.

Credential stuffing

Automatically trying username/password pairs leaked from other sites, exploiting password reuse.

CRUD

The four basic data operations: Create, Read, Update, Delete (SQL: INSERT, SELECT, UPDATE, DELETE).

CSRF (Cross-Site Request Forgery)

A malicious site makes the victim's browser send a request to another site where they are logged in, using their cookies.

CSS

Cascading Style Sheets: rules that control how HTML looks (colors, fonts, spacing, layout).

CSS box model

Every element is a box made of content, padding, border and margin. box-sizing decides whether width includes padding and border.

CSS Grid

A CSS layout model for arranging items in rows and columns at the same time.

CSS selector

A pattern that chooses which elements a rule applies to: p (elements), .card (class), #main (id), a:hover (state).

CTE (Common Table Expression)

A named temporary result defined with WITH that makes complex queries easier to read; can be recursive.

CVE

Common Vulnerabilities and Exposures: a public ID (e.g. CVE-2024-1234) for a known security flaw in software.

DAG

Directed Acyclic Graph: a graph with one-way edges and no cycles. Dependency graphs are DAGs.

DAO (Data Access Object)

A class that hides how a particular table or entity is stored and retrieved, usually with CRUD methods.

Data structure

A way of organizing data in memory so that some operations are efficient: list, dictionary, set, stack, queue, tree, graph.

Data type

The kind of value: integer, decimal number, text (string), true/false (boolean), list, dictionary, and so on.

data-testid

An HTML attribute added only for tests, so that a selector stays stable when the styles or the text change.

Database

An organized collection of data stored on disk so programs can search, update and share it safely.

Dataclass

A class decorated with @dataclass that automatically gets __init__, __repr__ and __eq__ from its declared fields. Great for plain data objects.

DBMS

Database Management System: the software that stores the data and runs queries, such as PostgreSQL, MySQL or Oracle Database.

DDL / DML

DDL (CREATE, ALTER, DROP) defines structure. DML (INSERT, UPDATE, DELETE) changes data.

Deadlock

Two or more transactions each wait for a lock the other holds, so none can continue. The database aborts one of them.

Debounce

Delaying a function until events stop for a given time, so it runs once after a burst (e.g. typing).

Decorator

A wrapper with the same interface as the wrapped object that adds behavior, such as BufferedReader wrapping FileReader.

Decorator

A function that takes another function and returns a modified version of it. @timer above def f means f = timer(f). Used for logging, caching, permissions, retries.

Deep copy

A completely independent copy, including copies of all nested objects: copy.deepcopy(a).

Default argument

A value used when the caller does not pass that parameter: def f(x=10). In Python it is created once, when the function is defined.

Defense in depth

Layering several independent security controls so one failure does not break the whole defense.

Defensive copy

Copying a mutable object when receiving it or returning it, so outsiders cannot change your internal state.

defer / async scripts

Script attributes that download JS without blocking HTML parsing. defer keeps order and waits for parsing; async runs as soon as ready.

Definition of Done

A team-wide checklist of quality conditions that every work item must meet to count as complete.

Delivery guarantees

At-most-once (may lose messages), at-least-once (may duplicate), exactly-once (hard; usually achieved with idempotent processing).

Denormalization

Intentionally duplicating some data to make reads faster, at the cost of more complex writes.

Dependency

An external library your code needs, such as requests or Django. Versions are usually pinned in requirements.txt, pyproject.toml or a lock file.

Dependency injection

Giving an object the things it needs (database, API client, clock) from outside, usually via the constructor, instead of creating them inside.

Dependency Inversion Principle

High-level business code should depend on abstractions (interfaces), not on concrete low-level details.

Dependency scope

Tells Maven when a dependency is needed: compile (default), provided, runtime or test.

Deploy

Putting a version of the application on a server or cloud environment so it runs for real users (or testers).

Deployment (Kubernetes)

An object that keeps a desired number of identical Pods running and handles rolling updates and rollbacks.

deque

'Double-ended queue' from collections. Fast O(1) add/remove at both ends; ideal for queues.

Descriptor

An object that customizes attribute access by defining __get__, __set__ or __delete__. Properties and methods are built on it.

Deserialization attack

Feeding crafted serialized data to an app so rebuilding the objects runs attacker-controlled code (gadget chains).

Design pattern

A named, proven solution to a recurring design problem (Factory, Strategy, Observer...). An idea to adapt, not a library.

Deterministic

Always producing the same output for the same input, with no dependence on time, randomness or order.

DevOps

A combination of culture, practices and tools that brings development and operations together to deliver software faster and more reliably.

DFS (depth-first search)

Exploring a graph by going as deep as possible along one path before backtracking, using recursion or a stack.

Dict insertion order

Since Python 3.7 a dict keeps keys in the order they were inserted, and the language guarantees it (it was only a CPython detail in 3.6).

Dictionary (dict)

A collection of key → value pairs with fast lookup by key: {"name": "Ana"}. Keys must be hashable.

Dijkstra's algorithm

Finds the shortest path from one node to all others in a graph with non-negative edge weights, using a min-heap.

DispatcherServlet

Spring MVC's front controller: the single entry point that routes each HTTP request to the right controller method.

DISTINCT

Removes duplicate rows from the result: SELECT DISTINCT country FROM users returns each country once.

DNS

Domain Name System: translates human-readable domain names into IP addresses.

DNS records

A: name to IPv4. AAAA: name to IPv6. CNAME: alias to another name. MX: mail servers. TXT: free text such as verification.

Docker CLI

Command-line tool: docker build (make an image), run (start a container), ps (list), logs, exec (shell inside), stop, rm.

Docker Compose

A tool to define and run several containers together from one YAML file.

Docker image

A read-only, layered template containing an app and everything it needs to run. Containers are started from images.

Docker layer cache

Docker reuses the result of each build step if its inputs did not change, which makes rebuilds fast.

Dockerfile

A text file with instructions (FROM, COPY, RUN, CMD...) that Docker follows to build an image.

DOM

Document Object Model: the tree of objects the browser builds from HTML. JavaScript reads and changes it to update the page.

DRY

Don't Repeat Yourself: each piece of knowledge should live in one place, so a change needs only one edit.

DTO (Data Transfer Object)

A simple class (often a record) shaped for an API request or response, separate from the database entity.

Duck typing

'If it walks like a duck and quacks like a duck, it is a duck.' Code cares about what an object can do (its methods), not its class.

Dunder method

'Double underscore' methods like __init__, __eq__, __len__. Python calls them automatically for built-in behavior (creation, comparison, len(), printing).

Dynamic array

An array that doubles its capacity when full (Python list, Java ArrayList). One append is occasionally O(n), but the amortized cost is O(1).

Dynamic programming

Solving a problem by breaking it into overlapping subproblems and storing each subproblem's answer so it is computed only once.

EBS

Elastic Block Store: network disks for EC2 instances. The data stays when the instance stops, like a virtual hard drive.

ECR / ACR

Managed container registries: Amazon Elastic Container Registry and Azure Container Registry. They store your Docker images privately.

ECS / EKS / Fargate

ECS: AWS's container orchestrator. EKS: managed Kubernetes. Fargate: serverless compute for containers, so you manage no nodes.

Edge case

An unusual or extreme input at the boundary of what a function handles: empty, zero, max size, None.

Encapsulation

Keeping data and the methods that use it together and hiding internal details, so other code uses only a safe public interface.

Encoding vs encryption

Encoding (base64, UTF-8) only changes the representation; anyone can reverse it. Encryption needs a key to read the data.

Encryption

Scrambling data so only someone with the right key can read it. Reversible with the key, unlike hashing.

End-to-end test

A test that exercises the whole system from the user's point of view, e.g. a browser clicking through the app.

Endpoint

One specific URL + HTTP method your API handles, e.g. GET /users/{id}, usually mapped to one function.

Enum singleton

Implementing a Singleton as a single-value Java enum; the JVM guarantees exactly one instance and it is thread-safe.

Environment variable

A named value provided to a program by its environment (os.environ["KEY"]), commonly used for configuration and secrets.

equals / hashCode contract

equals says whether two objects are logically the same. hashCode gives a number used by hash collections. If two objects are equal, they must return the same hashCode.

ETag

A version identifier for a resource sent by the server. Lets clients ask 'has it changed?' and get 304 Not Modified if not.

Event bubbling

An event on an element also triggers on its parent, then its parent's parent, up to the document.

Event delegation

Handling events of many child elements with one listener on their common parent, thanks to bubbling.

Event loop

The engine of asyncio. It runs many tasks in one thread, switching to another task whenever the current one is waiting (at an await).

Eventual consistency

Copies of data may differ for a short time after a write, but will all become the same if no new writes arrive.

Exception

An error object raised while the program runs (ValueError, KeyError...). If nobody catches it with try/except, the program stops and shows a traceback.

ExecutorService

The Java API to submit tasks to a thread pool and get a Future with the result.

EXISTS / NOT EXISTS

A SQL test that is true if a subquery returns at least one row (EXISTS) or none (NOT EXISTS).

Exit code

A number a process returns when it ends: 0 means success, anything else means an error or a signal.

EXPLAIN

A SQL command that shows how the database plans to run a query (indexes used, scans, joins). EXPLAIN ANALYZE also runs it and shows real timings.

Explicit wait

Waiting until a specific condition is true (element visible, clickable) with a timeout, instead of sleeping a fixed time.

Facade pattern

A simple front-door class that hides a complicated subsystem behind a few easy methods.

Factory

A function or class whose job is to create objects, choosing the right concrete type: create_parser("json") returns a JsonParser.

Failover

Automatically switching to a backup component when the main one fails.

Fake

A simple working implementation used in tests instead of the real one, e.g. an in-memory database.

Feature flag

A configuration switch that turns a feature on or off at runtime, for all users or some, without redeploying.

fetch

The browser API for HTTP requests. It returns a Promise, does NOT throw on 404 or 500 (check res.ok), and res.json() is also async.

Field / method

Fields store an object's data (state). Methods are the actions (behavior) the object can perform.

FIFO / LIFO

FIFO: first in, first out, like a queue at a shop. LIFO: last in, first out, like a stack of plates.

final

A modifier that prevents change: a final variable is assigned once, a final method cannot be overridden, a final class cannot be extended.

finally

A block that runs after try/catch no matter what happened, including after a return or an exception. Typically used for cleanup.

Firewall

A network control that allows or blocks connections based on rules (address, port, protocol).

Fixture (pytest)

A function that prepares something a test needs (data, connection, client) and optionally cleans it up afterwards.

Flaky test

A test that sometimes passes and sometimes fails without any code change.

Flexbox

A CSS layout model for arranging items in one direction (row or column), with easy alignment and spacing.

Floyd's cycle detection

Two pointers move through a linked list, one step and two steps at a time. If there is a cycle they meet; if not, the fast one reaches the end. Uses O(1) extra space.

Flyweight

Saves memory by sharing identical immutable objects, like the Integer cache and the string pool.

Foreign key

A column that holds the primary key of a row in another table, creating a relationship the database can enforce.

Framework

Reusable foundation of code that gives structure to an application and calls your code at defined points (for example Spring Boot, Django, React).

Frontend

The part of an application that runs on the user's device (browser or app) and that people see and interact with: layout, buttons, forms.

Function

A named, reusable block of code. It receives inputs (parameters), does something, and can give back a result with return.

functools.lru_cache

A decorator that remembers the results of a function for the same arguments (memoization). Arguments must be hashable, so passing a list raises TypeError.

functools.wraps

A decorator for decorators: it copies the original function's name and docstring onto the wrapper, so debugging and introspection still work.

G1 / ZGC

Modern JVM garbage collectors. G1 is the default: it works in regions and aims at predictable pauses. ZGC aims at pauses of a few milliseconds even on huge heaps.

Garbage collector

The part of a language runtime that automatically frees memory no longer in use. In Python, the gc module mainly cleans up reference cycles.

Garbage collector

The JVM component that automatically frees objects that can no longer be reached, so developers do not call free manually.

GAV coordinates

groupId, artifactId and version: the three values that uniquely identify a Maven artifact.

GCP (Google Cloud Platform)

Google's cloud platform. It offers equivalents of the AWS and Azure services: Compute Engine (virtual machines), Cloud Storage (object storage) and GKE (managed Kubernetes).

Generator

A function that uses yield to produce values one at a time, pausing between them. It does not build the whole result in memory, and it can only be consumed once.

Generic type

A type with a placeholder, like list[T], so the same code works for many types while keeping type information.

Generics

Parameterized types such as List<String> that let the compiler check element types and remove the need for casts.

GIL (Global Interpreter Lock)

A lock inside CPython (the standard Python) that allows only one thread to run Python code at a time. It keeps Python's memory management simple and safe, but it means threads cannot do heavy calculations in parallel.

Git

A distributed version control system that records the history of your files and supports branches and merging.

git add / commit / push / pull

add stages changes, commit saves a snapshot locally, push uploads commits to the remote, pull downloads and merges remote commits.

git cherry-pick

Copies the changes of one specific commit onto the current branch as a new commit.

git reflog

A local log of everywhere HEAD has pointed, used to recover "lost" commits after a reset or rebase.

git reset vs git revert

reset moves a branch back and rewrites history; revert adds a new commit that undoes an earlier one, safe on shared branches.

git stash

Temporarily stores uncommitted changes so you can switch tasks and bring them back later.

Global state

Data that any part of the program can read and change. It creates hidden connections between code and makes testing harder.

God object

An anti-pattern: one huge class that knows and does too much. Split it by responsibility.

GoF (Gang of Four)

The four authors of the book "Design Patterns" (1994), which catalogued 23 classic object-oriented design patterns.

Graph

A set of nodes (vertices) connected by edges. Edges can be directed or undirected, weighted or not.

GraphQL

An API query language where the client asks for exactly the fields it needs in one request, through a single endpoint.

GROUP BY

Groups rows that share a value so aggregate functions can be computed per group.

gRPC

A high-performance RPC framework using Protobuf binary messages over HTTP/2, with code generated from a shared schema.

Handling ambiguity

Ask clarifying questions, state your assumptions, split the work into small steps, ship something early and iterate with feedback.

Hash

A number calculated from a value, used to find it quickly in sets and dict keys. Equal values must have equal hashes. Only immutable values are normally hashable.

Hash collision

When two different keys produce the same slot in a hash table. Handled by chaining or probing; too many slow things down.

Hash function

A one-way function that maps any input to a fixed-size fingerprint. The same input always gives the same output.

Hash table

A structure that stores key → value pairs in an array, using a hash of the key to find the slot. Python's dict and set. O(1) average lookup.

HashMap

A Map that finds values by hashing the key into buckets. Average O(1) get and put. Not thread-safe; allows one null key.

HashSet

A Java Set backed by a hash table: no duplicates, no order, average O(1) add and contains. It needs correct equals and hashCode.

Heap / priority queue

A tree-based structure that always gives quick access to the smallest (min-heap) or largest item. Python: heapq. Push/pop O(log n).

Helm

The Kubernetes package manager: charts of templated manifests installed with per-environment values.

Hibernate

The most popular JPA implementation. It generates SQL, manages entity state and caches loaded objects.

High availability

Designing a system to keep working despite failures, using redundancy and automatic failover.

Higher-order function

A function that receives functions as arguments or returns a function. Decorators, map and sorted(key=...) are examples.

HMAC

A signature computed from a message and a secret key. Anyone with the key can verify that the message is authentic and unchanged.

Hoisting

JavaScript's behavior of moving declarations to the top of their scope before running code.

Horizontal scaling

Adding more servers that share the work, usually behind a load balancer. Requires stateless app design.

HPA (Horizontal Pod Autoscaler)

A Kubernetes object that changes the number of Pod replicas based on CPU or custom metrics.

HSTS

HTTP Strict Transport Security: a header telling browsers to always use HTTPS for a domain.

HTML

HyperText Markup Language: the tags that define a web page's structure and content (headings, paragraphs, links, forms).

HTTP

The protocol browsers and apps use to talk to web servers: a client sends a request (method, URL, headers, body) and gets a response (status code, headers, body).

HTTP method

The verb of a request: GET (read), POST (create), PUT (replace), PATCH (partial update), DELETE (remove).

HTTP/2

A newer version of HTTP that sends many requests at once over one connection and compresses headers.

HttpOnly cookie

A cookie flag that hides the cookie from JavaScript, so injected scripts cannot steal it.

HTTPS

HTTP running inside an encrypted TLS connection. Protects data from being read or changed and verifies the server's identity.

Hybrid connectivity

Connecting on-premises networks to the cloud with a site-to-site VPN or a dedicated line (Direct Connect, ExpressRoute).

Hydration

Attaching JavaScript behavior to server-rendered HTML in the browser so it becomes interactive.

I/O-bound

Work that spends most of its time waiting for input/output: network calls, disk reads, database queries. The CPU is mostly idle while waiting.

IaaS / PaaS / SaaS

Infrastructure, Platform and Software as a Service: rented servers; a platform that runs your code; a finished application.

IAM

Identity and Access Management: the AWS (or other cloud) system for users, roles and permissions.

IDE

Integrated Development Environment: an editor with extra tools such as autocomplete, a debugger and run/test buttons (IntelliJ IDEA, Eclipse, PyCharm).

Idempotent

An operation that has the same effect whether you do it once or many times. Setting x = 5 is idempotent; adding 1 to x is not.

Identity

Which exact object in memory a variable refers to. id(x) shows it and is compares it. Two equal lists can still be two different objects.

IDOR

Insecure Direct Object Reference: accessing someone else's data by changing an ID in the request, because ownership is not checked.

Immutable

An object that cannot change after creation, like int, str, tuple or frozenset. 'Changing' it really creates a new object.

Immutable class

A class whose objects never change after construction (final fields, no setters). Safe to share between threads.

Immutable infrastructure

Replacing servers with freshly built images for every change instead of modifying them in place.

Impact and metrics

Close a story with a result and, if you can, a number: time saved, errors reduced, users helped. It turns 'I worked on it' into 'it mattered'.

Indentation

Spaces at the start of a line. In Python they define which lines belong to a block (if, loop, function).

Index

A sorted lookup structure on one or more columns that lets the database find rows quickly without scanning the whole table.

Infrastructure as Code

Defining servers, networks and databases in code files, so infrastructure is versioned, reviewed and reproducible.

Ingress

Kubernetes rules that route external HTTP(S) traffic by host and path to Services, implemented by an Ingress Controller.

Inheritance

A class (child) reuses and extends another class (parent): class Dog(Animal). The child gets the parent's methods and can override them.

INNER JOIN

Returns only rows that have a match in both tables.

Input validation

Checking that incoming data matches what is expected (type, length, format, range) and rejecting anything else.

Instance

A concrete object created from a class. rex = Dog() makes rex an instance of Dog. The class is the blueprint; the instance is the house.

Integration test

A test that checks several real components working together, such as your code with a real database.

Interface

The set of methods an object promises to offer, without saying how they work inside. In Python often expressed with an ABC or a Protocol.

Interface Segregation Principle

Prefer several small, focused interfaces over one large one, so classes implement only what they use.

Interpreter

A program that reads source code and runs it directly. Python code runs with the python interpreter.

Inversion of Control (IoC)

A design where a framework or container controls object creation and wiring instead of your own code calling new.

IP address

A number that identifies a device on a network, like 192.168.1.10 (IPv4). DNS translates names into IP addresses.

Isolation level

How much concurrent transactions are protected from each other: Read Uncommitted, Read Committed, Repeatable Read, Serializable.

Iterable

Anything you can loop over with for: lists, strings, dicts, files, ranges. Calling iter() on it gives an iterator.

Iterator

An object that returns the next item each time you call next() on it, and remembers where it is. When it has no more items, it raises StopIteration.

Jackson

The default Java library that converts objects to JSON and JSON to objects.

Jakarta EE

The successor to Java EE. Since Spring Boot 3 the packages are jakarta.* instead of javax.*.

JAR

Java ARchive: a ZIP-based file that bundles compiled classes and resources. Libraries and Spring Boot apps are shipped as JARs.

Java

A general-purpose, object-oriented programming language, very common in backend and enterprise software. Not related to JavaScript.

Java heap

The shared memory area where all objects live. It is cleaned by the garbage collector. When it is full: OutOfMemoryError.

javac / java

javac compiles .java source into .class bytecode. java starts the JVM and runs that bytecode, or a whole JAR with java -jar.

JavaScript

The programming language that runs in browsers (and on servers with Node.js) to make pages interactive.

JavaScript event loop

The mechanism that runs JS on a single thread: run synchronous code, then all microtasks (promises), then the next macrotask (timers, events).

JDBC

The standard low-level Java API for running SQL on relational databases through drivers.

JdbcTemplate

A Spring helper that runs SQL through JDBC and removes the boilerplate: connections, statements and cleanup are handled for you.

JDK / JRE

JRE (Java Runtime Environment) = JVM + standard libraries, enough to run programs. JDK (Java Development Kit) = JRE + developer tools such as the compiler javac.

JOIN

Combining rows of two tables based on a related column, e.g. orders.customer_id = customers.id.

JPA (Jakarta Persistence)

The Java standard for mapping objects to relational tables (ORM): @Entity, @Id, relationships and JPQL queries.

JpaRepository

A Spring Data interface that gives ready-made CRUD, paging and sorting methods for an entity. You only declare the interface.

JSON

A text data format with objects {"key": value} and arrays [...]. The standard format for web APIs.

json.loads / json.dumps

json.loads turns a JSON string into Python objects. json.dumps turns Python objects into a JSON string.

JSX

A syntax that lets you write HTML-like markup inside JavaScript (React). The build step compiles it into normal function calls.

Junction table

A table with two foreign keys that links two tables in a many-to-many relationship.

JUnit 5

The standard Java unit testing framework: @Test, @BeforeEach, @ParameterizedTest, assertions and extensions.

JVM (Java Virtual Machine)

The program that loads Java bytecode and executes it, manages memory (garbage collection) and optimizes hot code while running. Each operating system has its own JVM.

JWT (JSON Web Token)

A compact token with three parts (header.payload.signature). The payload holds claims like user ID and expiry; the signature proves the server issued it.

Kadane's algorithm

An O(n) algorithm for the maximum sum of a contiguous subarray: at each element, extend the current run or restart.

Kafka

A distributed event streaming platform: messages are stored in an ordered, replayable log split into partitions.

Kanban

A visual board method with limits on work in progress and continuous flow, instead of fixed sprints.

Keyword argument

An argument passed by name: f(size=10). Order does not matter and calls are easier to read.

KMS / Key Vault

Managed services that create, store and control encryption keys (AWS KMS, Azure Key Vault).

kubectl

The Kubernetes command-line tool: apply, get, describe, logs, exec, rollout.

Kubernetes (K8s)

A system that automates deploying, scaling, healing and networking containers across a cluster of machines.

Kubernetes Secret

An object to hold sensitive values and inject them into Pods. Encoded, not encrypted, by default.

Lambda

A small anonymous function written in one expression: lambda x: x * 2 is the same as def f(x): return x * 2.

Lambda expression

A short anonymous function written as (args) -> expression, e.g. n -> n * 2. It can be used wherever a functional interface is expected.

Latency

The time one operation takes from start to finish, e.g. how long a request waits for its response.

latest tag

Docker's default tag. It is only a name that moves, so it does not mean 'newest'. Pin an exact version in production.

Law of Demeter

'Talk only to your immediate friends.' A method should not reach through a chain of objects (a.b.c.d()); chains couple your code to the inner structure of other classes.

Layer 4 vs layer 7

Layer 4 balances raw TCP/UDP connections; layer 7 understands HTTP and can route by URL path or host name.

Lazy evaluation

Computing values only when they are actually needed, instead of all at once in advance. Saves memory and time when not everything is used.

Lazy loading

Loading related data only when it is first accessed. Efficient, but outside a session it throws LazyInitializationException.

Leader-follower replication

One node (leader) accepts writes and copies them to followers, which serve reads and can replace the leader.

Learning from failure

Pick a real mistake, own it without blaming others, explain what you changed afterward (a test, a checklist, a process) and what you learned.

Learning quickly

Show a method: official docs, a small prototype, asking someone experienced, then applying it to real work. Give the result and how fast you got there.

Least privilege

Giving every user, service and key only the minimum permissions it needs.

LEFT JOIN

Returns all rows from the left table, plus matching rows from the right one (NULL where there is no match).

Library

A collection of reusable code that your program calls when it needs it (for example requests, Jackson).

Linear search

Checking items one by one from the start until the target is found. O(n).

Linked list

A sequence of nodes where each node holds a value and a pointer to the next node. Easy to insert/remove; slow to access by index.

Linux

Free, open source operating system family that runs most servers, containers and cloud machines.

Liskov Substitution Principle

A subclass must work anywhere its parent class is expected, without surprising the caller.

List

An ordered, changeable collection: [1, 2, 3]. Items are accessed by position, starting at 0.

List comprehension

A compact way to build a list from a loop: [x * 2 for x in nums if x > 0]. With parentheses instead of brackets it becomes a generator expression.

Load balancer

A component that spreads incoming requests across several servers and skips unhealthy ones.

Load test

Simulating many concurrent users to measure performance and find the system's limits.

Local Maven repository

The folder ~/.m2/repository where Maven caches downloaded libraries and stores artifacts from mvn install.

localStorage / sessionStorage

Browser key-value storage readable by JavaScript. localStorage persists; sessionStorage lasts for one tab.

Locator

The way a test finds an element: by id, name, CSS selector, XPath or link text. Stable locators make tests less brittle.

Lock (mutex)

A tool that lets only one thread at a time run a protected piece of code: with lock: .... Prevents race conditions.

Lock ordering

The standard way to avoid deadlocks: every transaction takes locks in the same global order, and keeps transactions short.

Logs, metrics, traces

Logs: timestamped text events. Metrics: numeric measurements over time. Traces: the timed path of one request through services.

LongAdder

A Java counter built for many threads: it spreads updates over several cells and sums them on read, so it scales better than AtomicLong under contention.

Loop

A structure that repeats a block of code, for example for (once per item) or while (as long as a condition is true).

LRU cache

A fixed-size cache that removes the Least Recently Used item when it needs space.

LTS (Long-Term Support)

A release that receives updates and fixes for several years. Java 8, 11, 17, 21 and 25 are LTS versions.

Malware

Malicious software: viruses, worms, ransomware, spyware and other programs designed to harm or steal.

Managed identity

An identity Azure manages for a resource so it can call other services with tokens instead of stored passwords. AWS equivalent: IAM roles.

Manual vs automated testing

Manual: a person runs the steps and judges the result. Automated: code runs the checks quickly and repeatedly.

map / filter / reduce

Array methods that return new results: map transforms each item, filter keeps matching items, reduce combines items into one value.

Markup language

A language that labels content with tags to describe its structure or meaning, such as HTML. It is not a programming language: it has no logic.

Maven

A Java build and dependency management tool. It reads pom.xml, downloads libraries, compiles, tests and packages the project.

Maven folder layout

The standard layout: src/main/java (code), src/main/resources (config), src/test/java (tests). Build output goes to target/.

Maven lifecycle

The ordered phases of a build: validate, compile, test, package, verify, install, deploy. Running a phase runs all earlier ones.

Media query

A CSS condition (screen width, dark mode, etc.) that applies rules only when true.

Memoization

Caching a function's results by its arguments, so repeated calls with the same input return instantly. Python: @functools.lru_cache.

Memory leak (Java)

Objects that are still referenced (so the GC cannot free them) but will never be used again, causing the heap to grow.

Mentoring

Helping someone grow: explain the why, give small tasks with feedback, pair on problems and let them own the solution. Describe how they improved.

Merge

Combining the changes from one branch into another. Keeps both histories and adds a merge commit when needed.

Merge conflict

Happens when two branches changed the same lines. You must pick the final content manually, then mark it resolved.

Merge sort

A sort that splits the list in halves, sorts each, and merges them. Always O(n log n), stable, uses extra memory.

Message broker

The server software that receives, stores and delivers messages between services (RabbitMQ, Kafka, SQS).

Message queue

A buffer where one service puts messages and another takes them later, so they don't have to be available at the same time.

Metaclass

The 'class of a class': it creates classes the way classes create objects. The default is type. Rarely needed in everyday code.

Metadata

Data about data. For a function: its name (__name__), docstring (__doc__), module, and so on.

Method

A function defined inside a class. It receives the object (self) automatically as its first argument.

MFA

Multi-factor authentication: requiring two or more different kinds of proof of identity, such as a password plus a phone code.

Microservices

An architecture where an application is split into small, independently deployable services that communicate over the network.

Microsoft Entra ID

Microsoft's cloud identity and access service, formerly Azure Active Directory (Azure AD).

Microtask vs macrotask

Microtasks (promise callbacks) run right after the current code, before any macrotask (setTimeout, I/O, UI events).

Middleware

Code that runs around every request and response in a web app, for cross-cutting tasks like logging, auth, CORS or timing.

Mock

A test double that replaces a real dependency, returns what you configure, and records calls so you can verify them.

Module / package

A module is a file of code you can import; a package is a folder of modules.

Monitoring

Watching metrics (errors, latency, CPU) over time and alerting when the system is unhealthy.

Monolith

An application built and deployed as a single unit. Can be well organized internally (modular monolith).

Monotonic stack

A stack kept in increasing or decreasing order, used to find the next greater or smaller element for every item in O(n).

Motivation for the role

Connect your goals to the role and the company: what you want to learn, what you can contribute and something specific you researched about their product or team.

MRO (Method Resolution Order)

The order in which Python searches classes for a method or attribute when inheritance is involved. See it with ClassName.__mro__.

Multi-stage build

A Dockerfile with several FROM stages, where later stages copy only the needed outputs from earlier ones.

Multiple inheritance

A class with more than one parent: class D(B, C). Python resolves conflicts using the MRO.

multiprocessing

Runs Python code in separate processes, each with its own interpreter and GIL, so CPU-bound work uses several cores. Cost: starting processes and pickling the data sent between them.

Mutable

An object that can be changed after it is created, like a list, dict or set. If two variables point to the same mutable object, a change through one is visible through the other.

Mutation testing

Planting small bugs in the code to check whether the test suite notices them.

MVC

Model-View-Controller: separates data and rules (model), presentation (view) and request handling (controller).

mvn clean / test / package / install

clean deletes target/, test runs the unit tests, package builds the JAR, install also copies it into ~/.m2.

MVP

Minimum Viable Product: the smallest version of a product that delivers value and lets the team learn from real users.

N+1 query problem

Running 1 query to get a list of N items, then 1 more query for each item. Fixed by loading related data in bulk (JOIN or IN query).

Namespace (Kubernetes)

A logical partition of a cluster (dev, staging, team-a) with its own names, quotas and permissions.

NAT

Network Address Translation: lets hosts with private IPs reach the internet through a shared public address.

Network partition

A failure where parts of a distributed system cannot communicate with each other, while each part keeps running.

NIST

The US National Institute of Standards and Technology. It publishes widely used security and cloud standards, such as the definition of cloud computing.

NIST cloud characteristics

On-demand self-service, broad network access, resource pooling, rapid elasticity, measured service.

Node.js

A JavaScript runtime that lets you run JavaScript outside the browser, for example to build servers and command-line tools.

Normal forms (1NF, 2NF, 3NF)

Progressive rules for table design that remove redundancy: atomic values (1NF), full dependence on the key (2NF), no dependence between non-key columns (3NF).

Normalization

Organizing tables so each fact is stored once, linked by keys. Avoids duplicate data and update mistakes.

NoSQL

Databases that are not relational tables: document, key-value, wide-column or graph stores, often with flexible schemas.

npm / package.json

npm is the Node package manager. package.json lists metadata, scripts and dependencies; npm install downloads them to node_modules.

NULL

A marker for 'missing or unknown value' in SQL. It is not 0 or empty string, and comparisons with it are never true (use IS NULL).

null (Java)

The value of a reference that points to no object. Calling a method on it throws NullPointerException.

OAuth 2.0

A standard for letting an app get limited access to a user's account on another service without seeing the user's password ('Log in with Google').

Object

Any value in Python (a number, a list, a function, a class). Every object has a type, a value and an identity.

Object storage

Storage for files (objects) accessed via an HTTP API, like S3. Very durable and scalable, but not a normal filesystem.

Object storage

Storage for whole files (objects) accessed by key or URL, like Amazon S3 and Azure Blob Storage. Not a database.

Observability

How well you can understand what a running system is doing from its outputs: metrics, logs and traces.

Observer pattern

Subscribers register with a subject and are notified automatically when an event happens (publish/subscribe).

OIDC (OpenID Connect)

A login layer on top of OAuth 2.0. It tells the app who the user is through an ID token (a JWT).

OOM killer

Out Of Memory killer: a Linux kernel mechanism that kills a process using more memory than allowed.

OOP

Object-oriented programming: organizing code into objects that bundle data (fields) and behavior (methods).

Open/Closed Principle

Code should be open for extension (add new behavior) but closed for modification (don't edit tested code to add it).

Operating system (OS)

The software that manages the hardware and runs other programs (Linux, Windows, macOS). It gives programs files, memory, processes and networking.

Optimistic locking

Not locking while reading; when saving, check a version number to detect if someone else changed the row in the meantime.

Optional

A container that may hold a value or be empty. Used as a return type to make "might be missing" explicit instead of returning null.

Origin

The combination of scheme, domain and port of a web page, e.g. https://app.example.com:443. Different origin = different site for the browser.

ORM

Object-Relational Mapper (Django ORM, SQLAlchemy): lets you work with database rows as Python objects instead of writing SQL by hand.

Overloading

Several methods with the same name but different parameter lists in the same class. The compiler chooses at compile time.

Overriding

A subclass provides its own implementation of an inherited method with the same signature. The JVM chooses the version at runtime from the real object type.

OWASP Top 10

A widely used list, published by the OWASP foundation, of the most critical security risks for web applications.

Ownership

Showing that you took responsibility beyond your task: you saw the problem, acted, followed through and owned the result. Use 'I', not only 'we'.

Package (Java)

A namespace that organizes related classes and interfaces, like a folder: java.util, com.mycompany.shop.

Package / dependency manager

A tool that downloads and tracks the libraries a project needs: Maven or Gradle (Java), pip (Python), npm (JavaScript).

Page Object Model

A pattern where each page is a class with its locators and actions, keeping tests readable and UI changes in one place.

Pagination

Returning a large list in smaller pages (e.g. 20 items at a time), using limit/offset or a cursor.

Parameter / argument

A parameter is a variable in a function's definition (def greet(name)). An argument is the value you pass when calling it (greet("Ana")).

parametrize

A pytest decorator that runs the same test with several sets of inputs.

Password hashing

Storing a slow, salted, one-way hash of the password (Argon2id, bcrypt, scrypt) instead of the password itself.

Patch

An update that fixes a bug or a security vulnerability in software.

Path parameter

A variable part of the URL path that identifies a resource: in /users/42, 42 is the user ID.

Path traversal

Using ../ sequences in a file path input to access files outside the intended folder.

Permutations (n!)

The number of ways to order n distinct items is n! (n factorial). Generating them all takes at least n! steps, which grows extremely fast.

Persistence

Keeping data after the program stops, by saving it on disk (for example in a database) instead of only in memory.

Persistence context

The set of entities a JPA session currently manages. Changes to them are detected (dirty checking) and written at commit.

PersistentVolume / Claim

PV: a piece of cluster storage. PVC: a Pod's request for storage; it binds to a PV so data survives Pod restarts.

Pessimistic locking

Locking rows when you read them (SELECT ... FOR UPDATE) so nobody else can change them until you finish.

Phishing

Fraudulent messages that impersonate trusted organizations to trick people into giving credentials or installing malware.

Pickle

Python's built-in way to convert objects to bytes and back. Used to send data between processes. Never unpickle untrusted data.

PID

Process ID: the number the operating system gives to each running process. In a container, PID 1 is the main process; when it exits, the container stops.

PII

Personally Identifiable Information: data that can identify a person, such as name, email, ID number or address.

pip

Python's package installer. It downloads packages from PyPI (the Python Package Index).

Pod

The smallest unit Kubernetes runs: one or more containers sharing network and storage.

Polling

The client repeatedly asks the server 'anything new?' at intervals. Simple but wasteful compared to push.

Polymorphism

Different classes respond to the same method call in their own way. The caller just calls x.area() without checking the type.

pom.xml

Project Object Model: the Maven file describing the project (coordinates, dependencies, plugins, properties).

Port

A number (0-65535) that identifies a specific service on a machine, e.g. 443 for HTTPS, 5432 for PostgreSQL.

Positional argument

An argument passed by position: f(10, 20). The first value goes to the first parameter, and so on.

Postmortem

A written analysis after an incident: what happened, why, and what will change to prevent it.

Prefix sum

An array where each position holds the total of all elements before it, so any range sum is one subtraction.

Present, past, future

A simple structure for 'Tell me about yourself': what you do now, how you got here (1 or 2 key steps), and why this role is next. About 1 to 2 minutes.

Primary key

The column(s) that uniquely identify each row in a table. Unique and never NULL.

Primitive type

A basic value type built into Java: int, long, double, boolean, char, byte, short, float. It is not an object and can never be null.

print vs return

print shows a value on the screen and the function then returns None. return hands a value back to the caller so other code can use it, and it ends the function.

Prioritization under pressure

Clarify what is urgent versus important, agree on scope with the stakeholders, deliver the most valuable part first, communicate risks early and say no to the rest.

Private endpoint / PrivateLink

Gives a cloud service a private IP in your network, so traffic never crosses the public internet.

Process

A running program with its own private memory. Two processes do not share variables; to exchange data they must send it to each other. Like two separate kitchens.

Programming language

A formal language for writing instructions that a computer can execute, such as Python, Java or JavaScript.

Promise

An object representing the future result of an async operation: pending, then fulfilled with a value or rejected with an error.

Promise.all

Runs promises in parallel and resolves with all results, but rejects as soon as ONE rejects. Promise.allSettled waits for all and reports each outcome.

Property-based testing

Testing that a rule holds for many automatically generated inputs (e.g. with Hypothesis).

Props

Inputs passed from a parent component to a child component. Read-only for the child.

Protocol (typing)

A type describing required methods. Any class that has those methods matches it, without inheriting from it.

Proxy pattern

An object that stands in for another with the same interface to control access or add behavior (transactions, caching, lazy loading).

Pub/sub

Publish/subscribe messaging: publishers send to a topic; every subscriber of that topic receives a copy.

Pull request

A request to merge a branch, with code review and automated checks, hosted on GitHub/GitLab (called merge request on GitLab).

pyproject.toml

The standard config file of a Python project: metadata, dependencies and tool settings in one place.

pytest

The most popular Python testing framework: plain assert statements, fixtures, parametrization and plugins.

QA

Quality Assurance: activities (testing, automation, process improvements) that help make sure software meets quality expectations.

QPS

Queries (requests) per second: a basic measure of load used in capacity estimates.

Query

A request written for a database to get or change data, usually in SQL.

Query parameter

Key=value pairs after ? in a URL, used for filtering, sorting and paging: ?status=paid&limit=10.

Questions for the interviewer

Ask about the team, how work is planned and reviewed, onboarding, what success looks like in 6 months and the main technical challenges. Avoid only asking about salary or perks.

Queue

A FIFO collection (first in, first out): add at the back, remove from the front. Like a line of people.

QUIC

A modern transport protocol built on UDP and used by HTTP/3. It sets up connections faster and avoids TCP head-of-line blocking.

Quicksort

A sort that picks a pivot, splits items into smaller and bigger than the pivot, and sorts each part. Fast on average, O(n²) worst case.

Race condition

A bug where the result depends on the unlucky timing of threads or processes touching the same data. Hard to reproduce because it happens only sometimes.

RAM

Random-access memory: fast, temporary memory where running programs keep their data. It is cleared when the program ends or the computer restarts.

Rate limiting

Restricting how many requests a client may make per time window, to protect the service from abuse and overload.

RBAC

Role-Based Access Control: permissions are given to roles (admin, editor, viewer) and users receive roles, instead of assigning permissions one by one.

RCE (Remote Code Execution)

A vulnerability that lets an attacker run their own code on your server. The most severe class of bug.

RDS / DynamoDB

RDS: managed relational databases. DynamoDB: serverless NoSQL key-value/document store for massive scale and simple access patterns.

React

A JavaScript library for building user interfaces from components that re-render when their data changes.

React Context

A way to make a value available to all descendant components without passing props at every level.

React hook

Functions starting with use (useState, useEffect, useMemo...) that give function components state and lifecycle features.

React Testing Library

A library that renders React components in tests and queries them like a user would (by role or text).

Read replica

A copy of the database that receives changes from the primary and serves read queries.

Readiness / liveness probe

Health checks Kubernetes runs on Pods: readiness decides if a Pod gets traffic; liveness decides if it must be restarted.

Rebase

Replaying your commits on top of another branch to get a straight-line history. It rewrites commit IDs.

Receiving feedback

Listen without defending, ask questions to understand, thank the person, act on it and show the change. Interviewers look for a growth mindset.

Reconciliation

React's process of comparing the new UI description with the previous one and updating only what changed.

Record

A compact immutable data class (Java 16+): record Point(int x, int y) {} generates constructor, accessors, equals, hashCode and toString.

Recursion

A function that solves a problem by calling itself on smaller inputs, until it reaches a base case.

Redis

A very fast in-memory key-value data store, used for caching, counters, sessions, queues and leaderboards.

Refactoring

Improving the internal structure of code (names, duplication, organization) without changing its behavior.

Reference counting

CPython counts how many variables or containers point to each object. When the count drops to 0, the object is freed immediately.

Region / Availability Zone

A Region is a geographic area; an Availability Zone is an isolated data center location inside it. Spread across AZs for high availability.

Regression

A bug where something that used to work stops working after a change. Regression tests guard against it.

Relational database

A database that stores data in tables with rows and columns, linked by keys, and queried with SQL (PostgreSQL, MySQL, Oracle, SQL Server).

Remote repository

A shared copy of the Git repository hosted elsewhere (GitHub, GitLab). origin is the default name of the main remote.

Replication

Keeping copies of the same data on several servers, for availability and to spread read traffic.

Repository

A class that hides how data is stored, offering simple methods like get, add, list to the rest of the code.

Requests and limits

Kubernetes CPU/memory settings: requests are reserved for scheduling; limits are the maximum (memory over the limit means OOMKilled).

Responsive design

Designing pages that adapt their layout to different screen sizes, from phones to desktops.

REST

A popular style for web APIs: URLs name resources (/users/42), HTTP methods express actions, and requests are stateless.

RestTemplate

Spring's classic HTTP client for calling other REST services. In newer code RestClient or WebClient is preferred.

Retrospective

A regular, blameless team meeting to review how the team worked and agree on concrete improvements.

Retry with exponential backoff

Retrying a failed call after waiting longer each time (1 s, 2 s, 4 s...), with some randomness (jitter) so clients don't retry in sync.

Retry-After header

A header sent with 429 or 503 that tells the client how many seconds to wait before trying again.

Reverse proxy

A server in front of your app servers that receives client requests and forwards them, often adding TLS, caching and load balancing.

Rollback

Returning to the previous working version after a bad release.

Routing

Mapping incoming request paths and methods to the functions that handle them.

Salt

A random value added to each password before hashing so that identical passwords produce different hashes.

SAST / DAST / SCA

SAST scans source code statically; DAST attacks a running app; SCA checks third-party dependencies for known vulnerabilities.

SBOM

Software Bill of Materials: a list of every component and dependency inside your software, used to find vulnerable libraries quickly.

Schema

The structure of the data: which tables or documents exist, their fields, types and relationships.

Scope

Where a variable name is visible. Python looks names up in this order: Local (inside the function), Enclosing function, Global (module), Built-in (LEGB).

Scrum

An Agile framework with fixed sprints, three roles (Product Owner, Scrum Master, Developers) and events (planning, daily, review, retrospective).

SDK

Software Development Kit: a library plus tools that a vendor provides to use its service from code, for example the AWS SDK.

SDLC

Software Development Life Cycle: the phases from requirements and design through coding, testing, deployment and maintenance.

Secret

Sensitive configuration such as passwords, API keys and private keys. Must never be stored in code or logs.

Security Group / NSG

A virtual firewall attached to a resource: stateful and allow-only (AWS Security Group, Azure NSG). NACLs are stateless subnet-level filters.

SELECT / WHERE / HAVING / ORDER BY

SQL clauses are evaluated in this logical order: FROM, WHERE (filters rows), GROUP BY, HAVING (filters groups), SELECT (picks columns), ORDER BY, LIMIT.

Selenium WebDriver

A library that controls a real browser from code (open pages, find elements, click, type) to automate UI tests.

Semantic HTML

Using HTML elements for their meaning (button, nav, main, label) instead of generic divs, which helps accessibility and SEO.

Semantic Versioning

Version numbers MAJOR.MINOR.PATCH: breaking change, new compatible feature, compatible bug fix.

SEO

Search Engine Optimization: making pages easy for search engines to read and rank. Server-rendered HTML helps because crawlers see the content immediately.

Server

A computer or a program that waits for requests from clients and sends back responses.

Serverless

Running code without managing servers: the provider runs your function on demand and charges per execution (e.g. AWS Lambda).

Service (Kubernetes)

A stable network name and IP that load-balances traffic to a changing set of Pods.

Servlet / servlet container

A servlet is a Java class that handles HTTP requests; a container (Tomcat, Jetty) runs them and manages connections and threads.

Session

Server-side memory of a logged-in user, identified by a random session ID usually stored in a cookie.

Session fixation

An attack where the victim is made to log in with a session ID the attacker already knows.

Set

An unordered collection of unique values with very fast membership checks: {1, 2, 3}.

SHA-256 / SHA

The Secure Hash Algorithm family. SHA-256 turns any input into a fixed 256-bit fingerprint. It is fast and one-way, so for passwords use slow hashes (Argon2, bcrypt) instead.

Shallow copy

A new container that holds the SAME inner objects as the original: list(a), a.copy(), copy.copy(a).

Sharding

Splitting data across several servers by a key (e.g. user ID), so each holds only part of the data.

Shared responsibility model

The provider secures the cloud infrastructure; the customer secures their data, identities, configuration and code.

Signal (Unix)

A message sent to a process: SIGTERM (15) politely asks it to stop; SIGKILL (9) kills it immediately.

Single point of failure

A component without a backup whose failure stops the whole system.

Single Responsibility Principle

A class or module should have one job, so only one kind of change forces you to edit it.

Singleton

A class that allows only one instance, reachable from anywhere. Often criticized because it acts like a global variable.

SLI / SLO / SLA

SLI: a measured indicator (e.g. success rate). SLO: the internal target (e.g. 99.9%). SLA: a contractual promise to customers.

Slicing and negative indexes

seq[start:stop:step] takes a part of a list, tuple or string. start is included, stop is NOT. Negative indexes count from the end: s[-1] is the last item, so "python"[-1] is 'n'.

Sliding window

A technique that keeps a moving range [left, right] over an array or string, expanding and shrinking it instead of restarting, often O(n).

Smoke test

A small set of quick checks that the most important functions work, typically after a deploy.

SNAPSHOT version

A mutable development version (1.2.0-SNAPSHOT) that may change, unlike an immutable release version.

SOLID

Five design principles for maintainable object-oriented code: Single responsibility, Open/closed, Liskov substitution, Interface segregation, Dependency inversion.

Sorting algorithm

A method to put items in order. Common ones: merge sort, quicksort, heapsort, Timsort (Python). Good general sorts are O(n log n).

SPA (Single Page Application)

A web app that loads once and updates the view with JavaScript and API calls instead of full page reloads.

Space complexity

How much extra memory an algorithm needs as the input grows, written in Big-O.

Specificity

The weight CSS uses to choose between conflicting rules: inline > id > class > element.

Spring Boot

A layer on top of Spring that auto-configures libraries, bundles dependencies into starters and embeds a web server, so apps start with java -jar.

Spring Boot Actuator

Adds operational endpoints (health, metrics, info) for monitoring and orchestrator probes.

Spring Data JPA

A Spring module that generates repository implementations from interfaces, including queries derived from method names.

Spring Framework

A large Java framework for building applications. Its core is a container that creates objects (beans) and wires them together, with modules for web, data, security and testing.

Spring profile

A named configuration set (dev, test, prod) activated with spring.profiles.active, letting the same app use different settings per environment.

Spring proxy

A wrapper object Spring places around a bean to add behavior (transactions, caching, security). Calls inside the same class bypass it.

Spring Security

The Spring module for authentication, authorization and protection against common attacks (CSRF, session fixation...), built on a chain of servlet filters.

Sprint

A fixed period (1 to 4 weeks) in Scrum after which the team delivers a usable increment.

SQL

Structured Query Language: the language used to read and change data in relational databases (SELECT, INSERT, UPDATE, DELETE).

SQL injection

An attack where user input is inserted into a SQL query as code, letting the attacker read or change data. Prevented with parameterized queries.

SQS / SNS

AWS messaging: SQS is a queue that workers pull from; SNS publishes each message to all subscribers.

SSH

Secure Shell: an encrypted protocol to log in to and run commands on remote machines.

SSR

Server-side rendering: the server generates the HTML for a page so it arrives already filled with content.

SSRF

Server-Side Request Forgery: making your server send requests to internal or unintended addresses.

Stack

A LIFO collection (last in, first out): push adds to the top, pop removes from the top. Like a pile of plates.

Stack (tech stack)

The set of technologies used to build an application: for example React + Spring Boot + PostgreSQL.

StackOverflowError / OutOfMemoryError

StackOverflowError: the call stack is full, usually from infinite or very deep recursion. OutOfMemoryError: the heap has no room left even after garbage collection.

Staging area (index)

The waiting area where git add places changes you want in the next commit.

Staging environment

A production-like environment used to test releases before they reach real users.

Stakeholder

Anyone affected by or interested in a project: users, customers, managers, other teams.

STAR method

Situation, Task, Action, Result: a structure for answering behavioral questions with a short, concrete story.

Starter

A single Maven/Gradle dependency (like spring-boot-starter-web) that pulls in a compatible group of libraries for one purpose.

State (UI)

Data owned by a component that can change over time; changing it causes a re-render.

StatefulSet / DaemonSet / Job

StatefulSet: Pods with stable identity and storage (databases). DaemonSet: one Pod per node. Job: a run-to-completion task; CronJob: scheduled Jobs.

Stateless

The server keeps no memory of previous requests from a client; each request carries all it needs (e.g. a token).

static

A class-level member: one copy shared by all objects, usable without creating an instance (Math.max(1, 2)).

Static vs dynamic website

Static: the server sends the same ready-made files to everyone. Dynamic: the server builds the page for each request, usually with data from a database.

Status code

A 3-digit number in every HTTP response: 2xx success, 3xx redirect, 4xx client error, 5xx server error.

Stereotype annotations

@Component, @Service, @Repository, @Controller and @RestController: markers that register a class as a bean and describe its role.

Stop-the-world pause

A moment when the JVM pauses all application threads so the garbage collector can work safely. Long pauses cause latency spikes.

Story points / velocity

Story points are relative effort estimates; velocity is the number of points a team completes per sprint, used for forecasting.

Strategy pattern

Interchangeable algorithms behind one interface, chosen at runtime (e.g. different shipping cost rules).

Stream API

A way to process collections as a pipeline (filter, map, collect). Streams are lazy: nothing runs until a terminal operation such as toList() or forEach is called.

Strengths and weaknesses

Strengths: pick 2 or 3 relevant ones with a short example. Weakness: a real one that is not critical for the job, plus what you do to improve it.

String pool

A special memory area where Java keeps one copy of each string literal, so identical literals share the same object.

StringBuilder

A mutable text buffer for building strings efficiently. Unlike String, appending to it does not copy the whole text every time.

Structural typing

Type compatibility based on the shape (properties and methods) of a value, not the name of its type.

Stub

A test double that returns fixed, pre-programmed answers.

Surrogate key

An artificial identifier (auto-increment id or UUID) with no business meaning, used as a stable primary key.

Symmetric encryption

Encryption where the same secret key encrypts and decrypts (e.g. AES). Fast.

synchronized

A keyword that lets only one thread at a time run a block or method for a given lock object, and makes its changes visible to other threads.

System design

Deciding the main components of a system and how they work together to meet requirements for scale, reliability and speed.

Table

A set of rows (records) with the same columns (fields), like a spreadsheet with strict column types.

TCP

Transmission Control Protocol: a reliable connection between two machines. It guarantees that data arrives complete and in order. HTTP, databases and SSH run on top of it.

TDD (Test-Driven Development)

Writing a failing test first, then just enough code to pass it, then cleaning up: red → green → refactor.

Teamwork

Working well with others: share information, help teammates, give and accept review comments, respect different views and keep a positive attitude under pressure.

Technical debt

The future cost of quick or messy solutions taken now. It slows later changes until it is repaid.

Template Method

A base class fixes the steps of an algorithm and lets subclasses supply specific steps.

Terminal / shell

The terminal is the text window; the shell (Bash, Zsh, PowerShell) interprets the commands you type.

Terraform

A popular Infrastructure-as-Code tool that creates and updates cloud resources from configuration files.

Test case / test suite

A test case checks one scenario against an expected result. A suite is a group of test cases run together.

Test coverage

The percentage of code lines or branches executed by the test suite.

Test isolation

Each test sets up and cleans up its own data, so tests don't affect each other and can run in any order.

Test pyramid

Guideline for test mix: many fast unit tests at the bottom, fewer integration tests, very few slow end-to-end tests at the top.

Test slice

A Spring Boot test annotation that loads only part of the app (@WebMvcTest, @DataJpaTest) for fast, focused tests.

this (JavaScript)

A keyword whose value depends on how a function is called. Arrow functions take this from the surrounding code.

Thread

A sequence of instructions running inside a program. One program (process) can have several threads that share the same memory, like several cooks in one kitchen.

Thread pool

A fixed or bounded group of reusable worker threads that execute queued tasks, avoiding the cost and risk of one thread per task.

Thread stack

A per-thread memory area holding one frame per active method call with its local variables. Too many nested calls cause StackOverflowError.

Threat modeling / STRIDE

A design-time analysis of what can go wrong. STRIDE = Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege.

Throttle

Limiting a function to run at most once per time interval, even if events keep firing (e.g. scrolling).

Throughput

How much work a system completes per unit of time, e.g. requests per second.

Ticket / issue

A tracked unit of work (bug, task, story) in a tool such as Jira, with owner, status and priority.

Time complexity

How the number of steps of an algorithm grows with the input size, usually written in Big-O.

time.sleep vs asyncio.sleep

time.sleep blocks the whole thread. Inside async code use await asyncio.sleep(...), which lets other tasks run while waiting.

TLS

Transport Layer Security: the protocol that encrypts and authenticates network connections. The S in HTTPS.

TLS certificate

A digital document, signed by a trusted authority, that proves a public key belongs to a specific domain.

Token

A string a client sends to prove who it is (like a ticket), usually in the Authorization header. It replaces sending the password every time.

Token bucket

A rate limiting algorithm: tokens refill at a steady rate and each request spends one. It allows short bursts (up to the bucket size) while keeping the average rate under control.

Topological sort

Ordering the nodes of a DAG so that every node comes after the nodes it depends on.

Trade-off

A choice where improving one quality (speed) costs another (simplicity, consistency, money).

Transaction

A group of database operations treated as one unit: either all succeed (COMMIT) or all are undone (ROLLBACK).

Transitive dependency

A library pulled in automatically because one of your dependencies needs it.

Tree

A hierarchical structure of nodes: one root, each node has children, no cycles. Nodes without children are leaves.

Trie (prefix tree)

A tree where each path from the root spells a prefix; used for autocomplete and prefix searches.

try / except

Syntax to catch errors: code that might fail goes in try; the handling code goes in except SomeError:. finally always runs; else runs only if there was no error.

try-with-resources

A try statement that opens resources in parentheses and closes them automatically at the end, even after an exception.

TTL (time to live)

How long a cached item (or DNS record) stays valid before it expires and must be fetched again.

Twelve-Factor App

A set of 12 practices for cloud-friendly apps, such as config in env vars, stateless processes and logs to stdout.

Two pointers

A technique using two indexes that move through the data (from both ends, or one fast and one slow) to avoid nested loops.

Type coercion

Automatic conversion of a value from one type to another, e.g. JavaScript turning "5" into 5 when comparing with ==.

Type erasure

The compiler removes generic type arguments after checking, so at runtime List<String> and List<Integer> are both plain List.

Type hints

Annotations like def f(x: int) -> str: that document expected types. Python ignores them at runtime; tools like mypy and editors use them to find bugs.

TypeScript

JavaScript with static type annotations, checked at compile time and removed when compiled to JS.

TypeVar

A placeholder type used for generic code. T = TypeVar("T") lets a function say 'the output has the same type as the input'.

UDP

A faster, connectionless protocol with no delivery guarantee. Used for video calls, games, DNS lookups and HTTP/3 (through QUIC).

UI / UX

UI (user interface) is what the user sees and uses. UX (user experience) is the whole experience of using the product.

Unchecked (runtime) exception

An exception extending RuntimeException (NullPointerException, IllegalArgumentException...). The compiler does not force you to handle it; it usually signals a bug.

UNION

Combines the results of two SELECT queries into one list. UNION removes duplicates; UNION ALL keeps them.

Union-Find (disjoint set)

A structure that tracks which elements belong to the same group, with near-O(1) find and union operations.

UNIQUE constraint

A rule that no two rows may have the same value in that column (e.g. email).

Unit test

An automated test of a small piece of code (a function or class) in isolation, with external dependencies replaced by test doubles.

URL

Uniform Resource Locator: the address of a resource, made of scheme (https), host (example.com), optional port, path (/products) and query (?id=7).

useEffect

A React hook for side effects (fetching, subscriptions, timers) that run after render. The dependency array controls when it re-runs; the returned function cleans up.

User story

A short description of a need from the user's view: "As a ..., I want ..., so that ...", with acceptance criteria to confirm it is done.

useRef

A React hook that keeps a mutable value or a DOM node between renders without causing a re-render.

useState

A React hook that gives a component a piece of state: const [count, setCount] = useState(0). Calling the setter schedules a re-render.

UUID

Universally Unique Identifier: a 128-bit random ID like 3f2b8c1e-.... It can be generated anywhere without coordination, with a negligible chance of collision.

Validation

Checking that input data has the right shape, types and values before using it. In FastAPI done by Pydantic models.

var / let / const

Ways to declare variables in JS. var: function-scoped and hoisted (old). let: block-scoped, can be reassigned. const: block-scoped, cannot be reassigned.

Variable

A name that refers to a value stored in memory, so the value can be used or changed later.

Vertical scaling

Making one server more powerful (more CPU, RAM, disk). Simple but limited and still a single point of failure.

View

A named, saved query that behaves like a virtual table. A materialized view stores its result physically.

Virtual DOM

A lightweight in-memory description of the UI that React compares between renders to compute minimal real DOM changes.

Virtual environment

A self-contained folder with its own Python packages for one project, created with python -m venv .venv.

Virtual machine

A software emulation of a full computer, running its own operating system on top of a hypervisor.

Virtual thread

A lightweight thread (Java 21) scheduled by the JVM instead of the OS. Millions can exist, which suits I/O-heavy servers.

volatile

A field modifier guaranteeing that all threads see the latest written value. It does not make compound actions like count++ atomic.

Volume

Storage that lives outside a container's lifecycle, used to keep data such as database files.

VPC / VNet

A private, isolated virtual network in AWS (VPC) or Azure (VNet), divided into subnets.

VPN

Virtual Private Network: an encrypted tunnel between networks or devices over the internet, so they behave as if they were on the same private network.

Vulnerability

A weakness in software, configuration or process that an attacker could exploit.

WAF

Web Application Firewall: filters HTTP traffic and blocks common attacks like SQL injection and XSS before they reach the app.

WAR file

Web Application Archive: a packaged Java web app that is deployed into a servlet container such as Tomcat. Spring Boot usually builds an executable JAR instead.

Web browser

An app (Chrome, Firefox, Safari, Edge) that requests web pages from servers and displays them. It is the most common HTTP client.

Webhook

An HTTP call that a service makes to YOUR URL when an event happens (e.g. 'payment succeeded'), instead of you asking repeatedly.

WebSocket

A connection that stays open so server and client can send messages to each other at any time. Used for chat and live updates.

Window function

A function computed over a set of related rows while keeping every row: ROW_NUMBER, RANK, running totals, using OVER (PARTITION BY ... ORDER BY ...).

WIP limit

Work-in-progress limit: a Kanban rule that caps how many items can sit in a column at once, so the team finishes work before it starts more.

Worker

A process or thread that handles requests or jobs. A server often runs several workers to handle work in parallel.

Write-through cache

Every write goes to both the cache and the database, so the cache is always current.

WSGI / ASGI

Standards for how Python web servers run web apps. WSGI is synchronous (Flask, classic Django); ASGI supports async and WebSockets (FastAPI).

XSS (Cross-Site Scripting)

An attack where malicious JavaScript gets onto your site and runs in other users' browsers. Prevented by escaping output and CSP.

YAGNI

You Aren't Gonna Need It: do not build a feature until it is really needed.

YAML

A human-readable configuration format based on indentation, used by Kubernetes, Docker Compose, Spring and many CI tools.

yield

Turns a function into a generator: it pauses and hands back a value, then resumes where it stopped on the next call.