Come Back Later: Review Challenges

Return after several days without copying old solutions. Rebuild a lazy batch generator, a bounded counter and the first-failure recorder. State when generator validation executes and why a private field does not preserve an invariant without checks.

Next, recreate a two-gate ordering regression. Resolve the second job first and prove input-order output. Explain the difference between Promise.all preserving order and Promise.all limiting starts: it does the former, not the latter.

Finally, review the task-pool API from memory. Which callbacks receive a signal? When does rejection happen relative to active work? What happens if a callback never settles? Why does bounded concurrency still permit O(n) result memory? Identify one case that needs a source iterator cleanup test and one that needs a controlled schedule.

Predict, run, and explain

Write the output and trace the important state changes before checking it. Then run the program. Each editor is independent. Async examples end with main() so this editor waits for their work.

const original = { nested: { count: 1 } };
const copy = { ...original };

copy.nested.count = 2;
console.log(original.nested.count);

2

Your turn

// Keep failure presence independent of its stored value.

function firstFailure() {
  let failed = false;
  let value;

  return {
    record(error) {
      if (!failed) {
        failed = true;
        value = error;
      }
    },
    read() {
      return { failed, value };
    }
  };
}

const state = firstFailure();

state.record(undefined);
state.record("late");
console.log(state.read().failed);
console.log(state.read().value === undefined);

true
true

Change it and test it

Redo the retry brief after a week using controlled failures instead of timers. Explain the callback assumptions before coding. If you want types to enforce more caller relationships, continue with TypeScript beginner and intermediate; no framework is required for either path.