Parallel vs Sequential Async Operations

async function sequential() {
  const a = await delay(100, "a"); // starts, waits 100ms
  const b = await delay(100, "b"); // does NOT start until `a` is done — another 100ms
  const c = await delay(100, "c"); // does NOT start until `b` is done — another 100ms
  return [a, b, c];
}
// total time: ~300ms

async function parallel() {
  const promiseA = delay(100, "a"); // starts immediately, NOT awaited yet
  const promiseB = delay(100, "b"); // starts immediately too — overlaps with A
  const promiseC = delay(100, "c"); // starts immediately too — overlaps with A and B

  const [a, b, c] = await Promise.all([promiseA, promiseB, promiseC]); // wait for all THREE at once
  return [a, b, c];
}
// total time: ~100ms — all three ran concurrently

// LOOKS like it should be fine, but is needlessly sequential:
async function loadAllUsersSlow(ids) {
  const users = [];
  for (const id of ids) {
    const user = await fetchUser(id); // each iteration waits for the PREVIOUS one
    users.push(user);
  }
  return users;
}

// Fixed — starts all requests immediately, waits for all together:
async function loadAllUsersFast(ids) {
  const promises = ids.map(id => fetchUser(id)); // all fetches START here, immediately
  return Promise.all(promises);                    // NOW wait for all of them together
}

async function checkoutFlow() {
  const cart = await getCart();                 // step 2 needs cart's contents
  const total = await calculateTotal(cart);       // step 3 needs the calculated total
  const receipt = await chargeCard(total);         // each step's INPUT comes from the previous OUTPUT
  return receipt;
}

async function loadPage(userId) {
  // These two are INDEPENDENT of each other — run them in parallel:
  const [user, settings] = await Promise.all([
    fetchUser(userId),
    fetchSettings(userId),
  ]);

  // This DEPENDS on `user` — must run sequentially after the above:
  const recommendations = await fetchRecommendations(user.preferences);

  return { user, settings, recommendations };
}

async function processInBatches(items, batchSize, asyncFn) {
  const results = [];
  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    const batchResults = await Promise.all(batch.map(asyncFn)); // parallel WITHIN a batch
    results.push(...batchResults);
    // sequential BETWEEN batches — waits for one batch before starting the next
  }
  return results;
}