function process_with_retry(message):
  max_retries = 5
  retry_count = message.metadata.retry_count or 0

  try:
    process(message)
    broker.ack(message)
  catch NonRetryableError as e:
    // Poison pill — no amount of retrying will fix this
    log.error("Non-retryable failure", message_id=message.id, error=e)
    move_to_dlq(message, reason=e)
    broker.ack(message)
  catch RetryableError as e:
    if retry_count >= max_retries:
      log.error("Max retries exceeded", message_id=message.id, attempts=retry_count)
      move_to_dlq(message, reason="max_retries_exceeded")
      broker.ack(message)
    else:
      delay = min(2^retry_count * 1000, 60000)  // cap at 60s
      jitter = random(0, delay * 0.3)           // 30% jitter
      schedule_retry(message, delay + jitter, retry_count + 1)
      broker.ack(message)

# BROKEN — race condition between check and act
def withdraw(account_id, amount):
    balance = db.query("SELECT balance FROM accounts WHERE id = %s", account_id)
    if balance >= amount:
        # Another thread can withdraw between the SELECT and UPDATE
        db.execute("UPDATE accounts SET balance = balance - %s WHERE id = %s", amount, account_id)
        return "success"
    return "insufficient funds"

# FIXED — atomic operation, no window between check and act
def withdraw(account_id, amount):
    rows_affected = db.execute(
        "UPDATE accounts SET balance = balance - %s WHERE id = %s AND balance >= %s",
        amount, account_id, amount
    )
    return "success" if rows_affected > 0 else "insufficient funds"

# BROKEN — two threads read version 1, both write version 1 data
def update_profile(user_id, new_name):
    user = db.query("SELECT * FROM users WHERE id = %s", user_id)
    user.name = new_name
    db.execute("UPDATE users SET name = %s WHERE id = %s", new_name, user_id)

# FIXED — optimistic locking rejects stale writes
def update_profile(user_id, new_name, expected_version):
    rows = db.execute(
        "UPDATE users SET name = %s, version = version + 1 WHERE id = %s AND version = %s",
        new_name, user_id, expected_version
    )
    if rows == 0:
        raise ConflictError("Profile was modified by another request. Retry.")

// BROKEN — multiple goroutines increment simultaneously
var counter int
func increment() {
    counter++  // this is actually: read counter, add 1, write counter
    // Two goroutines can both read 5, both write 6 — one increment lost
}

// FIXED — atomic operation
var counter int64
func increment() {
    atomic.AddInt64(&counter, 1)  // hardware-level atomic, no lost updates
}

    +-------------------------------------------------+
    |                   EVENT LOOP                     |
    |                                                  |
    |  1. Poll Phase: check for completed I/O          |
    |  2. Check Phase: run setImmediate() callbacks     |
    |  3. Timers Phase: run setTimeout/setInterval      |
    |  4. Repeat                                       |
    +-------------------------------------------------+
         |            |             |
    [DB query]   [HTTP call]  [File read]
         |            |             |
    (OS/libuv handles I/O in background thread pool)

import asyncio

async def fetch_user(user_id):
    # This does NOT block the event loop — it yields control
    response = await http_client.get(f"/users/{user_id}")
    return response.json()

async def main():
    # These run concurrently on a SINGLE thread
    user1, user2, user3 = await asyncio.gather(
        fetch_user(1),
        fetch_user(2),
        fetch_user(3),
    )
    # All three HTTP requests were in-flight simultaneously
    # Total time ~ max(request1, request2, request3), not the sum

                          cancel (any state except Delivered/Returned)
                    +-------------------------------------------+
                    |                                           |
                    v                                           |
              +-----------+   pay    +---------+  ship   +-----------+
  [create] -> |  PLACED   | ------> |  PAID   | -----> |  SHIPPED  |
              +-----------+         +---------+         +-----------+
                    |                    |                     |
                    | (payment timeout)  | (refund before      | deliver
                    v                    |  shipping)          v
              +-----------+              |              +-----------+
              | CANCELLED |  <-----------+              | DELIVERED |
              +-----------+                             +-----------+
                    ^                                         |
                    |              +-----------+    return     |
                    +---------    |  RETURNED  | <------------+
                                  +-----------+

TRANSITIONS = {
    ("PLACED",    "PAID"):      { "guard": payment_confirmed,   "effect": reserve_inventory_and_email },
    ("PLACED",    "CANCELLED"): { "guard": timeout_or_user_cancel, "effect": release_holds },
    ("PAID",      "SHIPPED"):   { "guard": warehouse_dispatched, "effect": generate_tracking },
    ("PAID",      "CANCELLED"): { "guard": refund_requested,     "effect": process_refund },
    ("SHIPPED",   "DELIVERED"): { "guard": carrier_confirmed,    "effect": close_fulfillment },
    ("DELIVERED", "RETURNED"):  { "guard": return_within_window, "effect": generate_return_label },
    ("RETURNED",  "CANCELLED"): { "guard": return_inspected,     "effect": refund_and_restock },
}

def transition_order(order, target_state):
    key = (order.state, target_state)
    rule = TRANSITIONS.get(key)

    if rule is None:
        raise InvalidTransitionError(f"Cannot go from {order.state} to {target_state}")

    if not rule["guard"](order):
        raise GuardFailedError(f"Conditions not met for {order.state} -> {target_state}")

    with db.transaction():
        old_state = order.state
        order.state = target_state
        db.save(order)
        db.insert("state_transitions", {
            "order_id": order.id,
            "from_state": old_state,
            "to_state": target_state,
            "actor": current_user(),
            "timestamp": now(),
        })
        rule["effect"](order)