Async & Non-Blocking I/O

Concurrent I/O with Promise.all vs sequential in TypeScript

interface ProductDetails {
  product: { id: string; name: string };
  inventory: { qty: number };
  reviews: { avgRating: number; count: number };
}

// SEQUENTIAL: total time = t_product + t_inventory + t_reviews
async function getProductDetailsSequential(id: string): Promise<ProductDetails> {
  const product = await fetchProduct(id);       // ~50ms
  const inventory = await fetchInventory(id);   // ~30ms
  const reviews = await fetchReviews(id);       // ~40ms
  return { product, inventory, reviews };        // total ~120ms
}

// CONCURRENT: total time = max(t_product, t_inventory, t_reviews)
async function getProductDetailsConcurrent(id: string): Promise<ProductDetails> {
  const [product, inventory, reviews] = await Promise.all([
    fetchProduct(id),    // ~50ms
    fetchInventory(id),  // ~30ms (runs concurrently)
    fetchReviews(id),    // ~40ms (runs concurrently)
  ]);
  return { product, inventory, reviews }; // total ~50ms
}

// CONCURRENT with independent error handling
async function getProductDetailsResilient(id: string) {
  const [product, inventory, reviews] = await Promise.allSettled([
    fetchProduct(id),
    fetchInventory(id),
    fetchReviews(id),
  ]);
  return {
    product: product.status === 'fulfilled' ? product.value : null,
    inventory: inventory.status === 'fulfilled' ? inventory.value : null,
    reviews: reviews.status === 'fulfilled' ? reviews.value : null,
  };
}

The concurrent version runs all three fetches simultaneously. On a 120ms total with sequential execution, concurrent reduces wall-clock time to 50ms, a 2.4x speedup for this pattern. Promise.allSettled allows partial results when individual sources can fail independently.

Async streams with the Async gem in Ruby

require 'async'
require 'async/http/internet'

# Sequential: each request waits for the previous
def fetch_prices_sequential(product_ids)
  internet = Async::HTTP::Internet.new
  product_ids.map do |id|
    response = internet.get("https://pricing.api/products/#{id}")
    JSON.parse(response.read)
  end
end

# Concurrent: all requests in-flight simultaneously using Async tasks
def fetch_prices_concurrent(product_ids)
  Async do
    internet = Async::HTTP::Internet.new
    tasks = product_ids.map do |id|
      Async do
        response = internet.get("https://pricing.api/products/#{id}")
        JSON.parse(response.read)
      end
    end
    tasks.map(&:wait)
  end.wait
end

# With timeout per task
def fetch_prices_with_timeout(product_ids, timeout: 5)
  Async do
    internet = Async::HTTP::Internet.new
    product_ids.map do |id|
      Async do
        Async::Task.current.with_timeout(timeout) do
          response = internet.get("https://pricing.api/products/#{id}")
          JSON.parse(response.read)
        end
      rescue Async::TimeoutError
        nil
      end
    end.map(&:wait)
  end.wait
end

The Async gem (Samuel Williams, 2018) uses Ruby Fibers to implement cooperative concurrency on top of the event loop. Unlike threads, Fibers yield control explicitly at I/O boundaries; the Async::HTTP client automatically yields when waiting for network responses.