GM Friends. This is JetpackCompose.app’s Dispatch. The Android/Jetpack Compose newsletter that’s more refreshing than jumping into a pool on a scorching summer day.

I want to start off by acknowledging that this issue took a little longer to hit your inbox, but trust me, it’s for a good reason. I've been cooking up some exciting things behind the scenes that are going to make their way into the newsletter soon. Let’s just call it an investment in making my subscribers (that’s you!) even happier 😉

📣 Personal Update

To kick things off, I wanted to share a quick personal “W”. A few weeks ago, I had the incredible honor of being invited by Google for a Fireside Chat at one of their internal conferences - Mobile Week, that aims to bring together mobile engineers at Google (and there’s thousands of them).

Now, I’ve been doing this whole conference-speaking thing for almost 10+ years—conferences, meetups, private events, you name it. But this one? It hit different. It felt like a real career milestone—a full-circle moment, especially since so much of my professional journey has been built on top of Android. It was one of those moments where you stop and think, "Wow, how did I get here?". I’m just really grateful for the opportunity 🙏🏻

🤬 WTFacts

Why toUpperCase() Got the Boot?

We are all familiar with this strikethrough warning every time we try to use functions like toUpperCase and toLowerCase. Ever wondered why these functions got the boot in the first place? Blame it on…Turkey 🦃 No, not that kind 🤤 I mean Turkey, the country 🇹🇷 More specifically, it’s the turkish language we are talking about.

Turns out, uppercase and lowercase letters don't play by the same rules everywhere. In English, uppercase "i" is "I" (duh), but in the Turkish language, it's "İ" (with a dot on top!).

This tiny difference can cause major chaos. Since toUpperCase relied on Locale.getDefault(), your code could behave differently depending on where you are. To fix this, Kotlin swapped it out for uppercase(Locale.ROOT) for consistency. The same deal goes for lowercase. Well now you know why you need to see that yellow strikethrough line on a daily basis 😂

_Source

😆 Dev Delight

🤔 Interesting tid-bits

Iterate in SQL, not in code

If you're still looping over SQL queries in your code, we need to talk 🤨 Instead of running a loop to fetch individual results, use a single query to get everything in one go. Now this doesn’t sound genius by any means and most of us could’ve figured this out ourselves. But what forced me to stop was the fact that the official documentation states that running the loop is roughly 1000 times slower than a well-crafted SQL query!!!!

The slow way:

val ids = listOf(1, 2, 3, 4)
val results = mutableListOf<Data>()

ids.forEach { id ->
    val result = database.query("SELECT * FROM data WHERE id = $id")
    results.add(result)
}

The fast way:

SELECT * FROM data WHERE id IN (1, 2, 3, 4)

See the difference? One query vs. multiple round trips to the database. The latter will have your app running like it just drank a gallon of espresso.

When you look at this example, it seems super obvious. However, when there are numbers like 1000 times slower in the equation, it really forces you to rethink how you handle database queries. Time to let SQL do its thing 🫡

Compose 🤝 Generative AI, a match made in heaven

Compose is a dream come true for LLMs—possibly by accident. Think about it: everything is self-contained in the same file, no more juggling between XML and code, making it easier for LLMs to parse and generate UI components in one go. The declarative syntax and reusable functions are perfectly aligned with how LLMs break down problems. It’s like Compose was secretly engineered for AI-driven development without even realizing it. Sure, it wasn’t designed with LLMs in mind, but it feels like the future of how we interact with AI-driven tools just happened to land right in Jetpack Compose’s sweet spot. _{This conversation was the inspiration behind this thought.}

👋🏻 Adios Context Receivers, Hola Context Parameters

Remember when Kotlin 1.6.20 brought us context receivers as an experimental feature? Well, after some heart-to-heart feedback from the community, Kotlin’s moving on. Yep, context receivers are heading toward retirement. But don’t worry, Kotlin isn’t leaving us hanging. Instead, say hello to context parameters, coming in future releases! Since context receivers were used by quite a few of us already (not me thankfully), Kotlin’s making sure the removal process is smooth. Starting in Kotlin 2.0.20-RC2, you’ll get gentle nudges—aka warnings—if you’ve been using them with the -Xcontext-receivers option. So, no panic required, just a heads-up that change is on the horizon.

🥂 Tipsy Tip

Preventing a Composable Function from Being Invoked During Composition:

In Jetpack Compose, it's important to ensure that certain functions aren’t invoked during the composition phase to avoid side effects or performance issues. The composition phase is when the UI is built, and invoking functions here—especially those that modify state—can lead to unpredictable behavior.

If side-effect-heavy functions are called during composition, it could cause multiple unintended invocations. While React uses strict mode to intentionally double-render components and catch these issues, Jetpack Compose doesn’t yet have a similar feature.

You can use custom lint rules to ensure certain functions (like your analytics utilities for example) aren’t called during composition. Compose already includes some rules that prevent misuse of coroutines, like ensuring launch or async is wrapped in LaunchedEffect. You can create your own rules following this pattern—check out this example for inspiration.

👩‍💻 Featured Developer

This issue’s featured developer is the brilliant Saket Narayan, an engineer at Block working on Cash App, renowned for creating elegant interactions and pushing Android to do things that few others can achieve.

What’s your favorite Android Studio shortcut?

You are well regarded for building apps and libraries with remarkable attention to detail. Where do you think your passion for it comes from?

Your work on libraries such as Telephoto, Swipe, Dank, etc requires you to do Math. What resources would you recommend for someone that wants to pick up these “graphic programming” related concepts.

Where do you get your inspiration from when it comes to good design?

What’s once piece of advice you’d give other developers?

What's your daily driver?

Favorite purchase in the last year?

If you were allowed only 3 apps on your phone, which apps would it be and why?

One project that you feel most proud about shipping

What’s your favorite feature in Jetpack Compose

👂 Let me hear it!

What’d you think of this email? Tap your choice below and lemme hear it 👇

MEH - NOT GREAT

PRETTY GOOD!

AMAZING-LOVED IT!

On that note, here’s hoping that your bugs are minor and your compilations are error free,