A software design pattern is a named, reusable approach to a design problem that keeps recurring, such as how to create objects, how to notify interested parties when something changes, or how to add behavior without multiplying subclasses. Patterns are vocabulary and options. They are not drop-in code templates, and using one does not make a design better by default. The rest of this article explains the main patterns by the pressure each one addresses, shows how to tell look-alike structures apart, and sets out when a pattern is worth its added complexity.
What a design pattern is, and what it is not
A pattern describes a recurring solution idea. It names the conflict, outlines the shape of a fix, and gives developers a shared term for it. Two teams that both say “Observer” should mean the same thing: one object publishes changes, and other objects subscribe to be told about them. The name does not dictate class names, file layout, or the exact number of classes you write.
As an Amazon Associate I earn from qualifying purchases.
That distinction matters because patterns are often learned as diagrams and then applied mechanically. A pattern that fits a Java codebase from the 1990s may map onto a language feature in Python, Go, or TypeScript. In many cases the language already provides the mechanism, and the pattern survives only as a name for the idea.
Recommended Free Tools
How the catalog is organized
Refactoring.Guru’s catalog of design patterns presents 22 classic patterns, grouped into three families. The family tells you what kind of problem a pattern solves: creational patterns concern how objects are made, structural patterns concern how objects are composed, and behavioral patterns concern how objects collaborate and distribute responsibility.
#1 Best Overall
| Family | Patterns in the Refactoring.Guru catalog | Count |
|---|---|---|
| Creational | Factory Method, Abstract Factory, Builder, Prototype, Singleton | 5 |
| Structural | Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy | 7 |
| Behavioral | Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor | 10 |
Why sources give different counts
Greg Bryant’s Patterns Guru describes the original Gang of Four catalog as 23 patterns. The difference is scope, not a factual error on either side. Refactoring.Guru leaves Interpreter out of its main catalog and explains why it treats that pattern as niche. If you read a book or course that lists 23, expect Interpreter to be included. Neither publisher’s catalog description is dated in the pages consulted, so treat the numbers as the scope each source chose rather than a fixed standard.
Creational patterns: controlling how objects are made
Creational patterns become useful when the code that needs an object should not be the code that decides exactly which kind to build, or when the number of instances needs to be controlled.
Factory Method
Factory Method provides an interface for creating an object while letting subclasses decide which concrete product to produce. Consider a reporting module. The base class ReportCreator contains the logic for generating and sending a report, and calls an overridable method such as create_exporter(). A PdfReportCreator subclass returns a PDF exporter, and a CsvReportCreator returns a CSV exporter. The shared workflow stays in one place, and each subtype controls only its own product.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Use it when client code should depend on a product abstraction and the concrete product genuinely varies by subtype. If there is only one product and no realistic variation, a plain function call is usually clearer.
Rank #2
Singleton
Singleton restricts a class to a single instance and gives the rest of the program one shared access point to it. A configuration loader or a connection pool manager is a typical candidate.
The constraint is the point, and it has costs. A singleton is effectively shared global state. Code that reaches for it becomes harder to test in isolation, because tests share the same instance and can leave it changed for one another. Before choosing Singleton, ask whether one instance is a real requirement of the domain or merely a convenient way to pass an object around. Passing the dependency explicitly is often the simpler alternative.
Behavioral patterns: coordinating behavior and change
Behavioral patterns address how objects communicate and how behavior is selected, shared, or replaced.
Observer
Observer establishes a subscription mechanism. A subject keeps a list of observers and notifies each one when its state or an event changes. A price feed that updates a dashboard, a chart, and an alert service is a natural case: the feed does not need to know what each consumer does with the update.
In modern environments the same idea often appears as event listeners, callbacks, or reactive streams. Those facilities can express the pattern without a hand-written subject class. The trade-off to watch is that notifications can become hard to follow when many subscribers react to each other, so the flow of control is less visible in the code than a direct call.
Strategy
Strategy defines a family of algorithms behind a common contract, so the caller can swap one for another without changing its own logic. A shipping checkout is a good example. The checkout code asks a shipping calculator for a cost. Standard, express, and pickup calculators each implement the same method, and the checkout selects one at runtime. Adding a new carrier means adding a new strategy, not editing the checkout flow.
Structural patterns: arranging objects around one another
Structural patterns deal with how objects are wrapped, combined, or presented to other code.
Decorator
Decorator wraps an object with another object that shares its interface, and adds behavior before or after delegating to the wrapped object. Because each wrapper has the same interface, wrappers can be stacked in different combinations without writing a subclass for every combination.
class Notifier:
def send(self, message):
print(f"Email: {message}")
class EncryptingNotifier:
def __init__(self, wrapped):
self._wrapped = wrapped
def send(self, message):
self._wrapped.send(f"[encrypted] {message}")
notifier = EncryptingNotifier(Notifier())
notifier.send("Your order has shipped")The wrapper changes the message before delegating. A logging wrapper could instead record the call after delegating. Either way, the caller still sees a notifier with a send method and does not need to know how many layers exist.
Adapter
Adapter translates an existing interface into the one a client expects. If a payment library exposes charge(amount_cents) but your application code calls pay(amount_dollars), an adapter sits between them and performs the translation. Adapter exists because two interfaces disagree; Decorator exists because one interface needs more behavior. The next section makes that difference explicit.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Telling similar structures apart
Several patterns produce code that looks alike: each one holds a reference to another object and forwards calls to it. The differences lie in intent and in what happens to the interface. Refactoring.Guru’s comparisons of Decorator with Adapter, Proxy, and Strategy draw the following distinctions.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
| Pattern | Primary intent | Effect on the interface |
|---|---|---|
| Decorator | Adds behavior by wrapping an object | Preserves the interface, or extends it |
| Adapter | Translates one interface into the one a client expects | Changes the interface |
| Proxy | Controls access to an object | Not stated in this comparison |
| Strategy | Swaps the algorithm or behavior used by the caller | All strategies implement one shared contract |
When two patterns seem to fit, work through these questions in order:
Best Value
- What is the pressure? Conflicting interfaces, missing behavior, restricted access, or a choice among algorithms.
- What varies? The implementation, the behavior added, the caller, or the set of alternatives.
- Does the public interface change? If yes, Adapter is the likely candidate. If it stays the same, consider Decorator, Proxy, or Strategy.
- Who controls creation or lifetime? Some patterns decide when and how objects are built; others only wrap or forward them.
- How much indirection does it add? Each wrapper or layer is one more place a reader must follow.
- Does the language already cover it? Function parameters, closures, and event systems can replace a class hierarchy in many cases.
When a pattern earns its place
A pattern is worth using when it names a real recurring conflict and gives the design the flexibility that conflict requires. Bryant’s guide puts the principle directly: “The idea is not to ‘use lots of patterns’.” It also advises: “If language features already resolve these pressures, use them.” Both lines reflect the same test. Before reaching for Factory Method or Observer, confirm that the pressure exists in your code today, not in a hypothetical future.
Empirical evidence does not settle the question either. Bryant’s guide notes that studies of whether named patterns improve software are mixed, and that results depend on context and on how they are measured. Nothing in this overview establishes that a pattern automatically raises productivity or quality, so judge each use by the clarity it adds to the specific code in front of you.
Bryant also frames the practical standard as naming the problem first. As he writes, “If you can’t name the pressures, using a pattern is less enlightening.” Patterns are most valuable to learners when they make a design conversation more precise. Used as a checklist of things to insert, they add indirection without adding understanding.
For a deeper treatment of the original catalog, the 1994 book Design Patterns: Elements of Reusable Object-Oriented Software by Gamma, Helm, Johnson, and Vlissides remains the standard reference. Check a current edition for availability and pricing before buying.
Are design patterns still useful? Yes, as shared vocabulary and as a way to recognize a recurring conflict. They are less useful as mandatory structures. Learn the pressure each one addresses, check whether your language already solves it, and add the pattern only when the flexibility it provides is one your code actually needs.
Quick Recap
“
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
