Async/await I - Brief history of async/await

1. Early Days: Callback Hell (Pre-async/await)

Before async/await, asynchronous programming relied heavily on callbacks, leading to “callback hell” or “pyramid of doom”, making code difficult to read and maintain.

Example (Callback Hell in JavaScript)

function fetchData(callback) {
    setTimeout(() => {
        callback("Data received");
    }, 1000);
}

fetchData(data => {
    console.log(data);
    fetchData(nextData => {
        console.log(nextData);
        fetchData(finalData => {
            console.log(finalData);
        });
    });
});

Problems:

• Nested callbacks make it hard to read and debug.
• Hard to handle errors properly.

2. Promises & Futures (Improvement, but Still Complex)

To improve callback-based async programming, Futures (Java, Python) and Promises (JavaScript) were introduced.

Example (JavaScript Promises)

fetchData()
    .then(data => process(data))
    .then(result => save(result))
    .catch(error => console.error(error));

Improvements:

• ✅ Avoids deeply nested callbacks.
• ✅ Provides .catch() for error handling.
• 🚫 Still requires chaining and manual state management.

3. async/await Introduced in Different Languages

The async/await pattern was developed to make asynchronous code more readable by eliminating explicit callbacks and promise chaining.

🔹 C# (2012, .NET 4.5)

• Microsoft introduced async/await in C# 5.0 (2012) to simplify asynchronous programming with Task<T>.
• It was implemented using a compiler-generated state machine.

Example in C#

static async Task Main()
{
    Console.WriteLine("Start");
    await DoWorkAsync();
    Console.WriteLine("End");
}

static async Task DoWorkAsync()
{
    Console.WriteLine("Working...");
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

• ✅ Looks like synchronous code
• ✅ No callbacks required
• ✅ Exceptions handled with try-catch

🔹 Python (2015, Python 3.5)

• Python introduced async and await in Python 3.5 (2015).
• Uses coroutines (asyncio) and event loops.

Example in Python

import asyncio

async def do_work():
    print("Working...")
    await asyncio.sleep(1)
    print("Done!")

async def main():
    print("Start")
    await do_work()
    print("End")

asyncio.run(main())

• ✅ Works with event-driven systems
• ✅ Avoids callback hell

🔹 JavaScript (2017, ES8)

• JavaScript added async/await in ECMAScript 2017 (ES8).
• Built on top of Promises, but makes code more readable.

Example in JavaScript

async function fetchData() {
    console.log("Fetching...");
    let data = await fetch("https://api.example.com/data");
    console.log("Received:", await data.json());
}
fetchData();

• ✅ Works with event loops
• ✅ Cleaner than Promises

🔹 Java (2015, CompletableFuture) & (2022, Project Loom)

• Java has supported CompletableFuture since Java 8 (2014) for async tasks.
• Java 21 (2023) introduced Virtual Threads (Project Loom) to simplify async execution.

Example in Java (Using Loom)

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> doWork());
}

• ✅ Improves concurrent execution
• ✅ No need for callbacks

4. Summary of async/await Evolution

Why async/await Became So Popular?

• ✅ Improves Readability – Looks like synchronous code.
• ✅ Avoids Callback Hell – No nested callbacks.
• ✅ Better Error Handling – Uses try-catch for exceptions.
• ✅ Optimized Performance – Efficient async execution in multi-threaded and event-driven environments.