Core jargon for software architecture, delivery, and engineering culture.
Hiding how something works internally and exposing only the interface a caller needs to use it.
How tightly a module's responsibilities relate to one single purpose, rather than being a grab-bag of unrelated tasks.
Building behavior by assembling small, independent objects instead of extending a shared base class, avoiding deep and fragile class hierarchies.
The degree to which one component depends on another's internals — the tighter the coupling, the more a change on one side risks breaking the other.
An external package, library, or service that your code requires to function.
Supplying an object's dependencies from the outside instead of having it construct them itself, so those dependencies are easy to swap or mock.
Bundling data with the methods that operate on it, and blocking other code from reaching in and changing that data directly.
Services communicate by publishing and subscribing to events rather than calling each other directly — a producer emits 'something happened' and consumers react without the producer knowing who they are.
The process of attaching JavaScript event listeners and client-side state to HTML that was rendered on the server, making a static page interactive.
A defined set of operations something promises to support, without specifying how those operations are implemented internally.
A design principle where the framework calls your code, rather than your code calling the framework — the framework drives the overall flow, not you.
An architecture where an application is split into small, independently deployable services, each owning a narrow slice of functionality and communicating over a network.
A single deployable unit where all features and components of the application live together and run as one process.
Structuring a system so each part owns one distinct responsibility, with minimal overlap between parts.
Designating one system or table as the definitive record for a piece of data, so every other copy defers to it instead of drifting out of sync.
A web app that loads once and handles subsequent navigation by swapping content via JavaScript — the URL changes, but the page never fully reloads.
Pre-building all pages as static HTML at build time rather than rendering on each request, so the server just serves files with no per-request compute.
Generating the full HTML for a page on the server at request time and sending it to the browser, rather than sending a bare HTML shell and letting JavaScript build the page.