Sid Patil


Android Worldwide: January 2022

  ·  7 min read

An international collective of developer communities who like to put on quarterly events for Android Devs and related engineering specialties. Sid Patil and Gabor Varadi at Android worldwide July 2021

Event Details

We kickstart 2022 at Android Worldwide with a two days session on January 25th & 26th. This quarter we cover different topics ranging from managing memory at multiplatform level with Kotlin, maxing out the performance of your SQLite database, implementing FTS for faster querying and much more!

Our speakers for January 2022

  • Anna Zharkova
  • Rashyanjyot Arora
  • Kshitij Chauhan
  • William Shelor
  • Gema Rodriguez
  • Ed George
  • Sierra OBryan
  • Mohit Sarveiya
  • Ryan Kay
  • Gabor Varadi

Visit our website at Android Worldwide

We are a collective of about 30 communities around the world, focusing on Android development and modern development practices.

Participating communities

Android Budapest Android Developer Group Poznan Android Serbia
AndroidHeads Vienna DC Android Denver Droids
GDG Android Columbus GDG Boston Android GDG Bronx
GDG Capital Region GDG Córdoba Argentina GDG Fresno
GDG Helwan GDG Kolachi GDG Los Angeles
GDG Los Angeles Android GDG Montreal GDG Mumbai
GDG Nagpur GDG New York City GDG Osijek
GDG Phoenix GDG Tbilisi GDG Toronto Android
GDG Washington Kotlin Mumbai New York Android Developers
Kotlin Hyderabad

Kotlin Multiplatform. Memory management old and new way with Anna Zharkova

Abstract: The main idea of Kotlin Multiplatform, as well as other cross-platform SDKs, is to optimize development by writing code once and share it between different platforms. However, dealing with a common code base could have some nuances that should be figured out and solved according to the platform specifics. And implementation in a common base could be really tricky. One such moment is dealing with memory management, multithreading and concurrency. KMM SDK uses the specific for every native platform version of Kotlin: Kotlin/JVM, Kotlin/JS, or Kotlin/Native. Every version includes special Kotlin language extensions, tools, and libraries specified for a particular platform.

I would like to examine the specifics of both platforms, to show the difference between Kotlin Native and Kotline JVM, what problems could be faced in providing a common solution for both platforms, and the ways to provide a working solution. And how to work with new memory management model in 1.6.0 version of Kotlin/Native

Maxing out SQLite performance with Rashanjyot Arora

Abstract: This talk aims at helping developers improve database and query performance, covering the nuances of SQLite (and Room, especially in a reactive android world).

Why is this important?

  • Apps are increasingly storing more and more data and some of them are even becoming completely offline first.
  • Screen refresh rates are continually growing, and the faster we can cook up the data to be rendered, the better it is.

What this talk will cover?

  • What are Indexes and their types (single-column, multi-column, partial, covering, expression-based etc).
  • Evaluating impact of indexes via examples.
  • Support for indexes in Room and how to get around what Room doesn’t support yet.
  • A common issue with queries in the reactive world and how to get around it.
  • Pitfalls of using database views.
  • (Optional) Understanding advanced SQLite features such as pragma commands - vacuum, optimize etc.

In-Memory Full Text Search with Kotlin with Kshitij Chauhan

Abstract: This is a session on building an in-memory full-text-search library with Kotlin

In-Memory FTS is a technique to let users search through data that’s not persisted to a database. It can be used to build powerful search experiences over ephemeral data, but it’s not trivial to implement.

This session will cover how to build an in-memory full text search library in Kotlin using Coroutines and Kotlin Data Science libraries.


  • Tokenisation and Stemming of text documents
  • Inverted indices for fast reverse-lookups
  • Building a document processing pipeline with Kotlin Coroutines to generate full-text search indices

Develop your app with lots of “flow” with Gema Rodriguez

Abstract: Do you want to learn how to use Flow (and StateFlow)? Let’s use it to create an musical app, to compose together a symphony, applying reactive rhymes and using as base the MVI architecture in Android. In this talk we will share this journey to create a musical app in Android, applying the latest concurrency trends from Kotlin and this beloved reactive Android architecture. We will go from the origins and basics of the architecture, its advantages (and downsides), to the current implementation using StateFlow.

Building Quality with Firebase with William Shelor

Abstract: Firebase is a powerful tool for measuring quality and understanding trends in user behavior. In this session, we’ll discuss some of the free tools Firebase offers for measuring analytics and quality, and how they work together to give insight into how your app is performing. We’ll talk about:

  • Understanding user behavior with Firebase Analytics and Audiences
  • Tracking and resolving bugs with Crashlytics
  • Rolling out important changes with Remote Config
  • Measuring impact with Firebase A/B testing Join us as we discuss these elements of Firebase and more, with tips on how we’ve used them to fix bugs, understand user behavior, and grow our application.

Don’t get stung by OWASP - An intro into writing code for greater Android Security with Ed George

Abstract: In this session, we will take a dive into OWASP’s top threats for mobile security, the common Android security pitfalls we all succumb too and look how we may code in a more security-focused mindset going forwards.

Guide to destroying codebases: the demise of clever code with Gabor Varadi

Abstract: We try to write the best code possible, simplify future maintenance, optimize for code reuse, and apply best practices and principles to help us achieve this.

However, what if this can serve as a double-edged sword?

In this talk, we’ll analyze different ways and look at various examples on how through either under-use or over-use (or mis-use) of certain principles, we can inadvertantly introduce enough error surfaces, unintended complexity, or accidental coupling - that the only hope for a fix is a rewrite.

Android for Everyone: Accessibility in Android with Sierra OBryan

Abstract: Accessibility creates a better experience for everyone. Jetpack Compose simplifies development and can help us more easily build more accessible apps. In this talk, we’ll dive into some common use cases, Android Accessibility APIs, and compare these to the accessibility tools available in Jetpack Compose. We’ll also talk about general best practices, helpful tools, and how to test accessibility in your app.

The Golden Principles of Software Architecture Applied To Kotlin Multiplatform with Ryan Kay

Abstract: The purpose of this talk is to convey three important principles in software architecture (explained below) in a general way, but using code examples and case studies from a Kotlin multiplatform project to keep it relevant to most Android devs. The principles themselves are quite language/platform agnostic but the last principle is particularly relevant to multiplatform dev.

  1. Separation of concerns: I will explain the kinds of code which are observed in all kinds of three layer architectures (i.e. MV-Whatever), without appealing to any particular style/pattern. The idea is to get developers to stop worrying/wasting time about whether they found “the best” architecture (which doesn’t exist), and instead to find a suitable architecture based on project requirements.

  2. Abstractions: I will explain different kinds of mechanisms for abstraction (interfaces, abstract classes, inheritance), and as a bonus, Kotlin multiplatform’s source sets (using expect actual keywords). I will also address the issue of when you should prefer an abstraction, or simply a concrete class.

  3. Framework/Library minimalism: I will explain the benefits and difficulties that come with using 3rd party libraries and frameworks versus keeping most of your codebase standard library, and isolating libraries to specific end points of the application. I will also emphasize how doing this is particularly relevant to multiplatform programming in terms of code re-use.

Improving Gradle builds with Mohit Sarveiya

Abstract: As the number of modules in your code base increases, speed and consistency of your Gradle builds becomes very important. However, improving your Gradle builds can be a tricky endeavor. In this talk, I’ll address these common questions in improving Gradle builds.

  • How do we benchmark & profile our builds?
  • How do you read build scans to identify problems?
  • How do we maintain a consistent modular structure?
  • What tools can you use to speed up builds?

I’ll take a deep dive into these questions with examples and insights from my experiences.

About the author

Siddhesh Patil is an Android Engineer at DeliveryHero. Building core ordering experiences at Foodpanda and Foodora. He is the organzier of Kotlin Mumbai, a developer community in Mumbai, India. Find talks, articles and latest developments in Android and Kotlin on this website

Sid Patil is an Android Engineer and Kotlin Advocate based in Berlin, Germany. He works at Delivery Hero, building ordering experiences for food delivery and Q-commerce brands like Foodpanda and Foodora.

This publication was last updated on May 19, 2022

Share on

More articles to read