Component Design and Modularity

Author: Htunn Thu Thu

Date: January 4, 2026

Tags: #SoftwareDesign #TypeScript #Architecture #Modularity

Introduction

Good component design is about creating pieces that work together seamlessly while remaining independent. Building my AI-powered chatbot for multi-tenant POS microservices taught me the importance of well-designed, modular components.

This guide covers:

• Module Organization - Structuring code into cohesive units

• Coupling and Cohesion - Managing dependencies

• Interface Design - Creating clean APIs

• Dependency Management - Controlling relationships

• Reusability - Building components for multiple contexts

---

Module Organization

The Problem I Had

Early in my MCP server project, I had everything in one file:

// ❌ BAD: Everything in one file

// server.ts (1500+ lines)

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import * as net from 'net';
import * as tls from 'tls';

// Server setup
const server = new Server(/* ... */);

// Tool implementations
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'check_port',
        description: 'Check if a port is open',
        // ...
      }
    ]
  };
});

// Port scanner logic
async function checkPort(host: string, port: number): Promise<boolean> {
  return new Promise((resolve) => {
    const socket = new net.Socket();
    socket.setTimeout(2000);
    socket.on('connect', () => {
      socket.destroy();
      resolve(true);
    });
    // ... more logic
  });
}

// SSL checker logic
async function checkSSL(host: string): Promise<SSLInfo> {
  return new Promise((resolve, reject) => {
    const socket = tls.connect(443, host, () => {
      const cert = socket.getPeerCertificate();
      // ... more logic
    });
  });
}

// Formatting logic
function formatResults(results: ScanResult[]): string {
  // ... formatting logic
}

// Main execution
async function main() {
  // ... startup logic
}

main();

// Problem: Hard to test, maintain, or reuse anything!

My Solution: Modular Architecture

I split it into focused modules:

// ✅ GOOD: Modular structure

// src/
//   core/
//     scanner/
//       PortScanner.ts
//       SSLChecker.ts
//       types.ts
//     formatters/
//       ResultFormatter.ts
//     validation/
//       InputValidator.ts
//   mcp/
//     server.ts
//     handlers/
//       PortScanHandler.ts
//       SSLCheckHandler.ts
//   utils/
//     logger.ts
//     config.ts
//   index.ts

// src/core/scanner/types.ts
export interface ScanResult {
  port: number;
  open: boolean;
  service?: string;
  banner?: string;
}

export interface ScanOptions {
  timeout?: number;
  retries?: number;
  concurrent?: number;
}

export interface SSLInfo {
  valid: boolean;
  issuer: string;
  subject: string;
  validFrom: Date;
  validTo: Date;
  daysRemaining: number;
}

// src/core/scanner/PortScanner.ts
import { ScanResult, ScanOptions } from './types';

export class PortScanner {
  constructor(private options: ScanOptions = {}) {}
  
  async scan(host: string, port: number): Promise<ScanResult> {
    const timeout = this.options.timeout ?? 2000;
    
    return new Promise((resolve) => {
      const socket = new net.Socket();
      socket.setTimeout(timeout);
      
      socket.on('connect', () => {
        socket.destroy();
        resolve({ port, open: true });
      });
      
      socket.on('timeout', () => {
        socket.destroy();
        resolve({ port, open: false });
      });
      
      socket.on('error', () => {
        resolve({ port, open: false });
      });
      
      socket.connect(port, host);
    });
  }
  
  async scanRange(host: string, ports: number[]): Promise<ScanResult[]> {
    const concurrent = this.options.concurrent ?? 10;
    const results: ScanResult[] = [];
    
    for (let i = 0; i < ports.length; i += concurrent) {
      const batch = ports.slice(i, i + concurrent);
      const batchResults = await Promise.all(
        batch.map(port => this.scan(host, port))
      );
      results.push(...batchResults);
    }
    
    return results;
  }
}

// src/core/scanner/SSLChecker.ts
import { SSLInfo } from './types';

export class SSLChecker {
  async check(host: string, port: number = 443): Promise<SSLInfo> {
    return new Promise((resolve, reject) => {
      const socket = tls.connect(port, host, { rejectUnauthorized: false }, () => {
        const cert = socket.getPeerCertificate();
        
        if (!cert || Object.keys(cert).length === 0) {
          socket.destroy();
          reject(new Error('No certificate found'));
          return;
        }
        
        const now = new Date();
        const validTo = new Date(cert.valid_to);
        const daysRemaining = Math.floor(
          (validTo.getTime() - now.getTime()) / (1000 * 60 * 60 * 24)
        );
        
        socket.destroy();
        resolve({
          valid: now <= validTo,
          issuer: cert.issuer.CN,
          subject: cert.subject.CN,
          validFrom: new Date(cert.valid_from),
          validTo,
          daysRemaining
        });
      });
      
      socket.on('error', reject);
      socket.setTimeout(5000);
      socket.on('timeout', () => {
        socket.destroy();
        reject(new Error('SSL check timeout'));
      });
    });
  }
}

// src/core/formatters/ResultFormatter.ts
import { ScanResult, SSLInfo } from '../scanner/types';

export class ResultFormatter {
  formatScanResults(results: ScanResult[]): string {
    const openPorts = results.filter(r => r.open);
    
    if (openPorts.length === 0) {
      return 'No open ports found';
    }
    
    return openPorts.map(r => 
      `Port ${r.port}: OPEN${r.service ? ` (${r.service})` : ''}`
    ).join('\n');
  }
  
  formatSSLInfo(info: SSLInfo): string {
    const status = info.valid ? '✓ Valid' : '✗ Invalid';
    const warning = info.daysRemaining < 30 ? ' ⚠️ Expires soon!' : '';
    
    return `
SSL Certificate ${status}${warning}
Subject: ${info.subject}
Issuer: ${info.issuer}
Valid From: ${info.validFrom.toISOString()}
Valid Until: ${info.validTo.toISOString()}
Days Remaining: ${info.daysRemaining}
    `.trim();
  }
}

// src/mcp/handlers/PortScanHandler.ts
import { PortScanner } from '../../core/scanner/PortScanner';
import { ResultFormatter } from '../../core/formatters/ResultFormatter';

export class PortScanHandler {
  constructor(
    private scanner: PortScanner,
    private formatter: ResultFormatter
  ) {}
  
  async handle(args: { host: string; ports: number[] }): Promise<string> {
    const results = await this.scanner.scanRange(args.host, args.ports);
    return this.formatter.formatScanResults(results);
  }
}

// src/mcp/server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { PortScanner } from '../core/scanner/PortScanner';
import { SSLChecker } from '../core/scanner/SSLChecker';
import { ResultFormatter } from '../core/formatters/ResultFormatter';
import { PortScanHandler } from './handlers/PortScanHandler';

export function createMCPServer(): Server {
  const server = new Server(/* config */);
  
  // Initialize dependencies
  const scanner = new PortScanner({ timeout: 2000, concurrent: 10 });
  const sslChecker = new SSLChecker();
  const formatter = new ResultFormatter();
  
  // Create handlers
  const portScanHandler = new PortScanHandler(scanner, formatter);
  
  // Register tools
  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: [
        {
          name: 'check_port',
          description: 'Check if specific ports are open on a host',
          inputSchema: { /* ... */ }
        }
      ]
    };
  });
  
  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    if (request.params.name === 'check_port') {
      return {
        content: [{
          type: 'text',
          text: await portScanHandler.handle(request.params.arguments)
        }]
      };
    }
  });
  
  return server;
}

// Now each module can be tested independently!

---

Coupling and Cohesion

Understanding Cohesion

High Cohesion = Module elements are strongly related and serve a single purpose.

// ✅ GOOD: High cohesion - all methods relate to sensor data validation

export class SensorDataValidator {
  validateTemperature(temp: number): boolean {
    return temp >= -50 && temp <= 100;
  }
  
  validateHumidity(humidity: number): boolean {
    return humidity >= 0 && humidity <= 100;
  }
  
  validateSensorData(data: SensorData): ValidationResult {
    const errors: string[] = [];
    
    if (!this.validateTemperature(data.temperature)) {
      errors.push('Temperature out of range');
    }
    
    if (!this.validateHumidity(data.humidity)) {
      errors.push('Humidity out of range');
    }
    
    return {
      valid: errors.length === 0,
      errors
    };
  }
}

// ❌ BAD: Low cohesion - unrelated responsibilities mixed

export class SensorManager {
  validateTemperature(temp: number): boolean { /* ... */ }
  
  sendEmail(to: string, subject: string): void { /* ... */ }
  
  calculateAverage(values: number[]): number { /* ... */ }
  
  formatDate(date: Date): string { /* ... */ }
  
  // These don't belong together!
}

Understanding Coupling

Low Coupling = Modules have minimal dependencies on each other.

// ❌ BAD: High coupling - direct dependency on concrete class

class ReportGenerator {
  private database: MySQLDatabase; // Tightly coupled to MySQL
  
  constructor() {
    this.database = new MySQLDatabase('localhost', 'mydb');
  }
  
  async generateReport(): Promise<Report> {
    const data = await this.database.query('SELECT * FROM sensors');
    return this.formatReport(data);
  }
  
  private formatReport(data: any[]): Report {
    // ...
  }
}

// ✅ GOOD: Low coupling - depends on interface

interface DataSource {
  query(sql: string): Promise<any[]>;
}

class ReportGenerator {
  constructor(private dataSource: DataSource) {}
  
  async generateReport(): Promise<Report> {
    const data = await this.dataSource.query('SELECT * FROM sensors');
    return this.formatReport(data);
  }
  
  private formatReport(data: any[]): Report {
    // ...
  }
}

// Can now use any data source
const mysqlSource = new MySQLDataSource('localhost', 'mydb');
const postgresSource = new PostgresDataSource('localhost', 'mydb');
const mockSource = new MockDataSource();

const generator1 = new ReportGenerator(mysqlSource);
const generator2 = new ReportGenerator(postgresSource);
const generator3 = new ReportGenerator(mockSource); // Easy testing!

Real Example from My IoT Platform

Here's how I achieved low coupling in my IoT monitoring platform:

// ✅ REAL: Low coupling through dependency injection

// Define interfaces
interface SensorReader {
  read(sensorId: string): Promise<SensorData>;
}

interface DataStore {
  save(sensorId: string, data: SensorData): Promise<void>;
  query(sensorId: string, from: Date, to: Date): Promise<SensorData[]>;
}

interface AlertService {
  sendAlert(alert: Alert): Promise<void>;
}

interface LLMService {
  analyze(prompt: string): Promise<string>;
}

// Core monitoring service depends only on interfaces
class MonitoringService {
  constructor(
    private reader: SensorReader,
    private store: DataStore,
    private alerts: AlertService,
    private llm: LLMService
  ) {}
  
  async monitor(sensorId: string): Promise<void> {
    const data = await this.reader.read(sensorId);
    await this.store.save(sensorId, data);
    
    if (this.isAnomalous(data)) {
      const analysis = await this.llm.analyze(
        `Analyze anomalous sensor data: ${JSON.stringify(data)}`
      );
      
      await this.alerts.sendAlert({
        sensorId,
        message: `Anomaly detected: ${analysis}`,
        severity: 'high'
      });
    }
  }
  
  private isAnomalous(data: SensorData): boolean {
    return data.temperature > 35 || data.humidity > 80;
  }
}

// Concrete implementations
class MQTTSensorReader implements SensorReader {
  async read(sensorId: string): Promise<SensorData> {
    // MQTT-specific implementation
    return { temperature: 0, humidity: 0 };
  }
}

class MongoDataStore implements DataStore {
  constructor(private db: Db) {}
  
  async save(sensorId: string, data: SensorData): Promise<void> {
    await this.db.collection('sensor_data').insertOne({
      sensorId,
      data,
      timestamp: new Date()
    });
  }
  
  async query(sensorId: string, from: Date, to: Date): Promise<SensorData[]> {
    const docs = await this.db.collection('sensor_data')
      .find({
        sensorId,
        timestamp: { $gte: from, $lte: to }
      })
      .toArray();
    
    return docs.map(doc => doc.data);
  }
}

class EmailAlertService implements AlertService {
  async sendAlert(alert: Alert): Promise<void> {
    // Email implementation
    console.log('Sending email alert:', alert);
  }
}

class AzureOpenAIService implements LLMService {
  async analyze(prompt: string): Promise<string> {
    // Azure OpenAI implementation
    return 'Analysis result';
  }
}

// Easy to swap implementations
const service = new MonitoringService(
  new MQTTSensorReader(),
  new MongoDataStore(db),
  new EmailAlertService(),
  new AzureOpenAIService()
);

// Or use different implementations for testing
const testService = new MonitoringService(
  new MockSensorReader(),
  new InMemoryDataStore(),
  new MockAlertService(),
  new MockLLMService()
);

---

Interface Design

Creating Clean APIs

Good interfaces hide complexity and expose only what's needed:

// ❌ BAD: Leaky abstraction exposing internal details

class DataFetcher {
  private cache: Map<string, CacheEntry> = new Map();
  private requestQueue: Request[] = [];
  private rateLimiter: RateLimiter;
  
  // Exposes too much internal state
  getCache(): Map<string, CacheEntry> {
    return this.cache;
  }
  
  getQueue(): Request[] {
    return this.requestQueue;
  }
  
  // Requires users to understand internal mechanisms
  async fetch(url: string, useCache: boolean, priority: number): Promise<Data> {
    if (useCache && this.cache.has(url)) {
      return this.cache.get(url)!.data;
    }
    
    const request = { url, priority };
    this.requestQueue.push(request);
    this.requestQueue.sort((a, b) => b.priority - a.priority);
    
    // ...
  }
}

// ✅ GOOD: Clean interface hiding complexity

class DataFetcher {
  private cache = new Map<string, CacheEntry>();
  private requestQueue: Request[] = [];
  private rateLimiter: RateLimiter;
  
  // Simple, focused API
  async fetch(url: string, options: FetchOptions = {}): Promise<Data> {
    return this.executeFetch(url, options);
  }
  
  async prefetch(urls: string[]): Promise<void> {
    await Promise.all(urls.map(url => this.fetch(url)));
  }
  
  clearCache(): void {
    this.cache.clear();
  }
  
  // Internal implementation hidden
  private async executeFetch(url: string, options: FetchOptions): Promise<Data> {
    if (this.shouldUseCache(url, options)) {
      return this.getFromCache(url);
    }
    
    await this.rateLimiter.wait();
    const data = await this.makeRequest(url);
    this.updateCache(url, data);
    
    return data;
  }
  
  private shouldUseCache(url: string, options: FetchOptions): boolean {
    if (options.skipCache) return false;
    
    const entry = this.cache.get(url);
    if (!entry) return false;
    
    const age = Date.now() - entry.timestamp;
    return age < (options.maxAge ?? 60000);
  }
  
  // Other private methods...
}

// Usage is simple and intuitive
const fetcher = new DataFetcher();
const data = await fetcher.fetch('https://api.example.com/data');
const freshData = await fetcher.fetch('https://api.example.com/data', { skipCache: true });

Real Example: My MCP Server API

// ✅ REAL: Clean API design from my MCP server

export interface SecurityScanner {
  // Simple, intention-revealing methods
  scanPorts(host: string, ports: number[]): Promise<PortScanResult>;
  checkSSL(host: string): Promise<SSLCheckResult>;
  lookupDNS(domain: string): Promise<DNSLookupResult>;
  
  // Convenience method combining multiple scans
  comprehensiveScan(host: string): Promise<ComprehensiveScanResult>;
}

export class SimplePortChecker implements SecurityScanner {
  constructor(
    private scanner: PortScanner,
    private sslChecker: SSLChecker,
    private dnsResolver: DNSResolver
  ) {}
  
  async scanPorts(host: string, ports: number[]): Promise<PortScanResult> {
    const results = await this.scanner.scanRange(host, ports);
    
    return {
      host,
      scannedAt: new Date(),
      totalPorts: ports.length,
      openPorts: results.filter(r => r.open),
      closedPorts: results.filter(r => !r.open)
    };
  }
  
  async checkSSL(host: string): Promise<SSLCheckResult> {
    try {
      const info = await this.sslChecker.check(host);
      
      return {
        host,
        valid: info.valid,
        certificate: info,
        warnings: this.generateWarnings(info)
      };
    } catch (error) {
      return {
        host,
        valid: false,
        error: (error as Error).message
      };
    }
  }
  
  async lookupDNS(domain: string): Promise<DNSLookupResult> {
    const records = await this.dnsResolver.resolve(domain);
    
    return {
      domain,
      resolvedAt: new Date(),
      records
    };
  }
  
  async comprehensiveScan(host: string): Promise<ComprehensiveScanResult> {
    // Orchestrate multiple scans
    const [portScan, sslCheck, dnsLookup] = await Promise.all([
      this.scanPorts(host, [80, 443, 8080, 8443]),
      this.checkSSL(host),
      this.lookupDNS(host)
    ]);
    
    return {
      host,
      scannedAt: new Date(),
      portScan,
      sslCheck,
      dnsLookup,
      riskScore: this.calculateRiskScore(portScan, sslCheck)
    };
  }
  
  private generateWarnings(info: SSLInfo): string[] {
    const warnings: string[] = [];
    
    if (info.daysRemaining < 30) {
      warnings.push(`Certificate expires in ${info.daysRemaining} days`);
    }
    
    if (!info.valid) {
      warnings.push('Certificate is expired or not yet valid');
    }
    
    return warnings;
  }
  
  private calculateRiskScore(
    portScan: PortScanResult,
    sslCheck: SSLCheckResult
  ): number {
    let score = 0;
    
    // More open ports = higher risk
    score += portScan.openPorts.length * 10;
    
    // Invalid SSL = high risk
    if (!sslCheck.valid) {
      score += 50;
    }
    
    return Math.min(score, 100);
  }
}

// Usage is clean and straightforward
const checker = new SimplePortChecker(scanner, sslChecker, resolver);

// Simple scans
const portScan = await checker.scanPorts('example.com', [80, 443]);
const sslCheck = await checker.checkSSL('example.com');

// Or comprehensive scan
const fullScan = await checker.comprehensiveScan('example.com');
console.log(`Risk score: ${fullScan.riskScore}/100`);

---

Dependency Management

Dependency Injection

// ✅ REAL: Dependency injection in my chatbot project

// Define dependencies as interfaces
interface ConversationStore {
  save(conversationId: string, messages: Message[]): Promise<void>;
  load(conversationId: string): Promise<Message[]>;
}

interface LLMProvider {
  chat(messages: Message[]): Promise<string>;
}

interface TenantConfig {
  getTenantSettings(tenantId: string): Promise<TenantSettings>;
}

// Main service accepts dependencies
export class ChatbotService {
  constructor(
    private store: ConversationStore,
    private llm: LLMProvider,
    private config: TenantConfig
  ) {}
  
  async handleMessage(
    tenantId: string,
    conversationId: string,
    userMessage: string
  ): Promise<string> {
    // Load tenant-specific settings
    const settings = await this.config.getTenantSettings(tenantId);
    
    // Load conversation history
    const history = await this.store.load(conversationId);
    
    // Add user message
    history.push({ role: 'user', content: userMessage });
    
    // Get LLM response
    const response = await this.llm.chat(history);
    
    // Save updated history
    history.push({ role: 'assistant', content: response });
    await this.store.save(conversationId, history);
    
    return response;
  }
}

// Concrete implementations
class RedisConversationStore implements ConversationStore {
  constructor(private redis: RedisClient) {}
  
  async save(conversationId: string, messages: Message[]): Promise<void> {
    await this.redis.set(
      `conversation:${conversationId}`,
      JSON.stringify(messages),
      'EX',
      3600
    );
  }
  
  async load(conversationId: string): Promise<Message[]> {
    const data = await this.redis.get(`conversation:${conversationId}`);
    return data ? JSON.parse(data) : [];
  }
}

class AzureOpenAIProvider implements LLMProvider {
  async chat(messages: Message[]): Promise<string> {
    // Azure OpenAI implementation
    return 'response';
  }
}

class DatabaseTenantConfig implements TenantConfig {
  constructor(private db: Database) {}
  
  async getTenantSettings(tenantId: string): Promise<TenantSettings> {
    return await this.db.collection('tenants').findOne({ id: tenantId });
  }
}

// Easy to assemble with different implementations
const chatbot = new ChatbotService(
  new RedisConversationStore(redis),
  new AzureOpenAIProvider(),
  new DatabaseTenantConfig(db)
);

// Easy to test with mocks
const testChatbot = new ChatbotService(
  new InMemoryConversationStore(),
  new MockLLMProvider(),
  new MockTenantConfig()
);

Dependency Inversion Principle

High-level modules should not depend on low-level modules. Both should depend on abstractions.

// ✅ GOOD: Following dependency inversion

// High-level module
class ReportingService {
  constructor(
    private dataSource: DataSource,    // Abstraction
    private formatter: ReportFormatter  // Abstraction
  ) {}
  
  async generateReport(criteria: ReportCriteria): Promise<Report> {
    const data = await this.dataSource.query(criteria);
    return this.formatter.format(data);
  }
}

// Low-level modules implement abstractions
class MySQLDataSource implements DataSource {
  async query(criteria: ReportCriteria): Promise<RawData> {
    // MySQL-specific implementation
  }
}

class PDFReportFormatter implements ReportFormatter {
  format(data: RawData): Report {
    // PDF-specific formatting
  }
}

// Can easily swap implementations
const service = new ReportingService(
  new MySQLDataSource(),
  new PDFReportFormatter()
);

---

Reusability

Building Reusable Components

// ✅ REAL: Reusable rate limiter from my projects

export interface RateLimiterConfig {
  maxRequests: number;
  windowMs: number;
  strategy?: 'fixed' | 'sliding';
}

export class RateLimiter {
  private requests: number[] = [];
  
  constructor(private config: RateLimiterConfig) {}
  
  async wait(): Promise<void> {
    await this.checkAndWait();
  }
  
  canProceed(): boolean {
    this.cleanup();
    return this.requests.length < this.config.maxRequests;
  }
  
  private async checkAndWait(): Promise<void> {
    while (!this.canProceed()) {
      const oldestRequest = this.requests[0];
      const waitTime = this.config.windowMs - (Date.now() - oldestRequest);
      
      if (waitTime > 0) {
        await new Promise(resolve => setTimeout(resolve, waitTime));
      }
    }
    
    this.requests.push(Date.now());
  }
  
  private cleanup(): void {
    const cutoff = Date.now() - this.config.windowMs;
    this.requests = this.requests.filter(time => time > cutoff);
  }
  
  reset(): void {
    this.requests = [];
  }
}

// Reusable in multiple contexts:

// 1. API client rate limiting
class APIClient {
  private rateLimiter = new RateLimiter({
    maxRequests: 100,
    windowMs: 60000 // 100 requests per minute
  });
  
  async request(url: string): Promise<Response> {
    await this.rateLimiter.wait();
    return fetch(url);
  }
}

// 2. LLM request limiting
class LLMService {
  private rateLimiter = new RateLimiter({
    maxRequests: 10,
    windowMs: 60000 // 10 requests per minute
  });
  
  async generate(prompt: string): Promise<string> {
    await this.rateLimiter.wait();
    return this.callLLM(prompt);
  }
}

// 3. Database query limiting
class DatabaseClient {
  private rateLimiter = new RateLimiter({
    maxRequests: 1000,
    windowMs: 1000 // 1000 queries per second
  });
  
  async query(sql: string): Promise<any[]> {
    await this.rateLimiter.wait();
    return this.executeQuery(sql);
  }
}

---

Best Practices

1. Single Responsibility per Module

Each module should have one reason to change.

2. Explicit Dependencies

Use constructor injection to make dependencies visible.

3. Program to Interfaces

Depend on abstractions, not concrete implementations.

4. Keep Modules Focused

If a module does too much, split it.

5. Minimize Public API

Expose only what's necessary; keep internals private.

6. Document Module Boundaries

Use clear folder structure and naming conventions.

---

Conclusion

Good component design creates maintainable, testable, and reusable code:

• High Cohesion: Related functionality grouped together

• Low Coupling: Minimal dependencies between modules

• Clean Interfaces: Simple, focused APIs

• Dependency Injection: Flexible, testable components

• Reusability: Components work in multiple contexts

I apply these principles across all my TypeScript projects for better architecture.

What's Next?

• Error Handling → - Robust error strategies

• SOLID Principles → - Review design principles

• Design Patterns → - Pattern implementation

References

• My MCP Server - Modular architecture

• FreeCodeCamp - Software Design

---

Previous: ← Behavioral Patterns | Next: Error Handling →