Which talk would *you* want to see at Kafka Summit

I did talk about using Kafka with GraphQL at GraphQL summit. Now I would like to go speak at Kafka Summit as well. You can help by telling which of the three proposals I had in mind, you would like to see most. Also you should submit as well.

Here they are:

Expose your Kafka using GraphQL

GraphQL is a relatively new way to describe API's and offers subscriptions. Subscriptions are a way to send a stream of updates to the client. Often they are implemented using web sockets, which makes it hard to scale.

I will explain a solution by using a demo application, which is a bank simulation. Also I will share some benchmarks to prove the scalability. This will be done mainly using Clojure, but I also implemented the GraphQL endpoint in Java, Kotlin, and some other languages.

The demo project also contains a load test, which can be used on all the implementations in order to compare them.

From Avro to GraphQL, blazingly fast

Rust is called a system programming language but it's getting more and more use-full as the ecosystem grows. As it's strongly and strictly typed it should be possible to derive both the internal needed data structured to handle binary data based on Avro schema's and to derive a GraphQL schema which can be used by frontend applications.

I will share the results of this journey, with at least some demo, and if all goes well a docker image that can be used to easily interact with Kafka using GraphQL.

Using the Confluent Schema Registry with Rust

In this talk I will go into some of the challenges I faced making a Rust library that is as much as possible similar to the Java serializers. There are a couple of challenges here.
There is no default way of adding serializers with consumers and producers. Another thing is that there is no classpath in Rust to dynamically create specific class instances. Also it turned out the Avro library for Rust didn't support all complex types well.
That being said there are some advantages to using Rust. Like the memory safety, fast startup times, and being able to build very tiny Docker images.