Introduction

Asynchronous (async) programming is a style of writing code that lets a program start a long-running task and continue doing other work without waiting for that task to finish. When the task completes, the program picks up its result. This avoids "blocking" — where the whole program sits idle waiting for a slow operation like a network call, disk read, or database query.

Real-World Analogy

Synchronous vs Asynchronous

Prerequisites

Core Building Blocks

Evolution of Async Patterns

Async in JavaScript

JavaScript's async model is built on Promises with async/await syntax on top.

The Callback Era (for context)

// Old style — nested callbacks ("callback hell")
getUser(1, function (user) {
    getPosts(user.id, function (posts) {
        getComments(posts[0].id, function (comments) {
            console.log(comments);
        });
    });
});

Modern async / await

async function loadData() {
    try {
        const user = await getUser(1);
        const posts = await getPosts(user.id);
        const comments = await getComments(posts[0].id);
        console.log(comments);
    } catch (err) {
        console.error("Failed:", err);
    }
}

loadData();

Running tasks concurrently

// Both requests run at the same time
async function fetchBoth() {
    const [a, b] = await Promise.all([
        fetch("/api/a"),
        fetch("/api/b"),
    ]);
    return [await a.json(), await b.json()];
}

Async in Python (asyncio)

Python uses async def to define coroutines and await to suspend on awaitables.

import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = ["https://example.com", "https://python.org"]
    async with aiohttp.ClientSession() as session:
        # gather runs all requests concurrently
        results = await asyncio.gather(
            *(fetch(session, url) for url in urls)
        )
    print(f"Fetched {len(results)} pages")

asyncio.run(main())

Async in C# (.NET)

C# pioneered async/await using Task and Task<T> as its future type.

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();

        // Start both downloads concurrently
        Task<string> a = client.GetStringAsync("https://example.com");
        Task<string> b = client.GetStringAsync("https://dotnet.microsoft.com");

        string[] pages = await Task.WhenAll(a, b);
        Console.WriteLine($"Downloaded {pages.Length} pages");
    }
}

How async/await Works Internally

1. An async function runs normally until it hits an await.
2. If the awaited task isn't done, the function suspends and returns control to the event loop.
3. The event loop runs other ready tasks while the slow operation continues in the background.
4. When the awaited task completes, the event loop resumes the function right after the await.
5. The function continues with the resolved value until it finishes or awaits again.

Why Async Is Faster for I/O

Suppose you have \(N\) independent I/O tasks, each taking time \(t\). Run sequentially (sync), the total time is the sum:

\[ T_{\text{sync}} = \sum_{i=1}^{N} t_i \approx N \times t \]

Run concurrently (async), they overlap, so the total is close to the single longest task:

\[ T_{\text{async}} \approx \max_{1 \le i \le N} t_i \]

For many similar I/O-bound tasks, async can reduce total wait time from \(N \times t\) down to roughly \(t\).

When to Use Async (and When Not To)

Best Practices

Common Mistakes

Interview Questions

Quick Revision