Glossary
Quick reference definitions for common software engineering terms.
A
Abstraction - Hiding complex implementation details behind a simpler interface, allowing users to work with concepts rather than specifics.
API (Application Programming Interface) - A contract defining how software components communicate, specifying available operations, inputs, and outputs.
Asynchronous - Operations that don’t block execution while waiting for completion, allowing other work to proceed in parallel.
B
Big O Notation - Mathematical notation describing the upper bound of an algorithm’s growth rate as input size increases.
Boilerplate - Repetitive code that appears in many places with little variation, often a candidate for abstraction or generation.
C
Cohesion - The degree to which elements within a module belong together; high cohesion means elements are strongly related.
Coupling - The degree of interdependence between modules; loose coupling means modules can change independently.
CRUD - Create, Read, Update, Delete - the four basic operations for persistent storage.
D
Dependency Injection - A technique where objects receive their dependencies from external sources rather than creating them internally.
Domain - The subject area or business context that software is designed to address.
DRY (Don’t Repeat Yourself) - A principle stating that every piece of knowledge should have a single, authoritative representation.
E
Encapsulation - Bundling data with the methods that operate on it, and restricting direct access to internal state.
Entropy - In software, the tendency for systems to become increasingly disordered over time without active maintenance.
F
Factory - A creational pattern that provides an interface for creating objects without specifying their concrete classes.
Functional Programming - A paradigm treating computation as evaluation of mathematical functions, avoiding mutable state.
I
Idempotent - An operation that produces the same result whether executed once or multiple times.
Immutable - Data that cannot be modified after creation; changes create new instances.
Interface - A contract specifying what operations a type supports, without defining implementation.
L
Latency - The time delay between a request and its response.
Loose Coupling - Design where components have minimal dependencies on each other’s internal workings.
M
Microservices - An architectural style structuring an application as a collection of small, independently deployable services.
Mock - A test double that simulates the behavior of real objects in controlled ways.
Monolith - An application built as a single, unified unit where all functionality runs in one process.
O
Orthogonality - The property where changing one thing doesn’t affect others; components are independent.
P
Polymorphism - The ability to treat objects of different types through a common interface.
Pure Function - A function whose output depends only on its inputs and has no side effects.
R
Refactoring - Restructuring existing code without changing its external behavior to improve internal quality.
Repository - A pattern that mediates between domain and data mapping layers, providing collection-like access.
S
Separation of Concerns - Organizing code so each section addresses a distinct concern or responsibility.
Side Effect - Any state change observable outside a function’s return value, such as I/O or global modification.
SOLID - Five principles of object-oriented design: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion.
SRP (Single Responsibility Principle) - A class should have only one reason to change.
T
Technical Debt - The implied cost of future rework caused by choosing expedient solutions over better approaches.
Throughput - The rate at which a system processes work, typically measured in operations per time unit.
U
Unit Test - A test that verifies a small, isolated piece of code works correctly.
This glossary grows as encyclopedia entries are added. See domain indexes for detailed articles on each concept.