1.3 — Promises and async/await

Promises represent a future value. async/await is syntax sugar over Promises — still microtasks under the hood.

Callback style (legacy)

fetch('/api/metrics/summary')
  .then((r) => r.json())
  .then((data) => updateCards(data))
  .catch((err) => showError(err));

async/await (modern)

async function loadMetrics() {
  try {
    const r = await fetch('/api/metrics/summary');
    const data = await r.json();
    updateCards(data);
  } catch (err) {
    showError(err);
  }
}

Each await yields the function — remainder schedules as microtasks when the Promise settles.

console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
console.log('D');

Run synchronous code. console.log('A') executes immediately on the call stack.

Call stack

log('A')

Microtask queue

empty

Macrotask queue

empty

Console output

Contrast with Rust (preview)

	JavaScript (browser)	Rust + Tokio (ingestion/analyzer)
Concurrency model	Single thread + event loop	Thread pool + async tasks
Async syntax	`async/await` → microtasks	`async/await` → state machines
Blocking	Blocks the whole tab	`.await` yields task, not thread

Book 1.11 goes deeper on Tokio. For now: radar = JS loop, pipeline = Rust async.

Teach-back prompt

Does await fetch(...) block other tabs? Other SSE events in the same tab?

Promises and async/await