Agenda for July 25th

The agenda for our next event is below. Add individual talks to your calendar, or sign up at the bottom to receive event updates, straight to your inbox!
Kotlin Multiplatform. Make your Android App Cross-Platform
Kotlin Multiplatform is very trendy technology to create cross-platform application. You could create android and iOS app with common code base. It is possible to achieve a lot of result with less efforts. Also there a bunch of solution from Google with their special Jetpack libraries. In my talk I would like to show you, how to make your android app multi-platform and use the most actual and modern stack of libraries.
Building Managers Over 3rd Party SDKs for Easy Access
Anshul Khattar - Android Developer at Juno
A lot of times while integrating 3rd party SDKs, we copy paste boilerplate code again and again. Instead of this, building an SDK manager reduces boilerplate, promotes easy migration and much more.
Battle of the Titans: RxJava vs Kotlin Coroutines
Ivan Dimitrov - Android Developer at Devexperts
Join us for an in-depth exploration of the world of Android app development as we compare and contrast RxJava and Kotlin Coroutines. We will delve into the similarities and differences between these two popular asynchronous programming frameworks, discuss their respective advantages and disadvantages, and evaluate their performance in real-world scenarios. Drawing from our own experience of rewriting a significant portion of our Android app from RxJava to Kotlin Coroutines, we will share practical insights, best practices, and lessons learned. By the end of this session, you will gain a better understanding of the strengths and limitations of each approach and be equipped to make informed decisions on which method may be best suited for your next Android project.
Impact of Framework Choice on your Application: A Reverse Engineering Perspective
Ruben Pieters - Compiler Engineer
When developing an app you are faced with a difficult choice: which framework will you use to develop it? You can find evaluations of these frameworks containing their various pros and cons online. In this talk we want to dive a bit deeper into this topic by taking a reverse engineer's perspective: inspect and analyze the actual bundled application when using different frameworks. From this perspective, we will ask ourselves several questions related to the framework choice. What impact does the shared framework code have, does it meaningfully impact the overall app size or performance? If the framework allows you to write code in non-JVM based code, where does that end up and how is this code executed in the app? Are there any obvious differences in security caused by a choice of framework?
Building Accessible Apps with Jetpack Compose
Karol Wrótniak - Mobile Developer, Droids On Roids
Even more than 15% of the world's population lives with some form of disability. Nowadays the accessibility starts to become required by law. In this session, I will describe: - the best practices for building accessible apps with Jetpack Compose - how to use Semantics modifier to make your Composables accessible - the common accessibility guidelines - how to test your app accessibility
Six Things ViewBinding Teaches Us
Yauheni Slizh - Android Developer, Daresay by Knightec
View binding came some years ago and made our life easier. View binding is part of Android Jetpack and has a simple API to help us reduce boring work with findViewById or other libraries. How does it work internally, what principles use behind the scene, what problems await us when we're using? I will try to answer all these questions in my presentation. I want to share with you 6 lessons that I learned when working on View binding on different projects. I believe, It helps you avoid common mistakes and create a whole picture about 'How it works'.
JetPack Compose Performance Tips & Tricks
Eury Pérez - Principal Android Developer, Google Developer Expert in Android
Compose is a great, intuitive and straightforward way to build our UI with the behavior in the same place. Nevertheless there are a few decisions we need to make when using compose to avoid affecting the performance like the composables stability, knowing in which phase to execute certain code, optimizations with tools like R8, and so on.
Unveiling the Unseen Threat: Demystifying Memory Leaks in Android
Yves Kalume - Android Developer, Android GDE
Memory leaks can silently sabotage the performance and stability of Android applications, posing a significant challenge for developers. Memory leaks can be a silent and persistent performance killer. In this talk we will explore the causes, symptoms, and consequences of memory leaks, shedding light on how they can gradually degrade the user experience and impact device performance.
Blast Off: Managing Hundreds of UI Updates for Emoji Cannons
Piotr Prus - Android Developer
Managing a state might be a challenge. Managing the state with hundreds of updates and constant recomposition of floating emojis is a challenge indeed. In this talk, I will share how to build emoji cannon that floods your screen with UI elements, update the state, and does not freeze your UI. All of that with Jetpack Compose. In addition to covering the technical aspects of building and managing a state, I will also share how to build a responsive UI that takes the user input and animates.
Designing Jetpack Compose architecture for Gradual Migration from Fragments at Turo
Pavlo Stavytskyi - Sr. Staff Software Engineer at Turo
Many Android engineers are excited about adopting Jetpack Compose in their projects. However, in the majority of cases, the reality is that we have an existing codebase that relies on a legacy UI stack. In this talk, I will share how we designed a Jetpack Compose architecture at Turo that provides seamless integration in the existing fragment-based codebase. I will cover how we leveraged the power of Kotlin Symbol Processing (KSP) API in order to give a proper Jetpack Compose experience for our engineers while automatically preserving the compatibility with the rest of the codebase. This includes the abstraction over the navigation that hides implementation details of navigating between fragments and compose screens, and vice versa.