new Object() {
          @Subscribe
          public void eat(Object food) {
            objectEvents.add(food);
          }
        };

    List<Comparable<?>> compEvents = new ArrayList<>();
    Object compCatcher =
        new Object() {
          @Subscribe
          public void eat(Comparable<?> food) {
            compEvents.add(food);
          }
        };
    bus.register(stringCatcher);

        new Object() {
          @Subscribe
          public void eat(Object food) {
            objectEvents.add(food);
          }
        };

    List<Comparable<?>> compEvents = new ArrayList<>();
    Object compCatcher =
        new Object() {
          @Subscribe
          public void eat(Comparable<?> food) {
            compEvents.add(food);
          }
        };
    bus.register(stringCatcher);

### Burger Conclusion { #burger-conclusion }

In this scenario of "fast food burgers with your crush", as there is a lot of waiting 🕙, it makes a lot more sense to have a concurrent system ⏸🔀⏯.

This is the case for most of the web applications.

Many, many users, but your server is waiting 🕙 for their not-so-good connection to send their requests.

And then waiting 🕙 again for the responses to come back.

Ama *eşzamanlılık* ve *paralellik* arasındaki ayrıntılar oldukça farklıdır.

Farkı görmek için burgerlerle ilgili şu hikayeyi hayal edin:

### Eşzamanlı Burgerler { #concurrent-burgers }

Aşkınla fast food almaya gidiyorsun, kasiyer senden önceki insanların siparişlerini alırken sıraya giriyorsun. 😍

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

Le fast-food a 8 processeurs (serveurs/cuisiniers) 👨‍🍳👨‍🍳👨‍🍳👨‍🍳👨‍🍳👨‍🍳👨‍🍳👨‍🍳. Alors que le fast-food de burgers concurrents en avait 2 (un serveur et un cuisinier).

Et pourtant l'expérience finale n'est pas meilleure 😞.

---

### Parallele Hamburger { #parallel-burgers }

Stellen wir uns jetzt vor, dass es sich hierbei nicht um „nebenläufige Hamburger“, sondern um „parallele Hamburger“ handelt.

Sie gehen los mit Ihrem Schwarm, um paralleles Fast Food zu bekommen.

Sie stehen in der Schlange, während mehrere (sagen wir acht) Kassierer, die gleichzeitig Köche sind, die Bestellungen der Leute vor Ihnen entgegennehmen.

    val rootCa =
      HeldCertificate
        .Builder()
        .serialNumber(1L)
        .certificateAuthority(1)
        .commonName("root")
        .build()

    // Add a good intermediate CA, and have that issue a good certificate to localhost. Prepare an
    // SSL context for an HTTP client under attack. It includes the trusted CA and a pinned
    // certificate.
    val goodIntermediateCa =
      HeldCertificate

        assert response.status_code == 200
        assert response.json() == {"message": "all good?"}


def test_broken_return_finishes():
    client = TestClient(app, raise_server_exceptions=False)
    response = client.get("/broken")
    assert response.status_code == 200

The same way, there are many compatible tools. Including code generation tools for many languages.

## Pydantic { #pydantic }

All the data validation is performed under the hood by [Pydantic](https://docs.pydantic.dev/), so you get all the benefits from it. And you know you are in good hands.

You can use the same type declarations with `str`, `float`, `bool` and many other complex data types.

    tester.forAllPublicStaticMethods(GoodSerializableFactory.class).testSerializable();
  }

  public static final class GoodSerializableFactory {
    public static Object good(Runnable r) {
      return r;
    }

    public static Object good(AnInterface i) {
      return i;
    }

    private GoodSerializableFactory() {}
  }

  public void testSerializableOnReturnValues_bad() throws Exception {