Foundations vocabulary
Name core patterns. 35 hand-written terms with real workplace examples.
Learn foundations terms every day.
One hand-written term. A real workplace example. Thirty seconds before your day gets loud.
Encapsulate What Varies
Pull the parts of your code that change into their own modules. Leave the stable parts alone.
Composition Over Inheritance
Build behavior by combining small objects instead of stacking deep parent classes.
Program to Interface
Write code against a contract, not a specific implementation. Swap implementations without rewriting callers.
Loosely Coupled
Modules know little about each other's internals. A change in one place should not ripple everywhere.
Open-Closed Principle
Design modules so you can add behavior without editing existing code. Extend through new types, not surgery on old ones.
Dependency Inversion
High-level logic should not depend on low-level details. Both should depend on abstractions.
Law of Demeter
A method should only talk to its friends, not strangers. Avoid long chains like a.b.c.d.
Hollywood Principle
Do not call us, we will call you. Framework code runs your hooks instead of your code driving the framework.
Single Responsibility
A class or module should have one reason to change. Split mixed jobs into focused pieces.
Code Review
Reading a teammate's code before merge to catch bugs, security gaps, and design drift. You judge what changed, not just whether tests pass.
Abstract Factory
A factory that creates families of related objects without naming concrete classes at the call site.
Factory Method
A method that lets subclasses decide which concrete type to build while sharing the same creation steps.
Simple Factory
A single function or type that picks and returns the right object based on input. Not a formal pattern, but common in apps.
Singleton
A type that allows only one shared instance in the app. Useful for coordinators, sometimes overused for global state.
Adapter
Wraps an object with a different interface so existing code can use it without rewrites.
Composite
Treats single items and groups the same way. Tree structures where leaves and folders share one interface.
Decorator
Adds behavior by wrapping an object in layers. Each wrapper adds one concern without changing the core type.
Facade
A simple front door to a complex subsystem. Callers use one easy API instead of many internal types.
Remote Proxy
Stands in for an object that lives on another machine. Local code talks to the proxy as if it were nearby.
Virtual Proxy
Delays creating an expensive object until something actually needs it.
Protection Proxy
Controls access to a real object. Checks permissions before forwarding the call.
Command
Packages an action as an object. Supports undo, queues, and logging because the request is a thing you can store.
Iterator
Walks through a collection one item at a time without exposing how it is stored inside.
Observer
One object tells many listeners when something changes. Each listener updates on its own. Nothing polls them one by one.
State
Lets an object change behavior when its internal mode changes. Each mode lives in its own type instead of giant switches.
Strategy
Swaps algorithms at runtime behind the same interface. Pick sorting, pricing, or shipping logic without if-else sprawl.
Template Method
Defines the skeleton of an algorithm in a base type. Subclasses fill in specific steps without changing the flow.
MVC
Model-View-Controller splits data, UI, and input handling. Model holds state, View shows it, Controller connects user actions.
Big O Notation
A way to describe how runtime or memory grows as input size increases.
Relational Database
A database that stores rows in tables and links them with keys and relationships.
Data Pipeline
A sequence of steps that moves and transforms data from sources to usable outputs.
DNS
The system that maps human-readable domain names to IP addresses computers can reach.
API Endpoint
A specific URL and method where a service accepts requests and returns responses.
Algorithmic Bias
When automated systems produce unfair outcomes because of skewed training data or design choices.
Digital Footprint
The trail of data you leave online through posts, logins, clicks, and shared files.
Building toward a role? Browse career pathways that map terms to jobs.