ACID
ACID stands for Atomicity, Consistency, Isolation, and Durability - the four guarantees a relational database transaction provides. Atomicity makes a transaction all-or-nothing; Consistency keeps the database valid; Isolation hides concurrent transactions from each other; Durability persists committed data across crashes.
BASE
BASE stands for Basically Available, Soft state, Eventually consistent - a consistency philosophy common to NoSQL and distributed systems that trades the strict guarantees of ACID for availability and scale. It accepts temporary inconsistency in exchange for partition tolerance and throughput.
CAP Theorem
The CAP theorem (Brewer's theorem) states that a distributed data store can provide at most two of Consistency, Availability, and Partition tolerance simultaneously. Because network partitions are unavoidable, real systems effectively choose between consistency and availability when a partition occurs.
CRUD
CRUD stands for Create, Read, Update, Delete - the four basic operations of persistent storage. It is often used to describe the scope of a data-centric service or REST resource. Many frameworks scaffold CRUD endpoints automatically.
CQRS (Command Query Responsibility Segregation)
CQRS separates the model used to write data (commands) from the model used to read it (queries), allowing each to be optimised independently. It is often paired with event sourcing and read-side projections. It adds complexity and is justified only when read and write workloads diverge significantly.
DTO (Data Transfer Object)
A DTO is a simple object used to carry data across a boundary, such as between a service layer and an API client, without behaviour or domain logic. DTOs decouple the external contract from the internal domain model. In Java they are commonly implemented as records.
DI (Dependency Injection)
DI is the practice of providing a component's dependencies from outside rather than constructing them internally. It is the most widely used implementation of Inversion of Control. Spring, Guice, and Dagger are popular DI containers.
DDD (Domain-Driven Design)
DDD is a design philosophy that models software around the business domain using a shared ubiquitous language, with strategic patterns for system boundaries and tactical patterns for the model itself. It aims to align code structure with domain experts' mental model.
E2E (End-to-End Test)
An E2E test exercises a complete user flow through the fully integrated system, often driving a real browser or client. It provides the highest confidence but is the slowest and most brittle test type. The testing pyramid recommends few E2E tests relative to unit tests.
ETL (Extract, Transform, Load)
ETL describes a data pipeline that extracts data from sources, transforms it into a target shape, and loads it into a destination such as a data warehouse. A variant, ELT, loads raw data first and transforms it in place. ETL is foundational to analytics and reporting systems.
gRPC
gRPC is a high-performance remote procedure call framework using HTTP/2 for transport and Protocol Buffers for its interface definition and binary serialization. It supports streaming and strongly-typed contracts, making it popular for internal service-to-service communication.
IoC (Inversion of Control)
IoC is a design principle in which control over object construction and program flow is delegated to a framework or container instead of being hard-coded in application logic. Dependency Injection is its most common realisation.
JWT (JSON Web Token)
A JWT is a compact, URL-safe token format that encodes claims as a signed (and optionally encrypted) JSON payload, commonly used for stateless authentication. It consists of a header, payload, and signature separated by dots. Because the payload is only Base64-encoded, it must never carry secrets in plaintext.
KISS (Keep It Simple, Stupid)
KISS is a design maxim stating that systems work best when kept simple rather than made unnecessarily complex. It favours the most straightforward solution that meets the requirement. It complements YAGNI and DRY.
LSP (Liskov Substitution Principle)
LSP is the "L" in SOLID: subtypes must be substitutable for their base types without breaking client expectations. It governs the correct use of inheritance and subtyping.
MVC (Model-View-Controller)
MVC is an architectural pattern that separates an application into a model (data and rules), a view (presentation), and a controller (input handling and coordination). It promotes separation of concerns in user-facing applications and underlies many web frameworks.
MVP (Minimum Viable Product)
An MVP is the smallest version of a product that delivers enough value to learn from real users with minimal effort. The term is central to Lean Startup methodology. In engineering it implies building a thin but complete vertical slice.
N+1 Problem
The N+1 problem is a performance anti-pattern in which an ORM issues one query to load a list of N entities, then one additional query per entity to load a related field, producing N+1 queries instead of one. It is solved with eager fetching, join fetches, or batch loading.
OCP (Open/Closed Principle)
OCP is the "O" in SOLID: software entities should be open for extension but closed for modification. New behaviour is added through new code rather than by editing existing tested code.
OOP (Object-Oriented Programming)
OOP is a programming paradigm that structures software around objects bundling state and behaviour, with mechanisms such as encapsulation, inheritance, and polymorphism. It contrasts with procedural and functional paradigms, which many modern languages blend.
ORM (Object-Relational Mapping)
ORM is a technique that maps object-oriented domain models to relational tables, generating SQL automatically. It improves productivity at the risk of hiding query cost. JPA is the standard ORM specification in Java, with Hibernate as its leading implementation.
REST (Representational State Transfer)
REST is an architectural style for distributed hypermedia systems, defining constraints such as statelessness, a uniform interface, and resource-based addressing over HTTP. RESTful APIs are the dominant style for public web services.
SLA / SLO / SLI
An SLI (Service Level Indicator) is a measured quantity such as request latency; an SLO (Service Level Objective) is a target for that indicator such as "99% of requests under 200 ms"; an SLA (Service Level Agreement) is a contractual commitment with consequences. Together they form the basis of reliability engineering.
SOLID
SOLID is a mnemonic for five object-oriented design principles - Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion - that promote maintainable, flexible code.
SRP (Single Responsibility Principle)
SRP is the "S" in SOLID: a module should have a single reason to change, serving one actor or concern. Violations lead to fragile code where unrelated changes interfere.
TDD (Test-Driven Development)
TDD is a development workflow that writes tests before production code, cycling through red (failing test), green (passing code), and refactor. It drives design and produces a regression safety net as a by-product.
TTL (Time To Live)
TTL is a duration after which a cached value, DNS record, or message is considered expired and removed or refreshed. It is the simplest cache-invalidation strategy, trading freshness for implementation simplicity.
YAGNI (You Aren't Gonna Need It)
YAGNI is an Extreme Programming principle stating that functionality should be added only when actually needed, not when merely anticipated. It curbs speculative over-engineering.
WAL (Write-Ahead Log)
A WAL is a durability technique in which changes are appended to a sequential log before being applied to the main data store, so the system can recover by replaying the log after a crash. It underpins the Durability guarantee in relational databases and many distributed systems.
CI/CD
CI/CD combines Continuous Integration (automated build and test on every merge) with Continuous Delivery or Deployment (automated promotion of validated builds toward production). The pipeline shortens feedback loops and reduces release risk.
SSR (Server-Side Rendering)
SSR is a web rendering strategy where HTML is generated on the server for each request (or prerendered at build time) rather than constructed entirely in the browser. It improves first-paint performance and SEO at the cost of server work.