Callbacks, Callback Hell & Error-First Pattern

Promises solve ALL callback problems. Here's the complete comparison:

1. Chainable — no pyramid, linear .then() chain. Each step returns a new Promise.

2. Single error channel — one .catch() handles all errors in the chain. No more error checks at every level.

3. Guaranteed async — Promises always resolve/reject asynchronously, no Zalgo possible.

4. Composable — Promise.all, Promise.race, Promise.any for parallel operations.

5. Once settled, never changes — a resolved Promise stays resolved. No double-call bug.

6. Error propagation — errors bubble up the chain automatically, like try/catch.

The callback era is over for new code. But understanding callbacks is essential for: legacy code, Node.js APIs, and understanding what Promises fix.

// Same 4-step flow — Callbacks vs Promises vs Async/Await

// CALLBACKS: Pyramid of doom
getUser(userId, (err, user) => {
  if (err) return handleError(err);
  getOrders(user.id, (err, orders) => {
    if (err) return handleError(err);
    getOrderDetails(orders[0].id, (err, details) => {
      if (err) return handleError(err);
      processPayment(details.total, (err, receipt) => {
        if (err) return handleError(err);
        console.log("Done:", receipt);
      });
    });
  });
});

// PROMISES: Flat, linear chain
getUser(userId)
  .then(user => getOrders(user.id))
  .then(orders => getOrderDetails(orders[0].id))
  .then(details => processPayment(details.total))
  .then(receipt => console.log("Done:", receipt))
  .catch(err => handleError(err)); // ONE catch for ALL errors!

// ASYNC/AWAIT: Even cleaner (syntactic sugar over Promises)
async function processOrder(userId) {
  try {
    const user = await getUser(userId);
    const orders = await getOrders(user.id);
    const details = await getOrderDetails(orders[0].id);
    const receipt = await processPayment(details.total);
    console.log("Done:", receipt);
  } catch (err) {
    handleError(err); // One try/catch for all steps
  }
}