function retry_with_backoff(operation, max_retries=3, base_delay=1.0, max_delay=30.0):
  for attempt in 0..max_retries:
    try:
      return operation()
    catch error:
      if not is_retryable(error):     // 400, 404 = don't retry
        throw error
      if attempt == max_retries:
        throw error                    // exhausted retries

      // Exponential backoff with equal jitter (guarantees minimum delay)
      exp_delay = min(base_delay * (2 ** attempt), max_delay)
      // Equal jitter: half the delay is guaranteed, half is random
      // This ensures some minimum backoff while still de-correlating clients
      sleep(exp_delay / 2 + random(0, exp_delay / 2))

function is_retryable(error):
  // 502, 503, 504 = almost always transient (gateway/upstream issues)
  // 429 = rate limited (respect Retry-After header)
  // 408, Timeout, Connection = transient network issues
  // 500 = debatable — may be a bug (deterministic failure) or transient
  //   Conservative approach: retry 500 once, then treat as non-retryable
  return error.status in [408, 429, 500, 502, 503, 504]
         or error is TimeoutError
         or error is ConnectionError

  ┌──────────────────────────────────────────────────────┐
  │                                                      │
  │   ┌────────┐   failure threshold   ┌────────┐       │
  │   │ CLOSED │ ──── exceeded ──────> │  OPEN  │       │
  │   │        │                       │        │       │
  │   └────────┘                       └────────┘       │
  │       ^                                │            │
  │       │                                │            │
  │       │  success threshold     recovery timeout     │
  │       │  reached in half-open      expires          │
  │       │                                │            │
  │       │        ┌───────────┐           │            │
  │       └─────── │ HALF-OPEN │ <─────────┘            │
  │                │           │                        │
  │                └───────────┘                        │
  │                      │                              │
  │                      │ any failure                  │
  │                      └──────────── back to OPEN ────┘
  │                                                      │
  └──────────────────────────────────────────────────────┘

class CircuitBreaker:
  state = CLOSED
  failure_count = 0
  success_count = 0
  last_failure_time = null
  FAILURE_THRESHOLD = 5        // open after 5 consecutive failures
  RECOVERY_TIMEOUT = 30s       // try half-open after 30 seconds
  SUCCESS_THRESHOLD = 3        // close after 3 successes in half-open

  function call(request):
    if state == OPEN:
      if now() - last_failure_time > RECOVERY_TIMEOUT:
        state = HALF_OPEN       // enough time passed, test one request
        half_open_in_flight = true
      else:
        throw CircuitOpenException("Service unavailable, circuit is open")

    if state == HALF_OPEN and half_open_in_flight == false:
      throw CircuitOpenException("Half-open test in progress, rejecting")

    try:
      result = downstream.call(request)
      on_success()
      return result
    catch error:
      on_failure()
      throw error

  function on_success():
    if state == HALF_OPEN:
      success_count++
      if success_count >= SUCCESS_THRESHOLD:
        state = CLOSED          // recovered — resume normal traffic
        failure_count = 0
        success_count = 0
    else:
      failure_count = 0         // reset on success in closed state

  function on_failure():
    failure_count++
    last_failure_time = now()
    if state == HALF_OPEN:
      state = OPEN              // still failing — reopen
      success_count = 0
    elif failure_count >= FAILURE_THRESHOLD:
      state = OPEN              // too many failures — trip the breaker

class Invoice:
    def calculate_total(self, items, tax_rate):
        # Accounting logic — changes when tax rules change
        subtotal = sum(item.price * item.qty for item in items)
        return subtotal + (subtotal * tax_rate)

    def generate_pdf(self, invoice_data):
        # Rendering logic — changes when PDF layout changes
        pdf = PDFDocument()
        pdf.add_header("Invoice")
        pdf.add_table(invoice_data)
        return pdf.render()

class InvoiceCalculator:
    """Changes only when accounting/tax rules change."""
    def calculate_total(self, items, tax_rate):
        subtotal = sum(item.price * item.qty for item in items)
        return subtotal + (subtotal * tax_rate)

class InvoiceRenderer:
    """Changes only when PDF presentation changes."""
    def generate_pdf(self, invoice_data):
        pdf = PDFDocument()
        pdf.add_header("Invoice")
        pdf.add_table(invoice_data)
        return pdf.render()

class PaymentProcessor:
    def process(self, payment):
        if payment.method == "stripe":
            # Stripe-specific logic
            stripe.charge(payment.amount, payment.token)
        elif payment.method == "paypal":
            # PayPal-specific logic
            paypal.create_payment(payment.amount, payment.email)
        elif payment.method == "apple_pay":
            # Every new method = modifying this growing if/elif chain
            apple.authorize(payment.amount, payment.device_token)

class PaymentProcessor(ABC):
    @abstractmethod
    def process(self, payment): ...

class StripeProcessor(PaymentProcessor):
    def process(self, payment):
        stripe.charge(payment.amount, payment.token)

class PayPalProcessor(PaymentProcessor):
    def process(self, payment):
        paypal.create_payment(payment.amount, payment.email)

# Adding Apple Pay = adding a new class, no existing code modified
class ApplePayProcessor(PaymentProcessor):
    def process(self, payment):
        apple.authorize(payment.amount, payment.device_token)

class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height

    def set_width(self, w):
        self._width = w          # Only changes width

    def set_height(self, h):
        self._height = h         # Only changes height

    def area(self):
        return self._width * self._height

class Square(Rectangle):
    def set_width(self, w):
        self._width = w
        self._height = w         # SURPRISE: also changes height

    def set_height(self, h):
        self._width = h          # SURPRISE: also changes width
        self._height = h

# Code that expects Rectangle behavior breaks:
def test_area(rect: Rectangle):
    rect.set_width(5)
    rect.set_height(4)
    assert rect.area() == 20    # FAILS for Square (returns 16)

class Shape(ABC):
    @abstractmethod
    def area(self): ...

class Rectangle(Shape):
    def __init__(self, width, height):
        self._width = width
        self._height = height
    def area(self):
        return self._width * self._height

class Square(Shape):
    def __init__(self, side):
        self._side = side
    def area(self):
        return self._side ** 2

class Machine(ABC):
    @abstractmethod
    def print(self, doc): ...
    @abstractmethod
    def scan(self, doc): ...
    @abstractmethod
    def fax(self, doc): ...

class BasicPrinter(Machine):
    def print(self, doc):
        # Actually prints
        ...
    def scan(self, doc):
        raise NotImplementedError("I can't scan!")  # Forced to implement
    def fax(self, doc):
        raise NotImplementedError("I can't fax!")   # Forced to implement

class Printable(ABC):
    @abstractmethod
    def print(self, doc): ...

class Scannable(ABC):
    @abstractmethod
    def scan(self, doc): ...

class Faxable(ABC):
    @abstractmethod
    def fax(self, doc): ...

class BasicPrinter(Printable):
    def print(self, doc):
        ...  # Only implements what it can do

class MultiFunctionPrinter(Printable, Scannable, Faxable):
    def print(self, doc): ...
    def scan(self, doc): ...
    def fax(self, doc): ...

class OrderService:
    def __init__(self):
        self.payment = StripeClient()   # Hardcoded dependency

    def checkout(self, order):
        self.payment.charge(order.total)  # Can't swap, can't test

class PaymentGateway(ABC):
    @abstractmethod
    def charge(self, amount): ...

class OrderService:
    def __init__(self, payment: PaymentGateway):  # Injected abstraction
        self.payment = payment

    def checkout(self, order):
        self.payment.charge(order.total)

# Easy to swap: StripeGateway, AdyenGateway, MockGateway for tests

# Two teams share a "validate_input" function because the code looks identical
def validate_input(data, context):
    if context == "user_registration":
        # registration-specific rules creep in
        ...
    elif context == "order_placement":
        # order-specific rules creep in
        ...
    # This function grows into a god function with branching for every caller