Initially, I was skeptical about the Kotlin Multiplatform Mobile talk because it sounded like I would hear only about the basics. But the reality turned out to be a whole different story.
This blog post is by Łukasz Kasprzyk, Android Developer from Tooploox, Kotlin enthusiast, and die-hard football fan.
The 18th of May, 2022, will remain in my memory for a long time. Why is that, you ask? There are two reasons: the first and main reason is that on that day I went with my Android Teammates for our first offline conference – Kotlin Dev Day in Amsterdam. The second reason is that this conference took place at Ajax Amsterdam – Stadium Johan Cruijff Arena – for me, as a huge football fan, it was an awesome experience.
After we landed in Amsterdam we went from the Airport to our hotel. And, as we saw, it was around 100 meters from the stadium, a very nice spot.
The Conference doors opened at 8 am and the first talk was scheduled for 8:30, so we arrived punctually.
We needed to go to the 4th floor via escalator, on each floor we could see some crucial moments of Ajax’s history on many banners:
On the 4th floor, we went to queue for our badges and to get some details about the conference rooms, where they were, etc.
When I realized that this conference was taking place in the Stadium, I was expecting that we would be inside the Stadium building and in some inner conference rooms, but when we started exploring I saw that the Pitch was open and we could see it, but when I entered the tribune I was stunned. The whole Pitch was open for us to see, but the best part was that The Pitch was an actual stage (one of three) called “The Pitch” and we were sitting on leather seats.
In the main hall, there were booths for companies who were sponsoring the conference.
“What should I use” instead of “why should I use it” and Kotlin Multiplatform Mobile (KMM)
The intro and first keynote talk were on the Amsterdam Stage – “The Silver Bullet Syndrome Part 2 – Complexity Strikes Back!” By Hadi Hariri. Mister Hadi was very charismatic and made a lot of situational jokes during his talk. The talk was, as he described, the second part of two but I didn’t feel it was necessary to have seen the first to get the benefits of the second.
He started with Web Development history through Gradle and KMM, starting from the development itself through build, deployment, and security.
The main question and thesis of his talk were: What should I use instead of why should I use it.
The main takeaway was: Complexity comes at a cost.
The next talk took place on the third stage, called the Vienna Stage, and was about the topic I personally came to this conference to discuss: KMM. Piotr Prus – our countryman – hosted a talk called “Meet Kotlin Multiplatform Mobile (further referred to as KMM.)” Initially, I was skeptical about this talk because it sounded like I would hear only about the basics.
But Piotr held a talk that I wasn’t expecting: about how they adopted KMM in their company and made it production available. After the talk, I approached him and we had a very interesting chat about our experience with KMM. Unfortunately, his talk was only 25 min long and he had materials for over 40 minutes but we exchanged our opinions and we told ourselves we’d catch each other later.
Composing an API with Kotlin
As the schedule was tight and I was already late I needed to run to the next and the best stage – The Pitch, where Marton Braun started giving the talk “Composing an API with Kotlin.” He started from a Compose introduction, going through Extension Functions, Modifiers, Naming Conventions for VALs (Read-only local variable) in Compose, Scopes inside Compose, Inline classes, and finally Coroutines in Compose. It was nice to go through Compose from an inside perspective.
After this talk, we had a coffee break where organizers provided some hot beverages and sandwiches.
With new energy, I went back on the Pitch to hear “Kotcha!” by Jeroen Rosenberg. This talk was actually something different, as after the introduction Jeroen held a Quiz. It was about Kotlin and some very catchy cases of usage. I took part and made the top 10, which pleased me.
For first place, there was a price of a hoodie for speakers with the logo of the conference.
I had some spare time before my next planned session began, so I stayed for a while on the Pitch to listen to “Hexagonal architecture with Kotlin,” by Jan Verhoeckx. I was there only for 10 minutes but the talk looked interesting, as Jan was talking about information leaking between layers and how to avoid it.
Concurrency made easy with Kotlin Coroutines
From there I went to hear more about Coroutines in “Concurrency made easy with Kotlin Coroutines” with Ricardo Lippolis.
He started with what Coroutines are in general, and later went through how to suspend working functions. He went through Context and how to propagate errors, continuing with Dispatchers and Global scope usage, and finished off with runBlocking and how to use it.
After this talk, there was a lunch break, where we could grab some hot meals and spend some time exploring the sponsors’ booths.
Shoulders of Giants – Languages Kotlin learned from
After the break we went back to the best place ever – yes the Pitch – where Andrey Breslav talked about the “Shoulders of Giant – Languages Kotlin learned from.” It was actually awesome to hear about how the language I’m using right now was designed directly by the creator! I heard there how the whole process looked, which languages were the inspiration for Kotlin with examples, and why given decisions were made (one of the best talks there).
Later on, I moved on to the Vienna stage for the next two talks about the main topic of concern: KMM.
The first one was “Introducing Kotlin Multiplatform in an existing project” by Marco Gomiero – where he explained how to make a KMM library by yourself, distribute it to Maven on Android or XFramework on iOS, and use it in an existing project.
The second was called “Multiplatform success stories (and fuck ups)” with Liliia Abdulina (Lead QA on the KMM Team) – Liliia went through cases of 5 companies who used KMM from the beginning and showed all the pros and cons they provided, this was very useful for me personally as I’m introducing KMM in our company and what better way to learn than by the mistakes of others.
After this, there was the third and final afternoon break with some snacks.
Then, on the Vienna stage, Khaleel Freeman held a talk on “Adopting Jetpack Compose” all about the challenges he and his team faced when introducing Compose with the assumption of launching fast and iterating quickly.
Plugin and Play
Two final talks took place on The Pitch.
The first one was “Plugin and play” with Simone de Gijt, in which she covered some of the libraries which could help us develop, like Kover, Ktlint, and Detekt – with live demos. An interesting takeaway for me was to use the Android Studio plugin with Ktlint for live checks.
The final closing talk was from James Ward (Kotlin Product Manager at Google) with “James’ Top 5 Kotlin Things to Get Excited About in 2022.”
James also made a small online live questionnaire about us – the participants – on what technologies we use, etc.
He presented his top 5 for 2022:
- Inner Loop Dev: Server-side
- Testcontainers
- Incremental Compiler
- Inner Dev Loop: Live Preview
- Kotlin Multiplatform
Unfortunately, there was no hot news or spoilers but he gave us some sneak peeks. The whole conference wrapped up with some networking.
Kudos to the organizers for how it all was arranged, the place, the talks, the speakers, and everything around. If there will be the next edition I will definitely take part! Maybe next time, I will have something to tell about KMM.
