Comme il est très simple, son apprentissage est relativement intuitif, bien que la documentation soit quelque peu
technique par moments.

## `async` and `await` { #async-and-await }

Modern versions of Python have a very intuitive way to define asynchronous code. This makes it look just like normal "sequential" code and do the "awaiting" for you at the right moments.

When there is an operation that will require waiting before giving the results and has support for these new Python features, you can code it like:

```Python
burgers = await get_burgers(2)
```

Então em algum momento, é finalmente sua vez. Você vai ao balcão, pega seus hambúrgueres e volta para a mesa.

Você e seu _crush_ comem os hambúrgueres e aproveitam o tempo. ✨

---

Imagine que você seja o computador / programa nessa história.

* **Código Asíncrono**
* **`async` y `await`**
* **Coroutines**

## Código Asíncrono

El código asíncrono simplemente significa que el lenguaje 💬 tiene una forma de decirle a la computadora / programa 🤖 que en algún momento del código, tendrá que esperar que *otra cosa* termine en otro lugar. Digamos que esa *otra cosa* se llama "archivo-lento" 📝.

Jusqu'au moment où c'est (enfin) votre tour. Vous allez au comptoir, récupérez vos burgers 🍔 et revenez à votre table.

<img src="/img/async/concurrent-burgers/concurrent-burgers-06.png" class="illustration">

Vous et votre crush 😍 mangez les burgers 🍔 et passez un bon moment ✨.

<img src="/img/async/concurrent-burgers/concurrent-burgers-07.png" class="illustration">

    }

    @Override
    public void store(final OutputStream out, final String comments) throws IOException {
        getProperties().store(out, comments);
    }

    @Override
    public void store(final Writer writer, final String comments) throws IOException {
        getProperties().store(writer, comments);
    }

    @Override

// printed.
func (f *File) ParseGo(abspath string, src []byte) {
	// Two different parses: once with comments, once without.
	// The printer is not good enough at printing comments in the
	// right place when we start editing the AST behind its back,
	// so we use ast1 to look for the doc comments on import "C"
	// and on exported functions, and we use ast2 for translating
	// and reprinting.

        int[] versionMajors = { 6, 10, 10 };
        int[] versionMinors = { 1, 0, 0 };
        int[] serverTypes = { 0x00000801, 0x00000809, 0x0000101B }; // Various server types
        String[] comments = { "Workstation", "File server", "Domain Controller" };

        // Set converter and number of entries
        setConverter(response, 0);
        setNumEntries(response, numServers);

## Imagens de contêiner

Docker tem sido uma das principais ferramentas para criar e gerenciar **imagens de contêiner** e **contêineres**.

caso, seria melhor ter apenas 2 servidores e usar uma porcentagem maior de seus recursos (CPU, memória, disco, largura de banda de rede, etc).

Por outro lado, se você tem 2 servidores e está usando **100% da CPU e RAM deles**, em algum momento um processo pedirá mais memória, e o servidor terá que usar o disco como "memória" (o que pode ser milhares de vezes mais lento), ou até mesmo **travar**. Ou um processo pode precisar fazer alguma computação e teria que esperar até que a CPU esteja...