zsmb.coEst. 2017











What’s New in Compose Multiplatform - A Live Tour

What if you could just… do iOS development? Kotlin and Compose Multiplatform make it possible! Live coding our way through the evergrowing ecosystem built by JetBrains, Google, and the wonderful Kotlin community, we’ll show you how you can pick and choose well-established tools and libraries that you already know from Android and use them to build cross-platform apps.

Build a Multiplatform Future with Kotlin

Building with Kotlin Multiplatform not only allows you to share code easily, but it also plays nicely with the host platform, so it’s not cross-platform vs native code, but a beautiful collaboration of the two. You also get to choose what you want to share. Start as small as you want with a critical piece of logic, scale it up to an entire application including the UI, or pick anything in between that fits your needs.

Simplifying Build Configuration with Amper

Join us for a tour of Amper, a new build and project configuration tool from JetBrains, designed to make Kotlin project tooling approachable for everyone.

Building with Kotlin for Android and Beyond

A brief overview of Kotlin's history with Android and Multiplatform development.

Kotlin Multiplatform at Stable and Beyond

Kotlin Multiplatform became stable last year, making it ready for production use for anyone looking to share code between platforms. In this talk, we'll take a look at what that announcement means for Kotlin Multiplatform, and how the technology is evolving now, beyond the stable release.

Compose Multiplatform: iOS, Android & Desktop Apps in 100% Kotlin

Kotlin Multiplatform and Compose Multiplatform enable sharing any code you want across platforms, from the networking layer through business logic all the way to the UI! In this talk, we’ll live code a simple app that loads and displays data from an API, from start to finish in 100% Kotlin. We’ll run this app on Android, iOS, and desktop, all without duplicating any code!

Pragmatic Code Sharing with Kotlin Multiplatform

A brief overview of Kotlin's history, and its latest developments in Kotlin Multiplatform, including Compose Multiplatform, Fleet, and some details about how code sharing works across platforms.

Getting Started With KMP: Build Apps for iOS, Android, and Desktop in 100% Kotlin With Compose Multiplatform

Compose Multiplatform for iOS is currently in Alpha, so now is a great time to explore the technology! During this webinar, we will build a simple app from start to finish in Kotlin. In the process, you’ll see how Compose Multiplatform and Kotlin Multiplatform enable sharing everything from the networking layer to business logic and the UI. The end result will be a small app that can load and display different bird pictures from an API that runs on Android, iOS, and desktop.

The State of Kotlin Multiplatform

JetBrains Kotlin Multiplatform (KMP) is an open-source technology designed for flexible cross-platform development. It allows you to develop apps for Android, iOS, desktop, web, and server-side and efficiently reuse code across them, all while retaining the benefits of native programming. After 8 years of development, KMP has been refined into a production-ready technology and is going Stable, which means now is a great time to start using it in your project.

Composing an API the right way

Everyone who writes code using Jetpack Compose designs Composable functions and components all the time. In this talk, we'll take a look at some highlights from the official guidelines around designing Compose APIs, to see how we can do a better job of building with Compose.

Jetpack Compose Roundtable

A roundtable discussion on the state of Jetpack Compose, its success, our experiences, likes and dislikes about Compose.

Android Fireside Chat

The Android Developer Relations team is here to answer your burning questions in a friendly setting.

What’s new in Kotlin for Android

Discover exciting updates coming to Kotlin for Android developers this year, including the upcoming K2 compiler, using KTS for Gradle build scripts, improvements in Kotlin Symbol Processing, and some news about Kotlin Multiplatform.

Avoiding common coroutines mistakes in Compose

Compose and coroutines work great together, but there are certain patterns you need to avoid when combining them. In this session, we’ll look at some common pitfalls, detail why and how they cause problems, and see what patterns or APIs should be used instead.

Composing an API with Kotlin vol. 2

Jetpack Compose is one of the best examples of an exciting Kotlin code base. It’s a real treasure trove of examples for using advanced Kotlin language features and conventions. In this talk, we’ll continue the exploration started in the prequel to learn more best practices around our favourite programming language.

Composing an API with Kotlin

Kotlin offers many powerful language features to API authors. We’ll explore how Jetpack Compose’s syntax builds on these features, and how its APIs were shaped by Kotlin idioms and conventions. These ideas and best practices give you a deeper understanding of the language, and they are valuable for any Kotlin developer designing APIs – which is actually every Kotlin developer!

Untangling Coroutine Testing

Coroutines are embraced on Android as a tool to perform asynchronous operations and manage threading in your apps. Testing them requires some extra work and a solid understanding of scopes and dispatchers. In this talk, we’ll look at how to test coroutines with the latest available testing APIs introduced in kotlinx.coroutines 1.6, from the simplest cases all the way to Flows.

Building Effortless Chat Features with Stream and Compose

Learn what the new Jetpack Compose Chat SDK from Stream offers and how the team built it in just a couple of months.

Git Good with Android Studio

Android Studio is an incredibly powerful tool. One of my personal favourite parts of it is the version control support. In this talk, I'll show you how easy it is to use Git and perform version control tasks in general within Android Studio. No third-party tools required!

Building a production-ready Chat SDK with Jetpack Compose

In this session, we talk about how we built the world's first Jetpack Compose Chat SDK, what challenges we met along the way, and why put so much trust into a technology that only recently became stable. We also talk about the API design and what decisions we've made to allow for both quick-to-integrate default behavior and UI, as well as a rich set of customization options to make the SDK fit your needs.

Creating a Kotlin Course from Scratch

This talk tells the story of mobile development at BME-VIK-AUT, how I joined that story, and how we introduced Kotlin to the university curriculum.

How to Build Awesome Android Libraries

This talk is a collection of advice about building Android libraries or SDKs, highlighting some of the less obvious things you can do to make your library great.

It’s Compose O’Clock on Android

Jetpack Compose is changing how UI is being built on Android. This new toolkit is replacing the now 10-year-old, somewhat tedious View system with a declarative, functional approach, and promises to simplify and speed up UI development. This session explains what Jetpack Compose is, and then shows a quick example of interesting UI with it.

Mastering API Visibility in Kotlin

When designing a library, minimizing your API surface - the types, methods, properties, and functions you expose to the outside world - is a great idea. This doesn't apply to just libraries: it's a consideration you should make for every module in a multi-module project. In this talk, we'll look at all the ways that Kotlin lets you get your visibility just right.

Krate ft. Moshi

Krate is a SharedPreferences wrapper library based on Kotlin's delegates. This talk takes you on a journey where you'll learn how the new Moshi-based addon for the library was implemented. We'll touch on type erasure and reflection, testing, debugging, and various advanced Kotlin features along the way.

Android Complexity

Android development can often feel overwhelming – there’s so, so many things to take care of around a single app. Here’s a brief look at all the things* that an Android developer would have to consider, do, and test for in order to create the theoretically perfect application, to serve as a practical checklist for starting your next Android project.

Become a Pro in Android Studio

A tips and tricks session on making the most out of our best friend - and sometimes worst enemy - Android Studio.

Handling View State and Events with RainbowCake

RainbowCake is an architectural framework built on top of the best & latest of Jetpack and Kotlin. One of its core features is its view state and view event handling mechanism, which is somewhere between MVVM and MVI, and is powered by LiveData. In this talk, we’ll first look at the client side API of the framework, and the design decisions that went into it. Then, we’ll dive into how all of this is implemented under the hood by customizing LiveData. While the talk discusses this specific framework, the ideas in it are universal and can be used independently in any project.

Say “hi” to Moshi

JSON serialization is an everyday task for Android developers, but it's still not a trivial one. Long used solutions such as Gson have serious pain points, especially when using them with Kotlin. Could Moshi be our saviour when it comes to dealing with JSON on Android? We'll look at how to use it, what problems it solves, and how nicely it plays with our favourite JVM language.

Idiomatic Kotlin

'Idiomatic' is a word often used by Kotlin experts to describe elegant patterns or solutions that make excellent use of Kotlin's features. Let's turn this attitude around for a change, and have some fun by taking a look at the worst ways you can twist and abuse language features to take shortcuts, create tricky solutions, achieve exciting syntax, or confuse others who dare enter your codebase.


Kotlin has many features that are leaps and bounds ahead of Java. However, its primary target platform being the JVM, all of these features still need to compile to the same bytecode as Java does. This is a look at how a variety of interesting Kotlin features are compiled to bytecode, and what their Java equivalents would be. Even though Kotlin abstracts away much of the virtual machine and the original feature set of Java with its own features, it’s still important to know what your Kotlin code compiles to. Not only can this knowledge give you the power to optimize your code, but it will also help you avoid subtle bugs that would otherwise be near impossible to track down.

Reviewing Kotlin

I have been teaching our rapidly growing team of Android developers Kotlin for about a year, and for the last few months, I’ve been reviewing tens of thousands of lines of code written by almost a dozen people at times. Here’s what we’ve found out together about learning, teaching, and reviewing Kotlin. I’ll tell you what worked for us and what didn’t, so that you may be more prepared for this path than we were. I’ll also point out some of the issues that most often arose in the code while our developers were getting familiar with the language.

Tweaking LiveData

LiveData is a well-known tool by now, 2 years after its initial release. Let's take a brief look at what it does, and then see how we can create custom implementations - as well as test them!"

Delightful Delegate Design

When developing a library, designing an easy to use API while hiding unnecessary implementation details from clients is fundamental. This talk and article looks at some of the API design choices we've made for our library Krate, an Android SharedPreferences wrapper.

Android app architecture powered by Jetpack & Kotlin

A 3+ hour workshop first introducing coroutines and some Jetpack architecture components, then showcasing an app architecture built on the aforementioned technologies. Then, showing how this architecture can be used in practice with a half-complete example application built using that architecture that can be developed further during the workshop.

Typical Kotlin

The talk covers some of the basic built-in types of Kotlin (Any, Unit, Nothing), and how we interact with these types - whether we know it or not - when using basic constructs (the Elvis operator, return statements, null itself) of the language.

Android KTX

A lightning talk showing off some of the syntax gains that Google's Android KTX library offers.

Top 10 Kotlin Stack Overflow Questions

A selection of some of the most frequent questions about Kotlin on Stack Overflow, asked, answered and explained. Something in there for everyone, from beginners to experts.

DSL Design

A talk presenting the basics of what a DSL is, what use cases there are for them, and looking at some of the design choices we can make while creating one.

A Taste of Kotlin on Android

An introductory talk on Kotlin prepared right before Google made it an official language on Android. A brief history of where the language comes from, what benefits it offers, and many examples of its syntax and features.