Creating SDKs in Kotlin Multiplatform

Kotlin Multiplatform or KMP is the talk of the town nowadays. Everyone is talking about it, lots of big orgs are using it as well, including Thoughtworks, Shopify, JioCinema, Cred etc.
While making the whole app with KMP (Kotlin Multiplatform) sounds fantastic, another really good use case would be to migrate your SDKs and libraries to KMP.
Whether you're a B2B company that offers SDKs and libraries to external clients or creating and using SDKs internally within your company, making it in KMP can help ensure consistency among different platforms, less time and effort spent, and in the end lower cost of maintenance.
In this talk, we'll discuss why and how you should create SDKs and migrate existing SDKs to KMP, and some best practices regarding the same, from a person who has done it in production, affecting millions of users.
In this session, we'll learn the following
- Why Kotlin Multiplatform for SDKs
- Difference between multiplatform and cross-platform
- How to support different platforms (Android, iOS, JS, Flutter etc.) when creating SDKs
- Performance optimization and handling threading for different platforms
- Best practices

Learn why and how to migrate or create new SDKs / libraries with Kotlin Multiplatform.
In this session, we'll learn the following
- Why Kotlin Multiplatform for SDKs
- Difference between multiplatform and cross-platform
- How to support different platforms (Android, iOS, JS, Flutter etc.) when creating SDKs
- Performance optimization and handling threading for different platforms
- Best practices

Efficient Async code with Kotlin Coroutines

Working with asynchronous code is difficult especially for Android Developers which ultimately leads to callback hell. The only way out is using Rx, but again Rx has a really steep learning curve, and forces reactive style on the developers, whether you like it or not, the problem with Rx is that, most beginners in Rx tends to mix reactive style with imperative style which causes bugs and loopholes and also debugging Rx is almost a nightmare.
Most Android developers are using Kotlin nowadays, it has many fantastic features, Coroutines being most notable among them, moreover they're stable now.
This talk would cover:
- Co-routines Generator API Example (for explaining suspension)
- How and where to create Coroutine Scopes, and how to manage them
- How to make API calls just by using co-routines and Kotlin URL extension functions
- How to use co-routines with popular REST client Retrofit.
- Actors, easing Concurrency for Android Developers
- DSL with Corotuines
- Sneak peak at channels, an experimental feature in Coroutines

Nowadays all android developers are using Kotlin, Coroutines are awesome feature of Kotlin and now they're stable as well, it's the best time for Android developers to adopt Coroutines.
Today, for writing good async code developers are bound to follow reactive style with Rx libraries, while using Rx is not a bad thing, but developers need to go a complex learning curve to utilise Rx completely and most-often developers tend to mix reactive style with imperative style which causes bugs and loopholes and also debugging Rx is almost a nightmare.
Coroutines doesn't impose a particular tyle to you, you can follow whatever style you're familiar with and write efficient async code.

The State of Compose

While developing android apps, we have a habit of scattering around flags and variables all across activities or fragments. While this worked with XML views, it’ll definitely not work well with Jetpack Compose.
Jetpack Compose is the new declarative UI framework in android, which encourages developers to use states.
While migrating apps from XML to Jetpack Compose or while writing new apps with Jetpack Compose, developers need to decide on how to manage and hoist the state. Although states have been here for some time now in android, and long before Jetpack Compose, it still is confusing to most.
In this session, we’ll talk about different techniques for state management and hoisting along with their benefits and downsides and demystify states for Compose.
We'll also discuss how to avoid some common mistakes while working with states and compose that might lead to recomposition.

Chai pe Charcha: FOMO in Android development

As the Android framework grows every day along with new library releases every now and then. The overall Android as tech growing vaster and vaster.
It's almost impossible to keep up with everything new in Android, and that leads to having FOMO (Fear on Missing Out).
Here, we'll discuss how to tackle the FOMO with our panelists.

Chai pe Charcha: Importance of DS-Algo in Interviews

It's one of the most controversial topics. Is having a DS-Algo round in the interviews really necessary? Let's discuss with experts in this panel.

TDD in Android with Spek

Most developers (who writes test cases, but doesn't yet follow TDD) are interested in or willing to follow TDD, the only factor stopping them from following TDD is confusion.
In this session, I'll try to remove that confusion, so that developers can follow TDD without hesitation.
I'll be talking about following TDD, what should be the process, and how exactly should you approach TDD. While discussing on TDD, I'll also be discussing on writing test cases with Spek DSL and the different styles of DSL offered by Spek. I'll also be showing how to setup Spek.
We'll be writing a feature, following TDD and coding live in the session.
Spek being a DSL is descriptive way of writing rest cases, thus making them more readable and better organized, which will help further to understand TDD.
Moreover, if you're new in android-dev, but have prior experience in web, you'll find Spek more familiar than traditional JUnit4 unit testing.

Migrating to Compose

While Developing Apps, following a Reactive Architecture (for example MVI, Mobius, Redux, and even MVVM) & Single Source of Truth can get you some big wins including but not limited to, Loose Coupling & Separation of Concerns, Code Testability, and easy debugging, unidirectional data, etc. However, unlike Web, where Reactive Architectures are the norm, in
Android, however, Reactive Architecture wasn’t natural till the UI layer, until Compose that is.
Using Compose would require a radical shift in our thought process about app architectures and the way we manage UI. Not only we’ll have to let go of the habit of calling `findViewById`, but we’ll also need to become accustomed to have our UI completely controlled by states, instead of having multiple flags here and there in the Activity.
Not only that, but the way we manage screens will also be affected, we’ll now have to consider having a Single Activity/Fragment while basing the navigation/Screens completely on Compose functions.
Now, if you’re developing an App from scratch, addressing the above concerns is comparatively easier than when you need to adopt/migrate to Compose in an existing app.
In this session, we’ll talk about what could be the best strategies for adopting/migrating to Compose in different kinds/sizes of apps. We'll talk about challenges you might face while migrating some existing screens to Compose.
Are you thinking is it the best time to invest in Compose? We’ll also talk about that.

In this session, we'll talk about the best strategies to migrate/adopt Compose in your existing app. We'll talk about the challenges you might face doing so.

Let's Talk Composing UI

While Developing Apps, following a Reactive Architecture (for example MVI, Mobius, Redux and even MVVM) & Single Source of Truth can get you some big wins including but not limited to, Loose Coupling & Separation of Concerns, Code Testability and easy debugging, unidirectional data, etc. However, unlike Web, where Reactive Architectures are the norm, in Android, we need to opt for Reactive Architecture considering few tradeoffs (time to market, learning curve, etc.), as it’s not natural in Android.

What do I mean by saying Reactive architecture is not natural in Android? Just like web frontends, Android apps revolve around the UI, everything we do in our Android apps has some direct or indirect relation with the UI, and the Android UI framework is imperative itself.
While the Android Platform team kept adding more and more types of Views (such as Constraint Layout, RecyclerView or more recent Motion Layout), they didn’t change the nature of UI framework itself since the beginning of android development. This was majorly due to language and tooling limitations (limited by the technologies of that time).

Google announced official support for Kotlin 2 years back, and now major numbers of professional Android Developers worldwide already adopted Kotlin, which made it easier for Google to go Kotlin first in this IO19. Kotlin comes with many perks, some of them are Functional Programming support, compiler plugin capabilities and most importantly huge support on building DSLs at ease.

What relation does Koltin have with Reactive applications? In this IO19, Google announced Jetpack Compose (https://developer.android.com/jetpack/compose/), a new (still-in-development) next generation, Kotlin based, reactive cum declarative UI toolkit, backed by principals like Single Source of Truth, Unidirectional Data Flow, Functional Programming (especially function composition and effects).

This new UI toolkit would require a radical shift in our thought process about app architectures UI programming. In this talk, we would see how we can create and interact with UI with Jetpack Compose and how different it is from the present Android framework. We will also look into examples of some code patterns and ideas of from a few famous platforms such as Vue.js, React, Flutters, etc., and how these patterns and are adopted in Jetpack Compose.

Dive into Async apps with Kotlin Coroutines

This talk highlights the challenges underpinning some of the paradigms of asynchronous programming, in particular the callback based approach. The talk will address how Kotlin aims to solve this problem with coroutines by providing a synchronous interface to the user.

This talk would cover:
- Difference between Parallel Computing and Async Computing
- Coroutines Generator API - Sequences or iterables in an asynchronous manner
- Coroutine Scopes and how to manage them
- How to use Coroutines to do network calls from app.
- Actors, easing concurrency for Android Developers
- DSL with Coroutines
- Sneak peak at channels, and select experimental features in Coroutines
- Using Coroutines and Rx2 together

TDD (Test Driven Development) in Android

Most developers (who write test cases, but don't yet follow TDD) are interested in or willing to follow TDD, the only factor stopping them from following TDD is confusion.
In this session, I'll try to remove that confusion so that developers can follow TDD without hesitation.
I'll be talking about following TDD, what should be the process, and how exactly you should approach TDD. While discussing TDD.

Moreover, if you're new in android-dev but have prior experience in web, you'll find Spek more familiar than traditional JUnit4 unit testing.

Multiplatform Web App with Kotlin

In this session we’ll learn about how to create an web app with Kotlin/JS and React. We’ll also learn about Kotlin Multiplatform. We’ll implement the domain and data in common (Kotlin Multiplatform shared code) and then the presentation and UI layer in web with Kotlin/JS and React.
We’ll see how DI, multithreading and code sharing works in KMP.
We’ll also try to implement the same with Compose web.

Optimising UI in Jetpack Compose

Jetpack Compose is now really popular for UI development in Android. However, declarative UI is still a very new and a nuanced topic among Android developers.
Most of the developers are confused about how to write an optimized UI with Jetpack Compose, and lots of developers make mistakes on state management, passing parameters, and recomposing leading to having a slower, non-performant app on production. On the other hand, few developers fall into the rabbit hole of over-optimizing recomposition.
In this talk, we'll see how to improve the performance of your UI in Jetpack Compose, we'll learn about various APIs provided by the Jetpack Compose team to reduce unnecessary recomposition, we'll also learn handling lists in Compose and lastly, we'll learn about static analysis tools with Jetpack Compose, how to use them and some best practices.
This talk will cover
- Gap Buffer and Composer
- What's Composable
- What's Recomposition, how to optimise for it, and how not to over optimise for it
- Breaking down Composables
- Side Effects
- How remember works
- Working with Lists - kotlinx.immutablecollections
- suggestions on optimised state management
- @Stable and @Immutable annotations

Efficient Code Sharing in native apps with KMP

Kotlin Multiplatform or KMP is the talk of the town nowadays. Everyone is talking about it, lots of big orgs are using it as well, including Thoughtworks, Shopify, JioCinema, Cred etc.
With Kotlin Multiplatform you can share some of your code, across platforms (web, Android, iOS, and desktop) while still building a native app.
In this session we'll see how to efficiently share code between platform with Kotlin Multiplatform to build native apps in different platforms. The speaker will also share his learnt opinions on which code to share. We'll also see some best practices in architecting KMP apps.