Modern Mobile UI Development: Into the Multiverse

Choosing the right UI framework is critical to balancing user experience, development speed, and maintainability of your product. This is an exploration of the latest tools of the trade in mobile UI development, focusing on native UI frameworks like SwiftUI and Jetpack Compose along with cross-platform frameworks like React Native, Flutter, and MAUI. Through practical use cases—whether for individual developers, small teams, or large enterprises—this session provides insights into each framework's specific strengths and trade-offs. Learn about the key advancements in declarative programming paradigms, unidirectional dataflow, and reactive state management, as well as the trade-offs developers face when balancing native and cross-platform experiences. Be well-informed and gain a clearer understanding of when and why to prioritize native features or cross-platform efficiency, in the context of consumer-facing apps or internal business tools.

Choose Your Own Design Patterns in Kotlin!

Readers beware! You choose the object-oriented design pattern that we will dare! This interactive "myth-buster-esque" talk will take you through a haunted mansion of object-oriented Java design patterns from the book "Gang-of-Four" and debunk the myths of their relevance with Kotlin.

You (in the audience) will vote to choose where they would like to go. Wanna go to the kitchen to look at the cake builder and learn about the Builder Pattern? Turn to page 15. Perhaps you want to visit the friendly ghost lurking in the basement and learn about the Visitor Pattern? Turn to page 42. Or you could help with some housekeeping and accidentally shock yourself trying to plug in the vacuum while learning the Adapter Pattern? Turn to page 77.

OOP design patterns have haunted many legacy code bases over the years, and folks moving to Kotlin from Java tend to bring these ghosts along. Time to put on the proton pack and zap some of these ghosts from the past and debunk the orthodoxy.

My previous talk that this talk will build upon
https://www.youtube.com/watch?v=i7dHrLej2bg

Server Composables! Moving your screen logic to the server with kotlinx-rpc

Square's Molecule library lets you model complex screen logic to state-flows with Jetpack Compose. But did you know that you can stream these state-flows over WebSockets with kotlinx-rpc? This combination of libraries lets you move your screen logic over to the server and build "Server Composables".

But why? What is the advantage of moving this logic to the server in the first place? Is it worth switching over to WebSockets? Wouldn't we lose our screen state when our network goes down? These are some of the questions that will be answered in this session.

Building Your Own Opinionated Navigation Library with Decompose

Navigation is a core functionality in modern mobile apps. But what happens when existing navigation libraries don't quite fit your needs? This talk explores the concept of building your own opinionated navigation library using Decompose, a Kotlin Multiplatform navigation library for Jetpack Compose and other UI toolkits.

First off, we’ll explore the why? We'll delve into the fundamentals of navigation in mobile apps, covering concepts like state management, screen composition, passing argument and returning results, and different navigation models we often see on apps. We'll then explore platform-specific challenges you'll encounter (like configuration changes on Android and back button behaviour) and the benefits of using a custom navigation library.

Secondly, we’ll explore the What? The core of the talk will focus on Decompose and its capabilities as a navigation library and why you should use it. We'll see how Decompose helps to decompose screens as components, model navigation states as configurations, and expose the navigation state to plug in different UIs. We'll also explore Decompose's approach to animations, allowing for customisation using any UI framework's native APIs.

Finally, we'll see How? With a live demo showcasing a simple app built with Decompose's navigation capabilities.

We will be using Decompose together with Decompose-Router

Arkadii Ivanov is doing this talk on his own capacity, unrelated to his Google employment or role. If accepted, please don't associate any Google logos etc. with his profile. Mentioning in the bio is fine, though. Thank you!

https://github.com/arkivanov/Decompose https://github.com/xxfast/Decompose-Router

App of Theseus: Incrementally Adopting Kotlin Multiplatform!

This is the story of how we incrementally adopted Kotlin Multiplatform to Australia's PSCore public safety platform that helps frontline officers in keeping communities safe. A story of how we overcame challenges in threading the needle between a rewrite and a refactor. It is a story of challenges in fighting the tools and expanding the breadth of technical skills. A story that took over 2 years in making while sharing business logic and shared infrastructure between Android, iOS, desktop and the web.

Compose, Compose Everywhere!

Did you know that you can run Compose almost anywhere? In this interactive session, we'll take a look at how we use Compose to share 99% of UI, how we use Compose to share presentation logic between Android, WearOS, Desktop, iOS, Web and CLI clients, and how we use Compose in a backend server to streamline updates to a database.

This talk is a deep dive into how Compose UI can be used to create beautiful UIs that can be shared between mobile clients or create specialised UI for form factors like smartwatches or tablets. We'll discuss the benefits and challenges of using Compose for multiplatform development. Learn new concepts and use new frameworks to solve tough challenges and provide practical examples and tips for making the most of this powerful UI toolkit.

This talk will also explore how Compose can be applied outside of UI. We'll take a look at how we use Compose runtime to model screen states in order to share presentation logic between Android, WearOS, Desktop, iOS, Web and CLI clients - so that we can write our presentation logic once and share it between different client applications and let them present that information however they want. We will also take a quick look at how we use Compose runtime on the backend to event source and streamline updates to a database.

Whether you are a new Android developer looking to expand your skill set, or a veteran developer seeking to learn about an upcoming shared UI solution, this talk is for you. Join us and discover the power of Compose for building beautiful, responsive UIs across multiple platforms!

Design Patterns Need Not Apply

With Kotlin, some of the object-oriented design patterns from The Gang of Four - no longer need to be applied. The GoF design patterns were initially introduced to address issues due to technical limitations in the context of C++ & Java. In contrast - Kotlin was designed ground-up keeping these same problems and limitations in mind - so much so that Kotlin has solved the same issues by using the language rather than relying on developers to implement a pattern after the fact.

This "myth-buster-esque" presentation will take a closer look at some of the creational, structural and behavioural design patterns from the GoF book. Specifically, we will be deconstructing the factory, builder, and prototype patterns; destructuring adapter, proxy, and decorator patterns; breaking apart the visitor and mediator patterns. There are many more patterns to go through but these are the most controversial ones we have the time for.

This presentation will challenge the orthodoxy and deep dive into the "why". For each pattern, we will be taking a look at what the problem is first. Only then, we will take a look at how the GoF design pattern intends to address the said problem. Afterwards, we will critique the pattern, assess the need for such a pattern and discuss whether this problem even exists in the context of Kotlin.

In the absence of the need for these design patterns, we can finally lay these chapters from the GoF book to rest. If you have already known these patterns in the past, this presentation will convince you that you don't have to apply them anymore. If you didn't already know the patterns, then this presentation will convince you that you don't have to know them anymore. These patterns are a vestigial of the past that we can look back and learn from for the future.

How to Publish Your First Kotlin Multiplatform Library

Publishing a Kotlin multiplatform library can be very challenging. This presentation will walk through the whole process from drafting a concept to the publication of your first multiplatform library.

We will be using KStore - a minimal multiplatform library to store objects to disk - as a case study for this presentation. We will explore how it was originally inspired, the original goals and how its API evolved over time to support multiple platforms.

A key goal of this side-project was to make it self-managed as much as possible with minimal overhead so that the open-source community can extend or maintain the library even in my absence. To achieve this I've incorporated a number of tools to upkeep standards from code contributions - tools such as Klover code coverage and binary-compatibility-validator. I've also used a number of automation tools to streamline the process of publishing a multiplatform library - tools such as GitHub actions build matrices to build and test on multiple platforms.

Setting Sail with Compose Multiplatform 🏴‍☠️

Ahoy! Navigatin' in Android be a mighty contentious matter. But navigatin' in Compose, arrr, that be an even stormier sea! Now that we be havin' Compose Multiplatform, it be high time to unfurl the tattered sails and set sail on the ol' debate once more, arrr!

Afore we hoist the sails, we'll be learnin' the ropes and all' basics of navigation. We'll be learnin' about some of the challenges in navigation, like stacki' screens, passin' arguments, scopin' and retainin' instances and restoring booty-ful state.

Then we be settin' sail on a grand adventure to the vast open seas! First, we be sailin' through the familiar waters, navigatin' the treacherous but familiar waves o' the Androids using androidx-navigation-compose. But we ain't stoppin' there! We be chartin' into deeper waters and new horizons, where we'll be explorin' libraries such as Decompose, Voyager and Circuit - and unravel mysteries o' Compose Multiplatform navigation!

So lets hoist the sails, and let's set forth on this quest for knowledge and booty! Yo-ho-ho!

Watch this talk at Devfest Melbourne: https://www.youtube.com/watch?v=42FStXDJ7F8

Watch this talk at Devfest Sri Lanka: https://www.youtube.com/watch?v=sG60644C47I