Files
skills/public/engineering-design-patterns.html
zeekayandHanzo Dev 9e10c1c10e Each llms index points at the other two
hanzoskills.com/llms.txt now opens with the install line, the API
reference index and the company index, so an agent that lands on any
one of the three can find the rest.

robots.txt claimed 537 documents while llms.txt counts 920. The number
is gone from robots.txt; llms.txt derives it.

public/ is regenerated from scripts/site.py, which it had fallen
behind: the copy-prompt menu and agent bar were in the generator and
not in the committed pages. tests/site.mjs passes against the result.

Co-authored-by: Hanzo Dev <[email protected]>
2026-09-11 00:27:59 -07:00

778 lines
30 KiB
HTML

<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>engineering-design-patterns</title>
<meta name="color-scheme" content="dark">
<style>
/* Committed to one visual world: a dark instrument panel. No light variant —
the dot field and the hairline rules only read on black, and a naive
inversion would wash both out. Every colour is painted explicitly so the page
never borrows a host background. */
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
:root{
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
--font-zen-pixel-square:'Zen Pixel Square',monospace;
--mono:var(--font-zen-mono);
--sans:var(--font-zen-sans);
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
--r:999px; --r-soft:14px;
}
*{box-sizing:border-box}
html{-webkit-text-size-adjust:100%}
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
/* The dot field. A halftone made of one repeating radial-gradient, faded out
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
/* No overflow clip here: the dot field is inset to the box already, and a clip
would cut off the copy-prompt menu. */
.hero{position:relative;border-bottom:1px solid var(--line)}
.hero::before{content:"";position:absolute;inset:0;
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
background-size:7px 7px;
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
pointer-events:none}
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
nav{border-bottom:1px solid var(--line)}
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
justify-content:space-between;align-items:center;gap:1rem}
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--ink);text-decoration:none;
display:inline-flex;align-items:center;gap:.6rem}
.brand i{font-style:normal;color:var(--faint)}
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--soft);text-decoration:none}
nav a.up:hover{color:var(--ink)}
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
h1 em{font-style:normal;color:var(--faint)}
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
line-height:1.2;font-weight:400}
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
.btn.solid:hover{background:#d8d8d4}
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
/* Copy-prompt selector. Each row copies the prompt for its own target. */
.copy{position:relative;display:inline-flex}
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
padding:.4rem;display:flex;flex-direction:column;
box-shadow:0 12px 32px rgba(0,0,0,.75)}
.menu[hidden]{display:none}
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
white-space:nowrap}
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
.mi:hover .mark{color:var(--ink)}
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
letter-spacing:.1em;text-transform:uppercase}
/* Works-with bar: one scrolling row, name and mark per agent. */
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
display:flex;align-items:center}
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
-webkit-overflow-scrolling:touch;
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
.bar::-webkit-scrollbar{display:none}
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
text-decoration:none;background:var(--ground)}
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
.agent .mark{width:.95rem;height:.95rem}
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
p{margin:0 0 1rem;max-width:70ch}
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
li{margin:.22rem 0}
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
text-decoration-color:var(--line-hi)}
a:hover{text-decoration-color:var(--ink)}
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
display:block;overflow-x:auto}
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
.curl{display:block;background:var(--panel);border:1px solid var(--line);
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
white-space:pre;line-height:1.9}
.curl b{color:var(--ink);font-weight:400}
.curl i{font-style:normal;color:var(--faint)}
/* index */
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
#q:focus{outline:none;border-color:var(--soft)}
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
text-transform:uppercase;margin:0 0 2rem}
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
padding-bottom:.45rem}
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
border-radius:var(--r-soft);text-decoration:none}
.row:hover{background:#0a0a0a}
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
color:var(--faint);font-size:.85rem}
footer a{color:var(--soft)}
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
margin:0 0 2rem;font-size:.85rem}
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
border-bottom:1px solid var(--line);padding-bottom:.4rem}
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
.fmap a:hover{text-decoration:underline}
.fmap div{color:var(--faint);line-height:1.5}
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
@media (max-width:640px){
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
.btns{gap:.5rem}
.btn{padding:.75rem 1.15rem;font-size:.68rem}
.copy,.copy .btn{width:100%;justify-content:center}
.menu{left:0;right:0;min-width:0}
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
.strip b{border-right:0;padding-right:0}
.bar{width:100%}
}
</style>
<link rel="alternate" type="text/markdown" href="/engineering-design-patterns.md">
<link rel="icon" href="/favicon.svg">
<link rel="canonical" href="https://hanzoskills.com/engineering-design-patterns">
</head>
<!-- Reading this with a machine? Every page here is also plain markdown.
This one: https://hanzoskills.com/engineering-design-patterns.md
Index: https://hanzoskills.com/llms.txt
Corpus: https://hanzoskills.com/all.md
Append .md to any path for the markdown twin. -->
<body>
<nav><div class="in">
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
<a class="up" href="/">All skills</a>
</div></nav>
<div class="wrap">
<h1>engineering-design-patterns</h1><p class="lede">Gang of Four design patterns, when to use each pattern, implementation examples, and anti-patterns</p><h1>Software Design Patterns</h1>
<p><strong>Scope</strong>: Comprehensive guide to GoF design patterns, usage scenarios, implementations, and anti-patterns <strong>Lines</strong>: ~400 <strong>Last Updated</strong>: 2025-10-27 <strong>Format Version</strong>: 1.0 (Atomic)</p>
<hr>
<h2>When to Use This Skill</h2>
<p>Activate this skill when:</p>
<ul><li>Solving recurring design problems</li><li>Improving code flexibility and extensibility</li><li>Refactoring complex code</li><li>Designing APIs or frameworks</li><li>Establishing architectural patterns</li><li>Training engineers on design principles</li><li>Reviewing code for design improvements</li><li>Choosing between pattern alternatives</li></ul>
<h2>Core Concepts</h2>
<h3>Concept 1: Pattern Categories</h3>
<p><strong>Creational Patterns</strong> (object creation):</p>
<ul><li>Factory Method, Abstract Factory</li><li>Builder, Prototype, Singleton</li></ul>
<p><strong>Structural Patterns</strong> (object composition):</p>
<ul><li>Adapter, Bridge, Composite</li><li>Decorator, Facade, Proxy</li></ul>
<p><strong>Behavioral Patterns</strong> (object interaction):</p>
<ul><li>Strategy, Observer, Command</li><li>Template Method, Iterator, State</li></ul>
<hr>
<h2>Creational Patterns</h2>
<h3>Pattern 1: Factory Method</h3>
<p><strong>Problem</strong>: Need flexible object creation without specifying exact class</p>
<pre><code class="lang-python">from abc import ABC, abstractmethod
# Product
class Button(ABC):
@abstractmethod
def render(self) -&gt; str:
pass
class HTMLButton(Button):
def render(self) -&gt; str:
return &quot;&lt;button&gt;Click me&lt;/button&gt;&quot;
class SwiftButton(Button):
def render(self) -&gt; str:
return &quot;UIButton(title: &#x27;Click me&#x27;)&quot;
# Creator
class Dialog(ABC):
@abstractmethod
def create_button(self) -&gt; Button:
pass
def render(self) -&gt; str:
button = self.create_button()
return f&quot;Dialog with {button.render()}&quot;
class WebDialog(Dialog):
def create_button(self) -&gt; Button:
return HTMLButton()
class iOSDialog(Dialog):
def create_button(self) -&gt; Button:
return SwiftButton()
# Usage
dialog = WebDialog()
print(dialog.render())
# &quot;Dialog with &lt;button&gt;Click me&lt;/button&gt;&quot;</code></pre>
<p><strong>When to Use</strong>: When class can&#x27;t anticipate type of objects to create</p>
<hr>
<h3>Pattern 2: Builder</h3>
<p><strong>Problem</strong>: Construct complex objects step-by-step</p>
<pre><code class="lang-typescript">class Car {
constructor(
public engine: string,
public seats: number,
public gps: boolean,
public tripComputer: boolean
) {}
}
class CarBuilder {
private engine: string = &quot;V4&quot;;
private seats: number = 2;
private gps: boolean = false;
private tripComputer: boolean = false;
setEngine(engine: string): this {
this.engine = engine;
return this;
}
setSeats(seats: number): this {
this.seats = seats;
return this;
}
setGPS(gps: boolean): this {
this.gps = gps;
return this;
}
setTripComputer(tripComputer: boolean): this {
this.tripComputer = tripComputer;
return this;
}
build(): Car {
return new Car(this.engine, this.seats, this.gps, this.tripComputer);
}
}
// Usage
const car = new CarBuilder()
.setEngine(&quot;V8&quot;)
.setSeats(4)
.setGPS(true)
.build();</code></pre>
<p><strong>When to Use</strong>: Many constructor parameters, optional configurations</p>
<hr>
<h3>Pattern 3: Singleton</h3>
<p><strong>Problem</strong>: Ensure only one instance exists</p>
<pre><code class="lang-python">class Database:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
cls._instance._initialize()
return cls._instance
def _initialize(self):
self.connection = &quot;Connected to DB&quot;
def query(self, sql: str):
return f&quot;Executing: {sql}&quot;
# Usage
db1 = Database()
db2 = Database()
assert db1 is db2 # Same instance!</code></pre>
<p><strong>When to Use</strong>: Database connections, loggers, configuration <strong>Warning</strong>: Often considered anti-pattern (use dependency injection instead)</p>
<hr>
<h2>Structural Patterns</h2>
<h3>Pattern 4: Adapter</h3>
<p><strong>Problem</strong>: Make incompatible interfaces work together</p>
<pre><code class="lang-go">// Target interface (what client expects)
type MediaPlayer interface {
Play(audioType string, fileName string)
}
// Adaptee (existing incompatible class)
type VLCPlayer struct{}
func (v *VLCPlayer) PlayVLC(fileName string) {
fmt.Printf(&quot;Playing VLC file: %s\n&quot;, fileName)
}
// Adapter
type MediaAdapter struct {
vlcPlayer *VLCPlayer
}
func (a *MediaAdapter) Play(audioType string, fileName string) {
if audioType == &quot;vlc&quot; {
a.vlcPlayer.PlayVLC(fileName)
}
}
// Client
type AudioPlayer struct {
adapter *MediaAdapter
}
func (a *AudioPlayer) Play(audioType string, fileName string) {
if audioType == &quot;mp3&quot; {
fmt.Printf(&quot;Playing MP3 file: %s\n&quot;, fileName)
} else if audioType == &quot;vlc&quot; {
a.adapter.Play(audioType, fileName)
}
}</code></pre>
<p><strong>When to Use</strong>: Integrate third-party libraries, legacy code</p>
<hr>
<h3>Pattern 5: Decorator</h3>
<p><strong>Problem</strong>: Add behavior to objects dynamically</p>
<pre><code class="lang-python"># Component
class Coffee:
def cost(self) -&gt; float:
return 2.0
def description(self) -&gt; str:
return &quot;Coffee&quot;
# Decorators
class MilkDecorator:
def __init__(self, coffee: Coffee):
self._coffee = coffee
def cost(self) -&gt; float:
return self._coffee.cost() + 0.5
def description(self) -&gt; str:
return self._coffee.description() + &quot;, Milk&quot;
class SugarDecorator:
def __init__(self, coffee: Coffee):
self._coffee = coffee
def cost(self) -&gt; float:
return self._coffee.cost() + 0.2
def description(self) -&gt; str:
return self._coffee.description() + &quot;, Sugar&quot;
# Usage
coffee = Coffee()
coffee = MilkDecorator(coffee)
coffee = SugarDecorator(coffee)
print(coffee.description()) # &quot;Coffee, Milk, Sugar&quot;
print(coffee.cost()) # 2.7</code></pre>
<p><strong>When to Use</strong>: Add responsibilities without subclassing</p>
<hr>
<h3>Pattern 6: Facade</h3>
<p><strong>Problem</strong>: Simplify complex subsystem interface</p>
<pre><code class="lang-typescript">// Complex subsystem
class CPU {
freeze() { console.log(&quot;CPU: Freeze&quot;); }
jump(position: number) { console.log(`CPU: Jump to ${position}`); }
execute() { console.log(&quot;CPU: Execute&quot;); }
}
class Memory {
load(position: number, data: string) {
console.log(`Memory: Load ${data} at ${position}`);
}
}
class HardDrive {
read(sector: number, size: number): string {
console.log(`HardDrive: Read sector ${sector}`);
return &quot;boot data&quot;;
}
}
// Facade: Simple interface
class ComputerFacade {
private cpu = new CPU();
private memory = new Memory();
private hardDrive = new HardDrive();
start() {
this.cpu.freeze();
this.memory.load(0, this.hardDrive.read(0, 1024));
this.cpu.jump(0);
this.cpu.execute();
}
}
// Usage: Simple!
const computer = new ComputerFacade();
computer.start();</code></pre>
<p><strong>When to Use</strong>: Simplify complex APIs, provide unified interface</p>
<hr>
<h2>Behavioral Patterns</h2>
<h3>Pattern 7: Strategy</h3>
<p><strong>Problem</strong>: Select algorithm at runtime</p>
<pre><code class="lang-python">from abc import ABC, abstractmethod
# Strategy interface
class PaymentStrategy(ABC):
@abstractmethod
def pay(self, amount: float) -&gt; None:
pass
# Concrete strategies
class CreditCardPayment(PaymentStrategy):
def __init__(self, card_number: str):
self.card_number = card_number
def pay(self, amount: float) -&gt; None:
print(f&quot;Paid ${amount} with credit card {self.card_number}&quot;)
class PayPalPayment(PaymentStrategy):
def __init__(self, email: str):
self.email = email
def pay(self, amount: float) -&gt; None:
print(f&quot;Paid ${amount} via PayPal ({self.email})&quot;)
class CryptoPayment(PaymentStrategy):
def __init__(self, wallet: str):
self.wallet = wallet
def pay(self, amount: float) -&gt; None:
print(f&quot;Paid ${amount} via crypto wallet {self.wallet}&quot;)
# Context
class ShoppingCart:
def __init__(self, payment_strategy: PaymentStrategy):
self.payment_strategy = payment_strategy
self.items = []
def add_item(self, item: str, price: float):
self.items.append((item, price))
def checkout(self):
total = sum(price for _, price in self.items)
self.payment_strategy.pay(total)
# Usage
cart = ShoppingCart(CreditCardPayment(&quot;1234-5678-9012-3456&quot;))
cart.add_item(&quot;Book&quot;, 29.99)
cart.add_item(&quot;Pen&quot;, 5.99)
cart.checkout()
# &quot;Paid $35.98 with credit card 1234-5678-9012-3456&quot;</code></pre>
<p><strong>When to Use</strong>: Multiple algorithms, switch behavior at runtime</p>
<hr>
<h3>Pattern 8: Observer</h3>
<p><strong>Problem</strong>: Notify multiple objects of state changes</p>
<pre><code class="lang-typescript">interface Observer {
update(temperature: number): void;
}
class WeatherStation {
private observers: Observer[] = [];
private temperature: number = 0;
attach(observer: Observer): void {
this.observers.push(observer);
}
detach(observer: Observer): void {
this.observers = this.observers.filter(o =&gt; o !== observer);
}
setTemperature(temp: number): void {
this.temperature = temp;
this.notify();
}
private notify(): void {
for (const observer of this.observers) {
observer.update(this.temperature);
}
}
}
class PhoneDisplay implements Observer {
update(temperature: number): void {
console.log(`Phone: Temperature is ${temperature}°F`);
}
}
class WebDisplay implements Observer {
update(temperature: number): void {
console.log(`Web: Temperature is ${temperature}°F`);
}
}
// Usage
const station = new WeatherStation();
const phone = new PhoneDisplay();
const web = new WebDisplay();
station.attach(phone);
station.attach(web);
station.setTemperature(75);
// Phone: Temperature is 75°F
// Web: Temperature is 75°F</code></pre>
<p><strong>When to Use</strong>: Publish-subscribe, event handling, reactive systems</p>
<hr>
<h3>Pattern 9: Command</h3>
<p><strong>Problem</strong>: Encapsulate requests as objects</p>
<pre><code class="lang-go">// Command interface
type Command interface {
Execute()
Undo()
}
// Receiver
type Light struct {
isOn bool
}
func (l *Light) TurnOn() {
l.isOn = true
fmt.Println(&quot;Light is ON&quot;)
}
func (l *Light) TurnOff() {
l.isOn = false
fmt.Println(&quot;Light is OFF&quot;)
}
// Concrete commands
type LightOnCommand struct {
light *Light
}
func (c *LightOnCommand) Execute() {
c.light.TurnOn()
}
func (c *LightOnCommand) Undo() {
c.light.TurnOff()
}
// Invoker
type RemoteControl struct {
history []Command
}
func (r *RemoteControl) Submit(cmd Command) {
cmd.Execute()
r.history = append(r.history, cmd)
}
func (r *RemoteControl) Undo() {
if len(r.history) &gt; 0 {
last := r.history[len(r.history)-1]
last.Undo()
r.history = r.history[:len(r.history)-1]
}
}
// Usage
light := &amp;Light{}
onCmd := &amp;LightOnCommand{light: light}
remote := &amp;RemoteControl{}
remote.Submit(onCmd) // Light is ON
remote.Undo() // Light is OFF</code></pre>
<p><strong>When to Use</strong>: Undo/redo, queuing operations, transactions</p>
<hr>
<h3>Pattern 10: Template Method</h3>
<p><strong>Problem</strong>: Define algorithm skeleton, defer steps to subclasses</p>
<pre><code class="lang-python">from abc import ABC, abstractmethod
class DataMiner(ABC):
def mine(self, path: str) -&gt; None:
&quot;&quot;&quot;Template method&quot;&quot;&quot;
file = self.open_file(path)
data = self.extract_data(file)
parsed = self.parse_data(data)
analysis = self.analyze_data(parsed)
self.send_report(analysis)
self.close_file(file)
def open_file(self, path: str) -&gt; str:
return f&quot;Opened {path}&quot;
@abstractmethod
def extract_data(self, file: str) -&gt; str:
pass
@abstractmethod
def parse_data(self, data: str) -&gt; dict:
pass
def analyze_data(self, data: dict) -&gt; str:
return &quot;Analysis complete&quot;
def send_report(self, analysis: str) -&gt; None:
print(f&quot;Report: {analysis}&quot;)
def close_file(self, file: str) -&gt; None:
print(f&quot;Closed {file}&quot;)
class PDFDataMiner(DataMiner):
def extract_data(self, file: str) -&gt; str:
return &quot;PDF data extracted&quot;
def parse_data(self, data: str) -&gt; dict:
return {&quot;type&quot;: &quot;PDF&quot;, &quot;data&quot;: data}
class CSVDataMiner(DataMiner):
def extract_data(self, file: str) -&gt; str:
return &quot;CSV data extracted&quot;
def parse_data(self, data: str) -&gt; dict:
return {&quot;type&quot;: &quot;CSV&quot;, &quot;data&quot;: data}
# Usage
miner = PDFDataMiner()
miner.mine(&quot;report.pdf&quot;)</code></pre>
<p><strong>When to Use</strong>: Shared algorithm with varying steps</p>
<hr>
<h2>Advanced Patterns</h2>
<h3>Pattern 11: Chain of Responsibility</h3>
<pre><code class="lang-typescript">abstract class Handler {
private next: Handler | null = null;
setNext(handler: Handler): Handler {
this.next = handler;
return handler;
}
handle(request: string): string | null {
if (this.next) {
return this.next.handle(request);
}
return null;
}
}
class AuthHandler extends Handler {
handle(request: string): string | null {
if (request.includes(&quot;authenticated&quot;)) {
console.log(&quot;Auth: Passed&quot;);
return super.handle(request);
}
return &quot;Auth failed&quot;;
}
}
class ValidationHandler extends Handler {
handle(request: string): string | null {
if (request.includes(&quot;valid&quot;)) {
console.log(&quot;Validation: Passed&quot;);
return super.handle(request);
}
return &quot;Validation failed&quot;;
}
}
// Usage
const auth = new AuthHandler();
const validation = new ValidationHandler();
auth.setNext(validation);
console.log(auth.handle(&quot;authenticated valid request&quot;));
// Auth: Passed
// Validation: Passed</code></pre>
<hr>
<h2>Anti-Patterns</h2>
<h3>Common Pattern Misuses</h3>
<pre><code>❌ Pattern for Pattern&#x27;s Sake
→ Don&#x27;t force patterns - use when beneficial
✅ Identify problem first, then apply pattern
❌ Singleton Everywhere
→ Creates hidden dependencies, hard to test
✅ Use dependency injection instead
❌ Over-Engineering with Patterns
→ Simple problem doesn&#x27;t need complex pattern
✅ Start simple, refactor to pattern if needed
❌ Ignoring Context
→ Pattern appropriate in one language/context, not another
✅ Consider language idioms and ecosystem
❌ Mixing Patterns Poorly
→ Too many patterns create complexity
✅ Use minimal patterns to solve problem</code></pre>
<hr>
<h2>Pattern Selection Guide</h2>
<p>| Problem | Pattern | |---------|---------| | Too many constructor params | Builder | | Need single instance | Singleton (or DI) | | Incompatible interfaces | Adapter | | Add behavior dynamically | Decorator | | Complex subsystem | Facade | | Select algorithm at runtime | Strategy | | Notify many objects | Observer | | Undo/redo operations | Command | | Shared algorithm, varying steps | Template Method | | Chain of handlers | Chain of Responsibility |</p>
<hr>
<h2>Best Practices</h2>
<h3>Using Patterns Effectively</h3>
<p><strong>Do&#x27;s</strong>:</p>
<ul><li>Understand the problem before choosing pattern</li><li>Use patterns to communicate intent</li><li>Refactor to patterns incrementally</li><li>Combine patterns when appropriate</li><li>Document why pattern was chosen</li></ul>
<p><strong>Don&#x27;ts</strong>:</p>
<ul><li>Don&#x27;t memorize patterns without understanding</li><li>Don&#x27;t apply patterns prematurely</li><li>Don&#x27;t use patterns to show off knowledge</li><li>Don&#x27;t ignore language-specific idioms</li><li>Don&#x27;t overcomplicate simple problems</li></ul>
<hr>
<h2>Related Skills</h2>
<ul><li><strong>engineering-code-quality</strong>: Patterns improve quality</li><li><strong>engineering-refactoring-patterns</strong>: Refactoring to patterns</li><li><strong>engineering-domain-driven-design</strong>: DDD uses patterns</li><li><strong>engineering-test-driven-development</strong>: TDD with patterns</li><li><strong>engineering-functional-programming</strong>: FP alternatives to patterns</li></ul>
<hr>
<h2>References</h2>
<ul><li><a href="https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612">Design Patterns: Elements of Reusable Object-Oriented Software (GoF)</a></li><li><a href="https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124">Head First Design Patterns</a></li><li><a href="https://www.amazon.com/Refactoring-Patterns-Joshua-Kerievsky/dp/0321213351">Refactoring to Patterns by Joshua Kerievsky</a></li><li><a href="https://refactoring.guru/design-patterns">Refactoring.Guru - Design Patterns</a></li></ul>
<footer>
<div class="fmap">
<div><b>Build</b>
<a href="https://hanzo.app">hanzo.app</a> app builder
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
<div><b>Run</b>
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
<div><b>Account</b>
<a href="https://hanzo.id">hanzo.id</a> sign in
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
<div><b>Company</b>
<a href="https://hanzo.ai">hanzo.ai</a> canonical
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
</div>
<div class="fend"><a href="/engineering-design-patterns.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
</footer>
</div></body></html>