Behavioral patterns focus on communication between objects and how responsibilities are distributed. Building my IoT monitoring platform taught me that how objects interact is just as important as how they're structured.
This guide covers four behavioral patterns I use constantly:
Observer Pattern - Objects reacting to state changes
Strategy Pattern - Swappable algorithms
Command Pattern - Encapsulating requests as objects
State Pattern - Object behavior based on internal state
Observer Pattern
Defines a one-to-many dependency so when one object changes state, all dependents are notified.
The Problem I Had
In my IoT platform, I needed multiple components to react when sensor data arrived:
My Solution: Observer Pattern
I implemented a publish-subscribe system:
Event Emitter Pattern (Node.js Style)
For my MCP server, I used Node.js EventEmitter:
Strategy Pattern
Defines a family of algorithms, encapsulates each one, and makes them interchangeable.
The Problem I Had
My Agentic LLM project needed different search strategies:
My Solution: Strategy Pattern
I extracted strategies into separate classes:
Real Example: LLM Provider Selection
Here's how I use Strategy for LLM provider selection in my agent:
Command Pattern
Encapsulates a request as an object, allowing parameterization and queuing of requests.
The Problem I Had
My MCP server needed to support undo/redo and command history:
My Solution: Command Pattern
I encapsulated operations as command objects:
Macro Commands (Composite)
For complex workflows, I create composite commands:
State Pattern
Allows an object to alter its behavior when its internal state changes.
The Problem I Had
In my IoT platform, sensor connections had complex state management:
My Solution: State Pattern
I encapsulated each state as a separate class:
Real Example: Scan State Machine
Here's my actual scan state machine from the MCP server:
Combining Behavioral Patterns
Here's how I combine multiple behavioral patterns in my IoT platform:
// ❌ BAD: Direct method calls, no history
class SecurityTool {
async scanPort(host: string, port: number): Promise<void> {
// Scan logic
console.log(`Scanning ${host}:${port}`);
}
async checkSSL(host: string): Promise<void> {
// SSL check
console.log(`Checking SSL for ${host}`);
}
// No way to track what was executed, undo, or replay
}
// ✅ GOOD: Command pattern
interface Command {
execute(): Promise<void>;
undo(): Promise<void>;
describe(): string;
}
// Concrete command for port scanning
class PortScanCommand implements Command {
private result?: ScanResult;
constructor(
private scanner: PortScanner,
private host: string,
private port: number
) {}
async execute(): Promise<void> {
console.log(`Executing: Scan ${this.host}:${this.port}`);
this.result = await this.scanner.scan(this.host, this.port);
}
async undo(): Promise<void> {
console.log(`Undoing: Removing scan result for ${this.host}:${this.port}`);
// Clear cached result
this.result = undefined;
}
describe(): string {
return `Port scan of ${this.host}:${this.port}`;
}
}
// Concrete command for SSL check
class SSLCheckCommand implements Command {
private result?: SSLInfo;
constructor(
private checker: SSLChecker,
private host: string
) {}
async execute(): Promise<void> {
console.log(`Executing: SSL check for ${this.host}`);
this.result = await this.checker.check(this.host);
}
async undo(): Promise<void> {
console.log(`Undoing: Removing SSL check for ${this.host}`);
this.result = undefined;
}
describe(): string {
return `SSL check for ${this.host}`;
}
}
// Command invoker with history
class SecurityCommandInvoker {
private history: Command[] = [];
private currentIndex: number = -1;
async execute(command: Command): Promise<void> {
// Remove any commands after current index (redo history)
this.history = this.history.slice(0, this.currentIndex + 1);
await command.execute();
this.history.push(command);
this.currentIndex++;
}
async undo(): Promise<void> {
if (this.currentIndex < 0) {
console.log('Nothing to undo');
return;
}
const command = this.history[this.currentIndex];
await command.undo();
this.currentIndex--;
}
async redo(): Promise<void> {
if (this.currentIndex >= this.history.length - 1) {
console.log('Nothing to redo');
return;
}
this.currentIndex++;
const command = this.history[this.currentIndex];
await command.execute();
}
getHistory(): string[] {
return this.history.map(cmd => cmd.describe());
}
async replay(): Promise<void> {
console.log('Replaying all commands...');
for (const command of this.history) {
await command.execute();
}
}
}
// Usage
const invoker = new SecurityCommandInvoker();
// Execute commands
await invoker.execute(new PortScanCommand(scanner, 'example.com', 443));
await invoker.execute(new SSLCheckCommand(checker, 'example.com'));
await invoker.execute(new PortScanCommand(scanner, 'example.com', 80));
// Show history
console.log(invoker.getHistory());
// ['Port scan of example.com:443', 'SSL check for example.com', 'Port scan of example.com:80']
// Undo last command
await invoker.undo();
// Redo
await invoker.redo();
// Replay entire sequence
await invoker.replay();
// ✅ ADVANCED: Macro/composite commands
class MacroCommand implements Command {
constructor(private commands: Command[]) {}
async execute(): Promise<void> {
for (const command of this.commands) {
await command.execute();
}
}
async undo(): Promise<void> {
// Undo in reverse order
for (let i = this.commands.length - 1; i >= 0; i--) {
await this.commands[i].undo();
}
}
describe(): string {
return `Macro: ${this.commands.map(c => c.describe()).join(', ')}`;
}
}
// Create a comprehensive security scan macro
const comprehensiveScan = new MacroCommand([
new PortScanCommand(scanner, 'example.com', 80),
new PortScanCommand(scanner, 'example.com', 443),
new SSLCheckCommand(checker, 'example.com'),
new DNSLookupCommand(resolver, 'example.com')
]);
// Execute entire workflow as one command
await invoker.execute(comprehensiveScan);
// Undo entire workflow
await invoker.undo();
// ❌ BAD: Conditional logic based on state flags
class SensorConnection {
private state: 'disconnected' | 'connecting' | 'connected' | 'error' = 'disconnected';
async connect(): Promise<void> {
if (this.state === 'disconnected') {
this.state = 'connecting';
// Connection logic
this.state = 'connected';
} else if (this.state === 'connecting') {
throw new Error('Already connecting');
} else if (this.state === 'connected') {
throw new Error('Already connected');
}
}
async disconnect(): Promise<void> {
if (this.state === 'connected') {
// Disconnect logic
this.state = 'disconnected';
} else if (this.state === 'disconnected') {
throw new Error('Already disconnected');
} else if (this.state === 'connecting') {
throw new Error('Cannot disconnect while connecting');
}
}
async sendData(data: SensorData): Promise<void> {
if (this.state === 'connected') {
// Send data
} else {
throw new Error('Not connected');
}
}
// State logic scattered everywhere!
}
