Design Patterns Vocabulary — Software Architecture Exercises

1 / 5

Your tech lead describes the Factory Method pattern: "It lets subclasses decide which class to instantiate." A colleague asks which pattern goes further by providing "an abstract interface for creating families of related objects without specifying their concrete classes." Which pattern is your colleague describing?

Creational pattern vocabulary comparison:

The Abstract Factory is the correct answer. It extends Factory Method by grouping related factories behind a common interface, ensuring that the products from a single factory are compatible with each other.

Pattern	Creates	Key vocabulary	Example
Factory Method	One product via subclass override	"lets subclasses decide which class to instantiate"	LoggerFactory.create()
Abstract Factory	Families of related products	"interface for creating families… without specifying concrete classes"	UIFactory → Button + Checkbox (per OS theme)
Builder	One complex object step by step	"separates construction from representation"	QueryBuilder.select().where().limit()
Prototype	Copies of existing instances	"cloning", "copy constructor"	config.clone() with overrides

How to use this in an architecture discussion: "We're using an Abstract Factory so the UI layer can switch between the Material and Fluent design systems without touching the component consumers — the factory guarantees the products are always from the same family."

2 / 5

A tech lead says: "We used the observer pattern so our UI components subscribe to the data model and update automatically when state changes." In a system design review, how would you correctly describe the key vocabulary difference between the observer pattern and the pub/sub messaging pattern?

Observer vs. pub/sub vocabulary distinction:

The key architectural difference is coupling and synchrony, not just naming.

Dimension	Observer pattern	Pub/Sub pattern
Coupling	Subject holds references to observers — tight coupling	Publisher and subscriber know only the broker — fully decoupled
Synchrony	Typically synchronous (observers called in-process)	Typically asynchronous (messages queued in broker)
Location	In-process, single application	Cross-process, distributed systems
Examples	DOM EventTarget, Redux store subscriptions, React Context	Kafka topics, RabbitMQ exchanges, SNS/SQS

Architecture discussion phrases:

"The observer pattern gives us synchronous state propagation within the process, but if we need cross-service notifications we'd move to a pub/sub broker."
"The trade-off of observer is that slow observers block the subject's notification loop — pub/sub avoids this by decoupling delivery."

3 / 5

A senior engineer describes your Express.js middleware pipeline: "Each middleware function wraps the next one, adding behaviour before and after — the request flows in, gets transformed, and flows out." Which design pattern term most precisely describes this structure?

Structural pattern vocabulary — Decorator vs. similar patterns:

The Decorator pattern best describes middleware wrapping. The defining characteristic is that each layer wraps the next and executes code both before and after delegating to the inner call — exactly the middleware model.

Pattern	Core mechanism	Distinguishing feature
Decorator	Wraps an object, delegates to it, adds behaviour around the call	Layered wrapping; before + after hooks; same interface as wrapped object
Strategy	Swaps a pluggable algorithm implementation	No wrapping; replaces not augments; single active strategy at a time
Chain of Responsibility	Linear chain; each handler decides to handle or pass	Handlers are independent; the chain stops when one handles the request
Proxy	Controls access to a specific object	Single wrapping layer; access control focus, not behaviour augmentation

Real-world examples to cite in discussions:

Python function decorators (@login_required, @cache) — Decorator pattern
Express.js / Koa middleware pipelines — Decorator pattern
Java servlet filters — Decorator pattern

4 / 5

Your tech lead describes a new service: "We created a single OrderService class that coordinates inventory, payment, and shipping. Callers don't need to know anything about the subsystems — they just call OrderService.placeOrder()." Which design pattern does this implement?

Structural pattern vocabulary — Facade:

The Facade pattern is exactly this: a layer that simplifies access to a complex subsystem by exposing a coherent high-level interface.

Pattern	Purpose	Relationship to subsystem
Facade	Simplifies a complex subsystem for external callers	Hides multiple subsystems behind one entry point
Mediator	Reduces coupling between peer objects that interact with each other	Objects coordinate through the mediator, which routes messages between them
Proxy	Controls access to one specific object	One-to-one substitution; same interface as the wrapped object
Adapter	Translates one interface into another expected by the client	Interface translation, not simplification

Facade vocabulary phrases for architecture discussions:

"The Order API is a facade over three bounded contexts — it keeps the client simple while the domain complexity lives behind the boundary."
"We deliberately kept the facade thin — business logic belongs in the subsystems, not in the coordination layer."
"The facade also acts as an anti-corruption layer between the external API contract and our internal domain model."

5 / 5

An architect says: "We need an adapter to make this third-party payment SDK fit our domain's PaymentGateway interface — the SDK's method signatures are completely different from what our code expects." In an architecture review, how would you correctly distinguish the Adapter pattern from the Bridge pattern?

Adapter vs. Bridge — structural pattern vocabulary:

These two patterns look similar in structure (both involve an intermediary class) but differ fundamentally in intent and timing.

Dimension	Adapter	Bridge
Intent	Make incompatible interfaces work together	Decouple abstraction from implementation so each can vary independently
Design timing	Retroactive — applied after the fact to patch an incompatibility	Upfront — designed intentionally before implementation to allow extensibility
When to use	Integrating third-party SDKs, legacy code, or external APIs into your domain model	Designing an abstraction that must support multiple implementations (e.g., multiple rendering backends)
Key vocabulary	"wrapper", "translation layer", "anti-corruption layer"	"abstraction", "implementor", "decouple", "vary independently"

Architecture phrasing:

"We're wrapping the Stripe SDK behind our PaymentGateway interface — that's a classic adapter; we own the interface, not the implementation."
"The notification system uses a Bridge so we can add new channel implementations (email, SMS, push) without modifying the notification abstraction layer."