Why async, and callbacks

One thread, many waits

A thread is one line of work that runs instructions one after another. JavaScript runs your code on a single main thread. If that thread stopped for two seconds waiting for a server, the whole page would freeze: no scrolling, no clicks. Node.js would stop serving every other user during the wait.

So slow operations are asynchronous (async): you START them, your code continues immediately, and you are told LATER when they finish. The waiting happens outside your code, in the browser or in Node's system layer.

Synchronous versus asynchronous

console.log('1. Order placed');
setTimeout(() => {
  console.log('3. SMS sent');      // runs later
}, 1000);
console.log('2. Showing receipt');

Callbacks

A callback is a function you pass to another function so that it can call you back when something happens. You have already used callbacks with map and sort; there they are called immediately. With async APIs they are called later.

function fakeFetchUser(id, callback) {
  setTimeout(() => callback({ id, name: 'Asha' }), 100);
}
fakeFetchUser(7, (user) => console.log('Got', user.name));
console.log('Request sent');

Error-first callbacks in Node

Older Node.js APIs use a convention: the callback's first argument is an error (or null), and the result comes second. You must always check the error first.

const fs = require('node:fs');
fs.readFile('orders.csv', 'utf8', (err, text) => {
  if (err) {
    console.error('Could not read file:', err.message);
    return;
  }
  console.log('Lines:', text.split('\n').length);
});

Callback hell

When each step needs the result of the previous one, callbacks nest inside callbacks. The code drifts to the right, errors must be handled at every level, and the flow is hard to follow. This shape is called callback hell or the pyramid of doom.

getUser(id, (err, user) => {
  if (err) return fail(err);
  getOrders(user.id, (err, orders) => {
    if (err) return fail(err);
    getInvoice(orders[0].id, (err, invoice) => {
      if (err) return fail(err);
      sendEmail(user.email, invoice, (err) => {
        if (err) return fail(err);
        console.log('Done!');
      });
    });
  });
});

There is also a trust problem called inversion of control: you hand your function to someone else's code and hope it calls it exactly once, not twice, not never. Promises (next topic) solve both problems.