Esc
↑↓ navigate   Enter open   Esc close

IT Glossary

Clear, plain-English definitions for the terms IT professionals use every day — with pronunciation guides, usage examples, and links to related exercises.

Category:

Cheat Sheets & Reference Pages

A

API (Application Programming Interface)
A set of rules that allows different software systems to communicate with each other. Think of it as a menu in a restaurant — it tells you what you can order, how to order it, and what you will get back.
ADR (Architecture Decision Record)
A document that captures an important architectural decision, including the context, options considered, and the rationale for the chosen approach.
Asynchronous
A pattern where operations happen independently of the main program flow. The caller does not wait for the operation to complete before moving on. Contrast with synchronous.

B

Backlog
An ordered list of all work items (features, bugs, technical debt) that a development team intends to work on. Maintained and prioritised by the product owner.
Blue-green deployment
A release strategy using two identical environments ("blue" and "green"). Traffic is switched to the new version (green) while the old version (blue) remains on standby for instant rollback.

C

Cache
A temporary storage layer that keeps copies of frequently accessed data so future requests can be served faster. Pronounced /kæʃ/ ("cash"), not "catch".
CI/CD (Continuous Integration / Continuous Deployment)
A practice where code changes are automatically tested (CI) and deployed to production (CD) after passing all checks, reducing manual effort and human error.
Containerisation
Packaging an application and its dependencies into a container (e.g. Docker) so it runs consistently across different environments.

D

Daemon
A background process that runs continuously without direct user interaction. Pronounced /ˈdiːmən/ ("DEE-mon"). Common in Linux systems (e.g. sshd, nginx).
Dependency injection
A design pattern where objects receive their dependencies from an external source rather than creating them internally. Improves testability and decoupling.
DNS (Domain Name System)
The "phone book" of the internet. It translates human-readable domain names (e.g. google.com) into machine-readable IP addresses.

E

Edge computing
Processing data closer to its source (at the "edge" of the network) rather than in a central data centre, reducing latency for end users.
Endpoint
A specific URL path in an API where a client can send requests. For example, /api/v1/users is an endpoint for user-related operations.

I

Idempotent
An operation that produces the same result regardless of how many times it is executed. HTTP PUT and DELETE should be idempotent; POST is typically not.
IaC (Infrastructure as Code)
Managing and provisioning infrastructure (servers, networks, databases) through machine-readable configuration files rather than manual processes.

L

Latency
The time delay between a request being sent and the response being received. Measured in milliseconds (ms). Low latency = fast response time.
Load balancer
A component that distributes incoming network traffic across multiple servers to prevent any single server from becoming a bottleneck.

M

Microservices
An architectural style where an application is built as a collection of small, independent services that communicate over APIs. Contrast with a monolith.
Middleware
Software that sits between two systems, intercepting and processing requests or responses. In web frameworks, middleware typically handles auth, logging, or request parsing.
Mutex (Mutual Exclusion)
A synchronisation primitive that prevents multiple threads from accessing a shared resource simultaneously, avoiding race conditions.

R

Race condition
A bug that occurs when a program's behaviour depends on the timing or sequence of uncontrollable events (e.g. two threads modifying the same data simultaneously).
Refactoring
Restructuring existing code to improve its internal structure without changing its external behaviour. Reduces technical debt and improves maintainability.
REST (Representational State Transfer)
An architectural style for APIs that uses standard HTTP methods (GET, POST, PUT, DELETE) and stateless communication. RESTful APIs are the most common web API type.

S

SLA (Service Level Agreement)
A formal contract between a service provider and a customer defining the expected level of service, including uptime guarantees and response times.
SLI (Service Level Indicator)
A measurable metric that indicates how well a service is performing (e.g. request latency, error rate, availability percentage).
SLO (Service Level Objective)
A target value for an SLI. For example, "99.9% of requests should complete in under 200ms." An SLO is an internal goal; an SLA is an external commitment.
Slug
A URL-friendly string derived from a page title or name, using only lowercase letters, numbers, and hyphens. For example, the slug for "Getting Started" might be getting-started.
SQL (Structured Query Language)
The standard language for managing relational databases. Used to create, read, update, and delete data. Pronounced "sequel" (S-Q-L). Dialects include PostgreSQL, MySQL, and SQLite.
Sprint
A fixed-length iteration in Agile/Scrum (typically 1–2 weeks) during which the team completes a defined set of tasks. At the end of a sprint, working software should be delivered.
Stack
A set of technologies used together to build an application (e.g. MEAN stack: MongoDB, Express, Angular, Node.js). Also a data structure where items are added and removed from the top (last in, first out).
State
The data or condition of a system at a given point in time. In frontend development, UI state drives what is displayed. In distributed systems, stateful services store session data between requests; stateless services do not.
Static
Not changing at runtime. A static site is pre-generated HTML/CSS/JS served without a backend. A static variable belongs to the class rather than an instance.
Stateless
A system that does not retain information about previous interactions. Each request is treated independently. REST APIs are stateless by design.
Stub
A simplified replacement for a dependency in testing — it returns hardcoded responses without executing real logic. Similar to a mock, but stubs typically focus on providing canned answers rather than verifying calls.

T

Technical debt
The future cost of rework caused by choosing a quick solution now instead of a better, more time-consuming approach. Like financial debt, it accumulates interest over time.
Throughput
The amount of work a system can handle per unit of time (e.g. requests per second, transactions per minute). Distinct from latency.
Token
A string that represents a credential or identity. Access tokens (short-lived) and refresh tokens (long-lived) are used in OAuth flows. In AI/NLP, a token is a unit of text (roughly a word or subword) that a language model processes.
Transaction
A sequence of database operations treated as an atomic unit — either all succeed or all are rolled back. Transactions follow ACID properties (Atomicity, Consistency, Isolation, Durability).
Type checking
Verifying that values in a program are used consistently with their declared types. Static type checking happens at compile time (TypeScript, Java); dynamic type checking happens at runtime (Python, JavaScript).

F

Feature flag
A configuration switch that enables or disables a feature at runtime without deploying new code. Also called a feature toggle.
Fork
A copy of a repository that is independent of the original. You can make changes in your fork without affecting the upstream project.
Framework
A pre-built structure or scaffold that provides common patterns and tools for building applications. Frameworks are opinionated — they constrain how you write your code in exchange for productivity.
Function
A named block of reusable code that performs a specific task. In functional programming, a pure function produces the same output for the same input and has no side effects.

G

Garbage collection
An automatic memory management process that identifies and frees memory that is no longer used by a program. Pronounced "GC". Java, Python, and Go all use garbage collection.
Git
A distributed version control system that tracks changes in source code. Git allows multiple developers to collaborate on a codebase without overwriting each other's work.
GraphQL
A query language and runtime for APIs that allows clients to request exactly the data they need, avoiding over-fetching or under-fetching that is common with REST.

H

Heap
A region of memory used for dynamic allocation. Objects allocated at runtime live on the heap; they persist until explicitly freed or garbage collected.
HTTP (Hypertext Transfer Protocol)
The foundation of data communication on the web. Defines how messages are formatted and transmitted between clients and servers. HTTPS is the secure (encrypted) version.
Hook
In React, a function that lets you manage state and side effects inside a functional component (e.g. `useState`, `useEffect`). More broadly, a hook is a callback invoked at a specific point in a lifecycle.

J

JWT (JSON Web Token)
A compact, URL-safe token for securely transmitting information between parties. Commonly used for authentication and session management. Pronounced "jot".
JSON (JavaScript Object Notation)
A lightweight data-interchange format that is easy for humans to read and for machines to parse. The most common format for REST API payloads.

K

Kubernetes
An open-source container orchestration platform that automates deployment, scaling, and management of containerised applications. Often abbreviated as K8s (K + 8 letters + s).

N

Namespace
A logical grouping that organises identifiers (classes, functions, variables) to avoid naming conflicts. In Kubernetes, namespaces isolate resources within a cluster.
Node
In a distributed system, any device or instance that participates in the network. In Kubernetes, a node is a worker machine (VM or physical) that runs pods.
Null
A value (or the absence of a value) representing "nothing here". Accessing a property of null when you expect an object is one of the most common runtime errors.

O

OAuth (Open Authorisation)
A standard protocol that lets users grant third-party applications limited access to their resources without sharing passwords. The scheme behind "Sign in with Google".
ORM (Object-Relational Mapper)
A library that translates between your application's objects and database tables, so you can interact with a database using your programming language rather than raw SQL.
Overhead
Any extra cost (time, memory, network calls) incurred beyond the minimum needed to accomplish a task. "This adds too much overhead" means it costs more than it's worth.

P

Payload
The data being sent in a network request or response body — as opposed to the metadata in headers or the URL.
Pipeline
A sequence of automated steps that processes code or data. A CI pipeline runs tests; a data pipeline transforms raw data into a usable format.
Pod
The smallest deployable unit in Kubernetes — typically one or more containers that share a network namespace and storage.
Polling
repeatedly checking a resource at regular intervals to detect changes, as opposed to being notified (push). Polling is simpler to implement but less efficient.

Q

Queue
A data structure (and messaging pattern) where items are processed in the order they arrive — first in, first out (FIFO). Message queues decouple producers from consumers.
Query
A request for data from a database or API. In SQL, a query is written in a SELECT statement; in GraphQL, a query is the operation that fetches data.

U

Unit test
A test that verifies a single, isolated piece of functionality (a function, a method) in isolation from the rest of the system. The fastest and most granular type of test.
URL (Uniform Resource Locator)
The address of a resource on the web. Consists of a scheme (https://), domain (example.com), optional path (/users/42), and optional query string (?filter=active). Pronounced as individual letters: U-R-L.
UUID (Universally Unique Identifier)
A 128-bit identifier that is statistically guaranteed to be unique. Used for IDs in distributed systems where a central authority cannot assign sequential IDs.

V

Version control
A system that records changes to files over time so you can recall specific versions later. Git is the dominant version control system in modern software development.
Versioning
The practice of assigning unique version identifiers to releases (e.g. Semantic Versioning: MAJOR.MINOR.PATCH). API versioning allows clients to use a stable interface while the API evolves.
Virtual machine
Software that emulates a complete computer, allowing multiple operating systems to run on a single physical host. Abbreviated as VM.
Vulnerability
A weakness in a system that could be exploited by an attacker. CVE (Common Vulnerabilities and Exposures) is the industry standard for identifying and tracking vulnerabilities.

W

Webhook
A mechanism where one system sends an HTTP POST notification to another when a specific event occurs — an "HTTP callback". GitHub uses webhooks to notify CI systems when code is pushed.
WebSocket
A protocol providing a persistent two-way communication channel between client and server over a single TCP connection. Used for real-time features like chat, live updates, and collaborative editing.

X

XSS (Cross-Site Scripting)
A security vulnerability where an attacker injects malicious scripts into web pages viewed by other users. Prevented by escaping user-supplied output and using a Content Security Policy (CSP). Ranked in the OWASP Top 10.

Y

YAML (YAML Ain't Markup Language)
A human-readable data serialisation format widely used for configuration files (Docker Compose, Kubernetes, GitHub Actions, Ansible). Whitespace-significant — indentation defines structure. Pronounced "YAM-ul".