INDUSTRY NEXT / OPEN PROOF 002 / RUNS IN YOUR BROWSER

TOPCODER

Control the rush. Keep the order.

One asynchronous system needs a traffic plan. Bound the concurrency, preserve input order, stop honestly on failure, and carry the receipt. No account. No upload. No speed bonus.

Open ticket 002

PROMISE_POOL.EXELOCAL / READY

TIME LIMIT: None
UPLOADS: None
TOP CODER: 90+

01 / BOUNDEDUse all the room. Never more.

The pool stays busy while respecting the exact concurrency limit it was given.

02 / ORDEREDFinish wild. Return calm.

Workers may resolve in any sequence; callers still receive results in input order.

03 / HONESTFailure closes the gate.

Reject with the original error and stop starting work the caller no longer expects.

THE LOCAL PROOF BOOK / TWO TICKETS

Build a small
body of proof.

0/ 2 SEALED

TICKET 001 / STATE + ORDERThe Messy Queue

Reconcile revisions, cancellation, priority, and time without mutating the caller.

OPEN TICKET 002 / ASYNC + CONCURRENCYThe Promise Pool

Keep parallel work moving without losing order, exceeding capacity, or swallowing failure.

OPEN HERE

0 sealed. 2 still open.

TICKET 002 / THE PROMISE POOL

Bound the
concurrency.

READY 00 POINTS / 100

PROMISE.JS

Write `mapWithLimit(items, limit, worker)`.

The harness supplies a positive integer limit. Return a promise for an array of results that follows four rules:

Bounded: never have more than limit worker calls active.
Complete: call worker(item, index) once for every item.
Ordered: resolve results in input order, even when workers finish out of order.
Honest: reject with the original error, stop starting new work, and never mutate the input.

Open three hints No point penalty

Create a result array and a shared next index. Start at most limit async lanes. Each lane claims an index, awaits the worker, and writes into that index. A shared failed flag closes the gate.

EXAMPLE

await mapWithLimit(["slow", "fast"], 2, worker)
// fast may finish first
→ ["SLOW", "FAST"]

YOUR_POOL.JSLOCAL DRAFT

CHANGE NOTEWhat invariant does your pool protect?

Your code never leaves this page. Checks run in a disposable, network-blocked browser sandbox; your draft and sealed receipt stay only on this device.

Proof checks

Waiting for your first run.

EMPTY RESOLVES EMPTYNo phantom worker call.WAITING
INPUT ORDER HOLDSCompletion order cannot leak.WAITING
LIMIT NEVER BREAKSActive work stays within capacity.WAITING
OPEN SLOTS GET USEDThe pool is genuinely concurrent.WAITING
EACH ITEM RUNS ONCEThe original index comes along.WAITING
FAILURE CLOSES THE GATEOriginal error out; no new work in.WAITING
INPUT REMAINS INTACTThe caller keeps what it passed.WAITING

YOUR PORTABLE PROOF

Carry the
receipt.

The result is local and self-issued. Seal this ticket beside Ticket 001, then copy the two-ticket Proof Book into a portfolio, an application, or a conversation.

Seven correctness checks

Legible change note

Complete proof seal

INDUSTRY NEXT / TOP CODERPROOF ————

00/ 100

RUN THE TICKET

CHALLENGE: Ticket 002 / The Promise Pool
CHECKS: 0 of 7 passed
NOTE: Waiting for a change note.
BOUNDARY: Local browser proof / not a global rank

Raise your hand

THE HONEST BOUNDARY

Two sharp signals.
Still not a universal rank.

THIS CAN SIGNAL

Reasoning about promises, concurrency, ordering, failure, shared state, input safety, and a bounded implementation contract.

THIS CANNOT PROVE

Production observability, long-running collaboration, system architecture at scale, identity, or fit for every engineering role.

THE NEXT MOVE

Bring both receipts and one shipped thing. Explain a tradeoff. Then do a small real task with the people you may join.

TOPCODER

Proof checks

Carry thereceipt.

Two sharp signals.Still not a universal rank.

Carry the
receipt.

Two sharp signals.
Still not a universal rank.