mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
Every page now loads /webmcp.js, scripts/webmcp.ts with its types stripped (npm run webmcp). Where the browser has document.modelContext it registers two read-only tools: search_skills over the published skills index, and get_skill, which returns a skill's markdown checked against the index digest. The markdown alternate link moves from build.py to site.py, so CI holds every page to it. The API catalog gains the site itself (llms.txt and the skills index) and hanzo.ai/agents; the live discovery check now fetches every catalog link. tests/site.mjs drives the tools through a recording modelContext, and checks a browser without one loads clean.
778 lines
30 KiB
HTML
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="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/engineering-design-patterns">
|
|
<link rel="alternate" type="text/markdown" href="/engineering-design-patterns.md">
|
|
<script type="module" src="/webmcp.js"></script>
|
|
</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) -> str:
|
|
pass
|
|
|
|
class HTMLButton(Button):
|
|
def render(self) -> str:
|
|
return "<button>Click me</button>"
|
|
|
|
class SwiftButton(Button):
|
|
def render(self) -> str:
|
|
return "UIButton(title: 'Click me')"
|
|
|
|
# Creator
|
|
class Dialog(ABC):
|
|
@abstractmethod
|
|
def create_button(self) -> Button:
|
|
pass
|
|
|
|
def render(self) -> str:
|
|
button = self.create_button()
|
|
return f"Dialog with {button.render()}"
|
|
|
|
class WebDialog(Dialog):
|
|
def create_button(self) -> Button:
|
|
return HTMLButton()
|
|
|
|
class iOSDialog(Dialog):
|
|
def create_button(self) -> Button:
|
|
return SwiftButton()
|
|
|
|
# Usage
|
|
dialog = WebDialog()
|
|
print(dialog.render())
|
|
# "Dialog with <button>Click me</button>"</code></pre>
|
|
<p><strong>When to Use</strong>: When class can'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 = "V4";
|
|
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("V8")
|
|
.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 = "Connected to DB"
|
|
|
|
def query(self, sql: str):
|
|
return f"Executing: {sql}"
|
|
|
|
# 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("Playing VLC file: %s\n", fileName)
|
|
}
|
|
|
|
// Adapter
|
|
type MediaAdapter struct {
|
|
vlcPlayer *VLCPlayer
|
|
}
|
|
|
|
func (a *MediaAdapter) Play(audioType string, fileName string) {
|
|
if audioType == "vlc" {
|
|
a.vlcPlayer.PlayVLC(fileName)
|
|
}
|
|
}
|
|
|
|
// Client
|
|
type AudioPlayer struct {
|
|
adapter *MediaAdapter
|
|
}
|
|
|
|
func (a *AudioPlayer) Play(audioType string, fileName string) {
|
|
if audioType == "mp3" {
|
|
fmt.Printf("Playing MP3 file: %s\n", fileName)
|
|
} else if audioType == "vlc" {
|
|
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) -> float:
|
|
return 2.0
|
|
|
|
def description(self) -> str:
|
|
return "Coffee"
|
|
|
|
# Decorators
|
|
class MilkDecorator:
|
|
def __init__(self, coffee: Coffee):
|
|
self._coffee = coffee
|
|
|
|
def cost(self) -> float:
|
|
return self._coffee.cost() + 0.5
|
|
|
|
def description(self) -> str:
|
|
return self._coffee.description() + ", Milk"
|
|
|
|
class SugarDecorator:
|
|
def __init__(self, coffee: Coffee):
|
|
self._coffee = coffee
|
|
|
|
def cost(self) -> float:
|
|
return self._coffee.cost() + 0.2
|
|
|
|
def description(self) -> str:
|
|
return self._coffee.description() + ", Sugar"
|
|
|
|
# Usage
|
|
coffee = Coffee()
|
|
coffee = MilkDecorator(coffee)
|
|
coffee = SugarDecorator(coffee)
|
|
|
|
print(coffee.description()) # "Coffee, Milk, Sugar"
|
|
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("CPU: Freeze"); }
|
|
jump(position: number) { console.log(`CPU: Jump to ${position}`); }
|
|
execute() { console.log("CPU: Execute"); }
|
|
}
|
|
|
|
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 "boot data";
|
|
}
|
|
}
|
|
|
|
// 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) -> None:
|
|
pass
|
|
|
|
# Concrete strategies
|
|
class CreditCardPayment(PaymentStrategy):
|
|
def __init__(self, card_number: str):
|
|
self.card_number = card_number
|
|
|
|
def pay(self, amount: float) -> None:
|
|
print(f"Paid ${amount} with credit card {self.card_number}")
|
|
|
|
class PayPalPayment(PaymentStrategy):
|
|
def __init__(self, email: str):
|
|
self.email = email
|
|
|
|
def pay(self, amount: float) -> None:
|
|
print(f"Paid ${amount} via PayPal ({self.email})")
|
|
|
|
class CryptoPayment(PaymentStrategy):
|
|
def __init__(self, wallet: str):
|
|
self.wallet = wallet
|
|
|
|
def pay(self, amount: float) -> None:
|
|
print(f"Paid ${amount} via crypto wallet {self.wallet}")
|
|
|
|
# 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("1234-5678-9012-3456"))
|
|
cart.add_item("Book", 29.99)
|
|
cart.add_item("Pen", 5.99)
|
|
cart.checkout()
|
|
# "Paid $35.98 with credit card 1234-5678-9012-3456"</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 => 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("Light is ON")
|
|
}
|
|
|
|
func (l *Light) TurnOff() {
|
|
l.isOn = false
|
|
fmt.Println("Light is OFF")
|
|
}
|
|
|
|
// 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) > 0 {
|
|
last := r.history[len(r.history)-1]
|
|
last.Undo()
|
|
r.history = r.history[:len(r.history)-1]
|
|
}
|
|
}
|
|
|
|
// Usage
|
|
light := &Light{}
|
|
onCmd := &LightOnCommand{light: light}
|
|
|
|
remote := &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) -> None:
|
|
"""Template method"""
|
|
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) -> str:
|
|
return f"Opened {path}"
|
|
|
|
@abstractmethod
|
|
def extract_data(self, file: str) -> str:
|
|
pass
|
|
|
|
@abstractmethod
|
|
def parse_data(self, data: str) -> dict:
|
|
pass
|
|
|
|
def analyze_data(self, data: dict) -> str:
|
|
return "Analysis complete"
|
|
|
|
def send_report(self, analysis: str) -> None:
|
|
print(f"Report: {analysis}")
|
|
|
|
def close_file(self, file: str) -> None:
|
|
print(f"Closed {file}")
|
|
|
|
class PDFDataMiner(DataMiner):
|
|
def extract_data(self, file: str) -> str:
|
|
return "PDF data extracted"
|
|
|
|
def parse_data(self, data: str) -> dict:
|
|
return {"type": "PDF", "data": data}
|
|
|
|
class CSVDataMiner(DataMiner):
|
|
def extract_data(self, file: str) -> str:
|
|
return "CSV data extracted"
|
|
|
|
def parse_data(self, data: str) -> dict:
|
|
return {"type": "CSV", "data": data}
|
|
|
|
# Usage
|
|
miner = PDFDataMiner()
|
|
miner.mine("report.pdf")</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("authenticated")) {
|
|
console.log("Auth: Passed");
|
|
return super.handle(request);
|
|
}
|
|
return "Auth failed";
|
|
}
|
|
}
|
|
|
|
class ValidationHandler extends Handler {
|
|
handle(request: string): string | null {
|
|
if (request.includes("valid")) {
|
|
console.log("Validation: Passed");
|
|
return super.handle(request);
|
|
}
|
|
return "Validation failed";
|
|
}
|
|
}
|
|
|
|
// Usage
|
|
const auth = new AuthHandler();
|
|
const validation = new ValidationHandler();
|
|
auth.setNext(validation);
|
|
|
|
console.log(auth.handle("authenticated valid request"));
|
|
// Auth: Passed
|
|
// Validation: Passed</code></pre>
|
|
<hr>
|
|
<h2>Anti-Patterns</h2>
|
|
<h3>Common Pattern Misuses</h3>
|
|
<pre><code>❌ Pattern for Pattern's Sake
|
|
→ Don'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'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'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'ts</strong>:</p>
|
|
<ul><li>Don't memorize patterns without understanding</li><li>Don't apply patterns prematurely</li><li>Don't use patterns to show off knowledge</li><li>Don't ignore language-specific idioms</li><li>Don'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> |