One Problem in Five Languages

// Node: a small pool of async workers pulling from a shared index
async function fetchAll(urls, limit = 10) {
  const out = new Array(urls.length); let i = 0;
  const worker = async () => { while (i < urls.length) { const k = i++; out[k] = await fetch(urls[k], { signal: AbortSignal.timeout(5000) }).then(r => r.status); } };
  await Promise.all(Array.from({ length: limit }, worker));
  return out;
}

// Go: errgroup with a limit and a context that cancels on the first error
g, ctx := errgroup.WithContext(ctx); g.SetLimit(10)
for i, u := range urls { g.Go(func() error { s, err := get(ctx, u, 5*time.Second); out[i] = s; return err }) }
err := g.Wait()

// Rust (Tokio): buffer_unordered caps concurrency at 10
let out: Vec<_> = stream::iter(urls).map(|u| async move { timeout(Duration::from_secs(5), client.get(u).send()).await })
    .buffer_unordered(10).collect().await;

// Java 21: virtual threads + a semaphore
try (var ex = Executors.newVirtualThreadPerTaskExecutor()) {
  var sem = new Semaphore(10);
  var fs = urls.stream().map(u -> ex.submit(() -> { sem.acquire(); try { return get(u); } finally { sem.release(); } })).toList();
  for (var f : fs) results.add(f.get());
}

# Python asyncio: a semaphore and gather
async def fetch_all(urls, limit=10):
    sem = asyncio.Semaphore(limit)
    async def one(u):
        async with sem: return await asyncio.wait_for(get(u), 5)
    return await asyncio.gather(*(one(u) for u in urls))