Chapter 1, An Introduction to Reactive Programming, discussed in detail the principles of event-driven programming and reactive programming. As explained in the previous chapter, event-driven programming can be implemented in many ways: with different programming paradigms such as imperative or object-oriented, but also with different concurrency mechanisms. Asynchronous programming is one way to manage concurrency.

Concurrency is several tasks competing for the same resource at the same time. The definition of "at the same time" can be different depending on the resource being used. There are two main resources that a task may require: a Central Processing Unit (CPU) and I/O. In most cases, a task is either CPU bound or I/O bound; that is, either a task makes a lot of computations and is constrained by the available CPU resources,...

Since the early days of Python, it has always been possible to do asynchronous programming, but in the old way; that is, by using callbacks. Chapter 1, An Introduction to Reactive Programming, already explained some of the evolution in the frameworks and programming languages that made asynchronous programming easier during the last few years. The Python language naturally followed that trend, and many incremental improvements have been made since the early 2000s. Figure 2.4 shows the history of the main changes that occurred in Python concerning asynchronous programming.

The evolution on the left side are the elements that are still part of Python. The evolution on the right side concerns asynchronous frameworks and one deprecated module of the standard library:

AsyncIO is the official asynchronous framework for Python. As explained in the previous section, this does not mean that it is the only one available. Twisted and Gevent are two other asynchronous frameworks that are very famous. However, since its release in Python 3.4, AsyncIO has become very popular rather quickly. There is no doubt that one reason for this success comes from the philosophy of Python: There should be only one obvious way to do something. Since AsyncIO is part of the standard library, it is the de facto way to do asynchronous programming in Python. Another reason is probably that it was released with the correct timing, when developers regained interest in asynchronous programming.

AsyncIO relies on three entities:

• Futures: They represent values that will be available later
• Coroutines: They allow you to execute asynchronous actions
...

This section details a simple but realistic implementation of an asynchronous network service: an echo HTTP server. The behavior is the same as in the reactive echo server implemented in Chapter 1, An Introduction to Reactive Programming, but instead of echoing the command-line arguments, the server sends back the requests it receives on an HTTP request.

The AsyncIO library does not contain an HTTP stack. In this example, as well as throughout this whole book, the aiohttp package will be used. The aiohttp package is a complete implementation of the HTTP 1.x protocol with the support of web sockets. It can be used to implement clients and servers. This is a great package to implement HTTP microservices...

This chapter covered all the base concepts of asynchronous programming and how they work in Python. You should now understand what it means to yield or await a coroutine and know the differences between blocking and non-blocking designs. Hopefully, the short history of asynchronous programming in Python and the examples of asynchronous programming with callback also helped you understand why Python is one of the few languages with best-in-class support of asynchronous programming.

Moreover, you should also be familiar enough with the AsyncIO APIs to write your own asynchronous applications. This chapter only covered the basic usage of AsyncIO, but the features presented here are the most-used ones. Other more advanced features will be introduced in this book, as they are needed in other examples.

One last word on this chapter: Do not be fooled by the simplicity of the...

• Why is asynchronous programming more efficient than multiple processes/threads to handle I/O concurrency?
• Why is asynchronous programming not a solution to improve the performance of CPU-bound tasks?
• What is the reason why multithreading is not performing as well in Python as in other programming languages?
• What is the benefit of a generator compared to an iterator?
• Why does a generator help in writing asynchronous code?
• What is the difference between calling the next function and calling the send method of a generator object?
• How is a coroutine declared?
• How can a coroutine call another coroutine?
• What is the role of the event loop?

The evolution of the Python language is documented in Python Enhancement Proposals (PEPs). The three main evolution points of asynchronous programming in Python are described in detail in these dedicated PEPs:

• Generators are documented in PEP-255: https://www.python.org/dev/peps/pep-0255/
• Delegating to sub-generators (yield from) is documented in PEP-380: https://www.python.org/dev/peps/pep-0380/
• The async/await syntax is documented in PEP-492: https://www.python.org/dev/peps/pep-0492/

The documentation of the AsyncIO package is in the Python official documentation. Do not hesitate to read it to see all features available with event loops, futures, and coroutines: https://docs.python.org/3/library/asyncio.html.

The documentation of the aiohttp package is very detailed, and contains examples. This package will be used throughout this whole book to write microservices...