How was asynchronous code implemented in programming languages before the introduction of the async/await construct?

Before the introduction of the async/await construct, asynchronous code in Python and other languages was implemented using several approaches:

• Callbacks — functions passed as arguments that are called upon completion of an asynchronous operation. This approach often leads to "callback hell" — deep nesting and complex readability.

• Generators and coroutines — in Python, before async/await, generators with yield were used to pause and resume function execution. For example, the tornado library used this approach.

• Futures and promises — objects representing the result of an asynchronous operation that can be processed later.

• Event loops — for example, in Python, the asyncio library initially used an event loop and coroutines with yield from before the introduction of async/await.

An example of using generators for asynchrony before async/await:

import asyncio

def coroutine():
    print('Start')
    yield from asyncio.sleep(1)
    print('End')

loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine())

Thus, async/await simplified the syntax and made asynchronous code more readable and similar to synchronous code.