Design Patterns — Why Singleton Killed Our Test Suite

// Singleton Pattern — guarantees one shared instance of an expensive resource
public class DatabaseConnectionPool {

    // volatile ensures the instance is correctly visible across threads
    private static volatile DatabaseConnectionPool instance;

    private final String databaseUrl;
    private int activeConnections;

    // Private constructor prevents anyone from calling 'new DatabaseConnectionPool()'
    private DatabaseConnectionPool(String databaseUrl) {
        this.databaseUrl = databaseUrl;
        this.activeConnections = 0;
        System.out.println("Pool created — connecting to: " + databaseUrl);
    }

    // Double-checked locking: thread-safe without locking on every call
    public static DatabaseConnectionPool getInstance(String databaseUrl) {
        if (instance == null) {                          // First check (no lock)
            synchronized (DatabaseConnectionPool.class) {
                if (instance == null) {                  // Second check (with lock)
                    instance = new DatabaseConnectionPool(databaseUrl);
                }
            }
        }
        return instance;
    }

    public void borrowConnection() {
        activeConnections++;
        System.out.println("Connection borrowed. Active: " + activeConnections);
    }

    public void returnConnection() {
        if (activeConnections > 0) activeConnections--;
        System.out.println("Connection returned. Active: " + activeConnections);
    }

    // --- Builder Pattern — for objects with many optional configuration fields ---
    public static class ReportBuilder {
        // Required field
        private final String reportTitle;

        // Optional fields with sensible defaults
        private String dateRange   = "Last 30 days";
        private boolean includePdf  = false;
        private int     maxRows     = 100;

        public ReportBuilder(String reportTitle) {
            this.reportTitle = reportTitle;
        }

        // Each setter returns 'this' so calls can be chained fluently
        public ReportBuilder withDateRange(String dateRange) {
            this.dateRange = dateRange;
            return this;
        }

        public ReportBuilder withPdfExport(boolean includePdf) {
            this.includePdf = includePdf;
            return this;
        }

        public ReportBuilder withMaxRows(int maxRows) {
            this.maxRows = maxRows;
            return this;
        }

        public String build() {
            // In real code this would return a Report object
            return String.format(
                "Report[title=%s, range=%s, pdf=%b, maxRows=%d]",
                reportTitle, dateRange, includePdf, maxRows
            );
        }
    }

    public static void main(String[] args) {
        // Both calls return the exact same object — only one pool is ever created
        DatabaseConnectionPool poolA = DatabaseConnectionPool.getInstance("jdbc:postgresql://prod-db/sales");
        DatabaseConnectionPool poolB = DatabaseConnectionPool.getInstance("jdbc:postgresql://prod-db/sales");

        System.out.println("Same instance? " + (poolA == poolB));  // true

        poolA.borrowConnection();
        poolB.borrowConnection(); // poolB IS poolA, so activeConnections reaches 2
        poolA.returnConnection();

        // Builder: readable construction, no 8-parameter constructor nightmare
        String report = new ReportBuilder("Monthly Sales")
            .withDateRange("2024-01-01 to 2024-01-31")
            .withPdfExport(true)
            .withMaxRows(500)
            .build();

        System.out.println(report);
    }
}

// Facade Pattern — hides a complex multi-subsystem workflow behind a single clean method

// --- Subsystem 1: Email service (imagine this is a vendor SDK) ---
class EmailService {
    public void sendEmail(String recipient, String subject, String body) {
        System.out.println("[EMAIL] To: " + recipient + " | Subject: " + subject);
    }
}

// --- Subsystem 2: SMS gateway ---
class SmsGateway {
    public void sendSms(String phoneNumber, String message) {
        System.out.println("[SMS] To: " + phoneNumber + " | Msg: " + message);
    }
}

// --- Subsystem 3: Push notification service ---
class PushNotificationService {
    public void pushToDevice(String deviceToken, String payload) {
        System.out.println("[PUSH] Token: " + deviceToken + " | Payload: " + payload);
    }
}

// --- Adapter Pattern embedded: normalize an incompatible legacy alerter ---
interface ModernAlerter {
    void alert(String userId, String message);
}

class LegacyAlertSystem {
    // Old API — completely different signature, can't touch this code
    public void triggerAlertForEmployee(int employeeId, String msg, boolean urgent) {
        System.out.println("[LEGACY ALERT] EmpID:" + employeeId + " | " + msg + (urgent ? " (URGENT)" : ""));
    }
}

// Adapter wraps the legacy system and exposes the ModernAlerter interface
class LegacyAlertAdapter implements ModernAlerter {
    private final LegacyAlertSystem legacySystem;

    public LegacyAlertAdapter(LegacyAlertSystem legacySystem) {
        this.legacySystem = legacySystem;
    }

    @Override
    public void alert(String userId, String message) {
        // Translate modern call → legacy call (userId parsed to int, always urgent)
        int employeeId = Integer.parseInt(userId);
        legacySystem.triggerAlertForEmployee(employeeId, message, true);
    }
}

// --- The Facade: one method hides all subsystem coordination ---
class NotificationFacade {
    private final EmailService       emailService;
    private final SmsGateway         smsGateway;
    private final PushNotificationService pushService;
    private final ModernAlerter      alerter;

    public NotificationFacade() {
        this.emailService = new EmailService();
        this.smsGateway   = new SmsGateway();
        this.pushService  = new PushNotificationService();
        // Plugging in the adapted legacy system — callers never know it's legacy
        this.alerter      = new LegacyAlertAdapter(new LegacyAlertSystem());
    }

    // Caller doesn't know about three subsystems — just calls this one method
    public void notifyUser(String userId, String email, String phone,
                           String deviceToken, String eventMessage) {
        System.out.println("--- Sending notifications for event: " + eventMessage + " ---");
        emailService.sendEmail(email, "Important Update", eventMessage);
        smsGateway.sendSms(phone, eventMessage);
        pushService.pushToDevice(deviceToken, "{\"msg\":\"" + eventMessage + "\"}");
        alerter.alert(userId, eventMessage);  // Goes through Adapter → Legacy system
        System.out.println("--- All notifications dispatched ---\n");
    }
}

public class NotificationFacadeDemo {
    public static void main(String[] args) {
        NotificationFacade notifier = new NotificationFacade();

        // Caller only needs to know about this one clean method
        notifier.notifyUser(
            "4821",
            "alice@example.com",
            "+14155552671",
            "device-token-abc123",
            "Your order has shipped!"
        );
    }
}

import java.util.ArrayList;
import java.util.List;

// Strategy Pattern — swap discount algorithms at runtime without changing cart logic

// The Strategy interface: every discount type must implement this contract
interface DiscountStrategy {
    double apply(double originalPrice);
    String describe();
}

// Concrete Strategy 1: No discount (the default)
class NoDiscount implements DiscountStrategy {
    @Override
    public double apply(double originalPrice) {
        return originalPrice;  // Price unchanged
    }
    @Override public String describe() { return "No discount applied"; }
}

// Concrete Strategy 2: Percentage-based discount (e.g. summer sale)
class PercentageDiscount implements DiscountStrategy {
    private final double percentOff;  // e.g. 20.0 means 20% off

    public PercentageDiscount(double percentOff) {
        this.percentOff = percentOff;
    }

    @Override
    public double apply(double originalPrice) {
        return originalPrice * (1 - percentOff / 100.0);
    }
    @Override public String describe() { return percentOff + "% off"; }
}

// Concrete Strategy 3: Flat amount off (e.g. $10 coupon code)
class FlatAmountDiscount implements DiscountStrategy {
    private final double discountAmount;

    public FlatAmountDiscount(double discountAmount) {
        this.discountAmount = discountAmount;
    }

    @Override
    public double apply(double originalPrice) {
        // Guard: price can't go below zero
        return Math.max(0, originalPrice - discountAmount);
    }
    @Override public String describe() { return "$" + discountAmount + " flat off"; }
}

// Observer Pattern — notify multiple listeners when cart total changes
interface CartObserver {
    void onTotalChanged(double newTotal);
}

// Context class: the ShoppingCart holds a strategy and notifies observers
class ShoppingCart {
    private final List<Double>       itemPrices  = new ArrayList<>();
    private final List<CartObserver> observers   = new ArrayList<>();
    private DiscountStrategy         discountStrategy;

    public ShoppingCart() {
        this.discountStrategy = new NoDiscount();  // Sensible default
    }

    // Swap the discount strategy at any point without rebuilding the cart
    public void setDiscountStrategy(DiscountStrategy strategy) {
        this.discountStrategy = strategy;
        System.out.println("Discount updated: " + strategy.describe());
        notifyObservers();  // Immediately tell listeners about the pricing change
    }

    public void addItem(String itemName, double price) {
        itemPrices.add(price);
        System.out.println("Added: " + itemName + " ($" + price + ")");
        notifyObservers();
    }

    public void addObserver(CartObserver observer) {
        observers.add(observer);
    }

    private void notifyObservers() {
        double rawTotal      = itemPrices.stream().mapToDouble(Double::doubleValue).sum();
        double discountedTotal = discountStrategy.apply(rawTotal);
        // Every registered observer gets the updated total automatically
        for (CartObserver observer : observers) {
            observer.onTotalChanged(discountedTotal);
        }
    }
}

public class ShoppingCartStrategy {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        // Register observers — these represent UI widgets or analytics services
        cart.addObserver(total ->
            System.out.printf("  [Price Display] Current total: $%.2f%n", total));
        cart.addObserver(total ->
            System.out.printf("  [Analytics]     Cart value logged: $%.2f%n", total));

        System.out.println("\n=== Adding items ===");
        cart.addItem("Wireless Keyboard", 79.99);
        cart.addItem("USB-C Hub",         49.99);
        cart.addItem("Monitor Stand",     35.00);

        System.out.println("\n=== Applying summer sale (20% off) ===");
        cart.setDiscountStrategy(new PercentageDiscount(20));

        System.out.println("\n=== User applies $15 coupon code ===");
        // Swapping strategy mid-session — observers are notified again automatically
        cart.setDiscountStrategy(new FlatAmountDiscount(15));
    }
}

// Factory Method Pattern — let subclasses decide which concrete document to create

abstract class Document {
    public abstract void open();
    public abstract void save();
}

class PDFDocument extends Document {
    @Override public void open() { System.out.println("Opening PDF..."); }
    @Override public void save() { System.out.println("Saving PDF..."); }
}

class WordDocument extends Document {
    @Override public void open() { System.out.println("Opening Word document..."); }
    @Override public void save() { System.out.println("Saving Word document..."); }
}

class SpreadsheetDocument extends Document {
    @Override public void open() { System.out.println("Opening spreadsheet..."); }
    @Override public void save() { System.out.println("Saving spreadsheet..."); }
}

// The factory method is declared abstract in the creator
abstract class DocumentCreator {
    // This is the factory method — subclasses implement it
    protected abstract Document createDocument();

    // Template method using the factory method
    public void newDocument() {
        Document doc = createDocument();
        doc.open();
        // ... do some work ...
        doc.save();
    }
}

class PDFCreator extends DocumentCreator {
    @Override
    protected Document createDocument() {
        return new PDFDocument();
    }
}

class WordCreator extends DocumentCreator {
    @Override
    protected Document createDocument() {
        return new WordDocument();
    }
}

class SpreadsheetCreator extends DocumentCreator {
    @Override
    protected Document createDocument() {
        return new SpreadsheetDocument();
    }
}

public class DocumentFactoryDemo {
    public static void main(String[] args) {
        // The client only knows about DocumentCreator and Document
        DocumentCreator creator = new PDFCreator();
        creator.newDocument();

        creator = new WordCreator();
        creator.newDocument();
    }
}

// Adapter Pattern — make a legacy payment system work with a modern checkout flow

// Target interface that the modern checkout expects
interface ModernPaymentProcessor {
    boolean charge(String customerId, double amount);
    String getTransactionId();
}

// Adaptee: legacy payment system with a different API
class LegacyPaymentSystem {
    // Returns a transaction ID as an integer, amount in cents
    public int executePayment(int clientCode, int amountCents) {
        System.out.println("[LEGACY] Charging client " + clientCode + " amount " + amountCents + " cents");
        return 12345; // pretend transaction ID
    }
}

// Adapter maps modern interface to legacy API
class LegacyPaymentAdapter implements ModernPaymentProcessor {
    private final LegacyPaymentSystem legacySystem;
    private String lastTransactionId;

    public LegacyPaymentAdapter(LegacyPaymentSystem legacySystem) {
        this.legacySystem = legacySystem;
    }

    @Override
    public boolean charge(String customerId, double amount) {
        int clientCode = Integer.parseInt(customerId.replaceAll("[^0-9]", ""));
        int cents = (int) Math.round(amount * 100);
        int legacyId = legacySystem.executePayment(clientCode, cents);
        this.lastTransactionId = String.valueOf(legacyId);
        return legacyId > 0;
    }

    @Override
    public String getTransactionId() {
        return lastTransactionId;
    }
}

public class PaymentAdapterDemo {
    public static void main(String[] args) {
        ModernPaymentProcessor processor = new LegacyPaymentAdapter(new LegacyPaymentSystem());

        // Client code calls the modern interface — doesn't know it's talking to legacy
        boolean success = processor.charge("CUST-4821", 49.99);
        System.out.println("Payment success: " + success);
        System.out.println("Transaction ID: " + processor.getTransactionId());
    }
}

// Not runnable — this is a decision tree sketch
// Identify the problem:
// 1. Object creation problem? -> Singleton, Factory, Builder, Prototype
// 2. Composition/integration problem? -> Adapter, Decorator, Facade, Proxy
// 3. Communication/responsibility problem? -> Strategy, Observer, Command, Iterator
//
// Example:
// Problem: "We have a class that creates different types of documents based on a string parameter"
// Pain: "Every time we add a document type, we edit that class"
// Pattern: Factory Method -> each document type in its own subclass
//
// Problem: "We need to send notifications via email, SMS, and push — currently three separate method calls"
// Pain: "Every new notification channel requires changing the caller code"
// Pattern: Facade + possibly Observer
//
// Problem: "The payment processing method has a 12-branch if-else chain"
// Pain: "Adding a new payment method breaks the existing code"
// Pattern: Strategy

// io.thecodeforge — cs-fundamentals tutorial

// Bad: Singleton applied before it hurts
class LoggerConfig:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

// Now every test that imports this is coupled
// Every parallel thread fights over one config

// Better: pass config explicitly until coupling hurts
class PaymentService:
    def __init__(self, config: dict):
        self.config = config

// If you need exactly one instance, inject it from main()
// Don't bake it into the class

// io.thecodeforge — cs-fundamentals tutorial

// Without pattern: simple, testable, no indirection
def send_email(recipient: str, body: str):
    smtp_client = SMTPClient(config["smtp_host"])
    smtp_client.send(recipient, body)

// With Adapter: only if you have multiple email providers
class EmailGateway:
    def send(self, recipient: str, body: str): pass

class SMTPAdapter(EmailGateway):
    def send(self, recipient, body):
        SMTPClient(config["smtp_host"]).send(recipient, body)

class SendGridAdapter(EmailGateway):
    def send(self, recipient, body):
        SendGridAPI(config["sendgrid_key"]).deliver(recipient, body)

// Ask: "Are we actually switching email providers?"
// If not, the first version wins. No pattern needed.

// io.thecodeforge — cs-fundamentals tutorial

from abc import ABC, abstractmethod

class NotificationSender(ABC):
    @abstractmethod
    def send(self, msg: str):
        pass

class EmailSender(NotificationSender):
    def send(self, msg: str):
        print(f"[EMAIL] {msg}")

class SMSSender(NotificationSender):
    def send(self, msg: str):
        print(f"[SMS] {msg}")

class NotificationService:
    def __init__(self, sender: NotificationSender):
        self._sender = sender

    def notify(self, msg: str):
        self._sender.send(msg)

# Usage
svc = NotificationService(EmailSender())
svc.notify("Deploy succeeded")

// io.thecodeforge — cs-fundamentals tutorial

class PatternCheck:
    @staticmethod
    def is_pattern(candidate: str) -> bool:
        checks = [
            "Has 1 name",
            "Solves 1 problem",
            "Has trade-offs",
            "Works in prod"
        ]
        return all(c in candidate for c in checks)

print(PatternCheck.is_pattern("Singleton — controls instance count, but breaks testability"))
print(PatternCheck.is_pattern("MagicWrapper — fixes everything"))

# Modern Singleton using dependency injection container
# Instead of a global instance, let the DI container manage lifecycle

class DatabaseConnection:
    def __init__(self, url: str):
        self.url = url

# In a DI framework (e.g., FastAPI with Depends)
from fastapi import FastAPI, Depends

app = FastAPI()

# Assume a container that provides a singleton instance
def get_db():
    return DatabaseConnection("postgresql://localhost/mydb")

@app.get("/")
def read_root(db: DatabaseConnection = Depends(get_db)):
    return {"db_url": db.url}

# Simplified CQRS example: separate write and read models

class WriteModel:
    def __init__(self):
        self.db = {}

    def create_user(self, user_id: str, name: str):
        self.db[user_id] = {"name": name, "version": 1}
        return user_id

class ReadModel:
    def __init__(self):
        self.db = {}  # denormalized for fast reads

    def update_from_event(self, event):
        if event["type"] == "UserCreated":
            self.db[event["user_id"]] = {"name": event["name"], "post_count": 0}

    def get_user(self, user_id: str):
        return self.db.get(user_id)

# Simple Maybe monad in Python

class Maybe:
    def __init__(self, value):
        self.value = value

    @staticmethod
    def just(value):
        return Maybe(value)

    @staticmethod
    def nothing():
        return Maybe(None)

    def map(self, func):
        if self.value is None:
            return Maybe.nothing()
        return Maybe.just(func(self.value))

    def flat_map(self, func):
        if self.value is None:
            return Maybe.nothing()
        return func(self.value)

# Usage: chaining without None checks
def safe_divide(x: float, y: float) -> Maybe:
    if y == 0:
        return Maybe.nothing()
    return Maybe.just(x / y)

result = Maybe.just(10).flat_map(lambda v: safe_divide(v, 2)).map(lambda v: v * 2)
print(result.value)  # 10.0