Real time Kong Gateway Configuration For Kotlin Applications

(DRAFT) Kotlin allows us to create beautiful, easy-to-read, and generic code in different ways. In this session, we will have a look at the different ways Kong can provide extra features to our Kotlin applications. We will have a look at quick examples of how these features can be implemented in the back-end via Kotlin and how some of these features can work together with Kong. The highlights are how can we access our application via OAuth2 with a pure Kotlin implementation or via Kong, apply rate-limiting, and use StatsD, CORS, and metric analytics with Prometheus and Moesif API. This session intends especially to show how can we, with services implemented with Spring and/or Micronaut and Kotlin, can get an optimal workflow between our applications, Kong, and the outside world. Further, we will also see, with examples, how can we get this configured in real-time with an angular administration application, speaking to our own Kotlin implemented back-end service in Spring. For example, we will see how can we limit traffic to an application and visualize that with Locust in real-time, and observe how traffic easily gets limited at a push of a button with our own custom application.

Collecting events from an Event Stream in Kotlin

(DRAFT) The Kotlin language allows us to easily create streams where events can be emitted and then collected via, for example, REST endpoints. In this session we'll take a look at examples of how to work with event streams in Kotlin, how can we apply algorithms with it, and make it work within a Spring Framework environment.

Event Streaming in the context of Kotlin Reactive Web Applications

Event streaming is not a new concept. Coroutines are also not a new concept. However, these two concepts, together, are only now being widely used and considered for new developments and updates of old applications. Kotlin provides a way to implement applications in a reactive way using coroutines, and implementing event streams. We will have a look at different running application examples and how they can respond to event triggers, how they can digest event messages and how that plays out in terms of performance. We will also draw a few comparisons to understand how a reactive architecture works.

From command line to Spring Native - Working with the Kotlin-Native compiler and GraalVM

This session is about Native Development.

Kotlin Streams Potentially Good and Potentially Bad Ideas

In the last 5 years, we have not seen such a sophisticated and fast evolution of technology as the one Kotlin is going through. Such a speed in evolution can lead us sometimes to think that Kotlin can do anything including replacing external event streaming / queueing systems such as Kafka and RabbitMQ. In real life, this remains something that we must decide by considering what we want to implement. In this session, we'll have a look at the pitfalls of event streaming using pure Kotlin code, where this can be used, and when we definitely need to use an external event streaming system.

Making a Distributed Cache System with Hazelcast with combined Data processing in Kotlin

Working with a distributed cache system provides leverage to make applications faster by avoiding too many database operations. Not only that, but a cache system can also play a crucial role in avoiding unnecessary repeated calculations. In this session, we're going to go to the insides and outs of data processing in Kotlin with generics, flow, data streams, and a couple of surprises, to get systems optimal. We're going to have a look at a fictional banking system and have a look at different situations where crucial decisions can be made to allow our Bank to be efficient and still remain reliable in reaching an optimal SLA. This session combines a thorough review of data processing in Kotlin and how can we apply it considering a distributed cache system like Hazelcast. We'll have a look at data grids and how can we populate them efficiently using Kotlin as the backbone of our services.

Lightning development times using Kong's own Unirest Library

Developing a REST client can be very easy but in some cases, it can be a very daunting experience. In this session, I will bring in a complex REST application service and a Kong gateway portal and we'll experience together and live how the development of a client can be done quite fast with increasing complexity with the Java Unirest Library. The code will be developed in Kotlin for the client whereas the service will be already available running in the background.

Could Virtual Threads cast away the usage of Kotlin Coroutines? What experience can tell us

Kotlin coroutines have been around since 2017 and have contributed to defending the usage of Kotlin in everything from Android development to multi-platform, to developing highly available and resilient services making optimized use of resources, and allowing threads to be available as soon as possible. The use of coroutines also implicated the usage of context and scopes, which for many became complicated abstract concepts. And then Java 21 was released in 2023 and while researching and applying this at work I realized that in some places, it makes sense to remove the usage of coroutines and replace them with virtual threads. On the other hand, in other places, the usage of Kotlin coroutines seems to remain justified.
In this session I will talk about funny examples and real-life problems that I found on the field, why did they occurred, and how I solved them. We may find a common ground between Java Virtual Threads and Kotlin Coroutines, or maybe not.
After this session, you will come out with a different understanding of what Kotlin Coroutines and Java Virtual Threads have to offer. You'll be able to make better-informed decisions on how both work, so that you can independently suggest solutions in your team, at work, or on your own time.

This session has examples and may introduce some live code running examples. However code may be shown during the presentation, there is no expectation to make live code changes.

Integrating Arrow Optics in a Real Life Scenario, my personal life experience in a parallel world

I work in The Netherlands and there we have been using arrow optics for a while and it is more than amazing. I want with this talk to share my experience but instead of talking Telecom, I want to include this talk in the context of a spaceship and the data transmission to talk with the systems in that spaceship. I cannot of course show code of any company I have been and so, to share my knowledge and experience I will create a space ship scenario. For that I will use the Spring Framework as an example for services completely implemented in Kotlin, with a R2DBC database and completely reactive. My experiences should raise the curiosity and hopefully avoid seeing people make mistakes with arrow and explain what it is, what it is not, and it can be.

Kotlin Mysteries found from years working with Kotlin

Kotlin can be very handy and easy to use. Kotlin offers the possibility to develop code that is easy to understand, safe, immutable, and thus predictable and follows standards that avoid side effects. I realized that very quickly after I started my Kotlin journey that already amounts to more than 4 years.

Having said that, some concepts can be difficult to visualize which can generate some confusion. While there are several advantages to using Kotlin, those advantages can only be put into practice if we can understand what the JVM is doing to our code. There are situations that may seem to question of non-nullable mark offered by Kotlin, others where you'll find functionalities that may seem to serve no purpose at first glance and if you are coming from the Java world you may find confronting the concept of specifically tail-recursive fuctions and its usages. All of these situations have created some confusing situations professionally, generating delays in development, that could have been mitigated if we had previous clear understanding of these concepts.

In this presentation, we are going to have a look at what tailrec, inline, crossinline, nullables, non-nullables do to our code, how the JVM responds to that, and how annotations affect behavior in the Kotlin code for web application services frameworks like the Spring Framework. We'll also have a look at what happens when a non-nullable becomes null in Kotlin and why that happens. You' ll leave this session with these mysteries behind you and ready to face the engineering world with Kotlin by your side whether you venture into android or server side development.

Creating an elevated developer experience

DRAFT