From Callbacks to Promises: Solving Callback Hell with Async Patterns

As an early software engineer you faced a dilemma: threads were useful but blocking calls (e.g., downstream service requests) would suspend the entire thread, forcing you to create many threads and incurring high creation/switch overhead and memory consumption. This synchronous model is simple but inefficient.

Callback Functions and Asynchronous Programming

To avoid blocking, you introduced callbacks: instead of waiting, you pass a function that the system calls when the operation completes.

get_response(parse_response);  // get_response returns immediately

Here parse_response is the callback that processes the downstream response, allowing get_response to return without blocking.

Callback Hell: The Nightmare Begins

When multiple dependent asynchronous operations are needed, callbacks become deeply nested, forming the infamous "callback hell" and making the code hard to read and maintain.

getUser(userId, function(user) {
  getUserOrders(user.id, function(orders) {
    getOrderDetails(orders[0].id, function(details) {
      displayOrderDetails(details);
    }, function(error) {
      handleOrderDetailsError(error);
    });
  }, function(error) {
    handleOrdersError(error);
  });
}, function(error) {
  handleUserError(error);
});

The nested structure fragments the control flow, and as the depth grows, readability and maintainability suffer.

Future or Now? Introducing Promise/Future

To linearise asynchronous composition, you create a "time container" that separates values from computation and supports chainable calls. This is the Promise (or Future) abstraction.

A Promise represents a value that will become available later. Its powerful feature is chaining via .then() for success handling and .catch() for error handling.

getUser(userId)
  .then(user => getUserOrders(user.id))
  .then(orders => getOrderDetails(orders[0].id))
  .then(details => displayOrderDetails(details))
  .catch(error => handleError(error));

This linear chain eliminates deep nesting and makes asynchronous flows easier to read. Additionally, Promise.all() can run multiple promises in parallel and resolve when all succeed.

Synchronous + Asynchronous

While Promises improve structure, they still rely on underlying callbacks ( .then(), .catch()) and can feel like pseudo‑synchronous code. For very complex async logic, the code may still be unintuitive.

The next step is to combine the intuitive nature of synchronous code with the efficiency of asynchronous execution without blocking threads. This leads to the concept of coroutines, which implement custom control flow on top of threads.