vegancoder

Parallelism with Android SQLite The SQLDelight documentation provides this example: val players: Flow<List<HockeyPlayer>> = playerQueries.selectAll() .asFlow() .mapToList(Dispatchers.IO) This looks reasonable, right? In the Square Point Of Sale application, we recently ...

A must-read SQLite #performance article for #AndroidDev from @p-y.wtf: blog.p-y.wtf/parallelism-...

@p-y.wtf is probably the best Android performance expert out there right now, so if you're not following him here for some reason, you definitely should!

A lot of the points in the talk could sound obvious or maybe were already implicitly learned by working with Compose code, but having the most important things all in one place and structured nicely was very engaging to watch. I've also learned a few things I didn't know.

Designing scalable Compose APIs - droidcon As more and more apps and teams migrate to Compose, it's important to establish clear guidelines for writing high-quality Compose code.

A nice educational #AndroidDev talk from @anomiss.bsky.social on best practices for designing Compose APIs (external and internal):

www.droidcon.com/2024/11/22/d...

Herding Elephants Wrangling a 3,500-module Gradle project

2nd and 3rd parts of the story from 2021 and 2023:

- developer.squareup.com/blog/herding...
- developer.squareup.com/blog/stamped...

Mmmm
The statement that the AI E2E tests will be less flaky than the hand-written ones is a bit too optimistic.

Hand-written tests are easy to monitor, debug and fix. Who fixes Gemini, when it suddently stops finding the right image or button in an app, or is just down?

This image shows a Sankey diagram visualizing the path of 30 job applications – from submission to final outcome. The flows indicate how many applications progressed in each way. Key stages in the process: Applications (total: 30): - 23 via a website - 5 via an employee referral - 2 contacts were initiated by the company ("I was contacted") Initial responses: - 6 applications were ignored - 6 received a reply Progress after contact: - 4 led to an introductory interview - Of those: - 2 led to a technical interview - 1 of those led to a signed employment contract - 2 ended without further decision ("no rejection, no continuation") Rejections: - 17 applications were rejected Candidate’s own decision: - 4 times the applicant declined Summary: - Most applications came through websites but often didn’t go far. - Only one application resulted in a successful hire. - Overall, response rates were modest: many were ignored or rejected early on. The diagram provides a clear overview of the application process, highlights bottlenecks (e.g., many early rejections), and gives a good sense of the overall success rate.

#AndroidDev job search in Germany, senior remote position, visualized.

Took about one and a half months, and I feel incredibly lucky that it took that little - my last job search took me about 6 months.

(what the red colors are in the diagram I don't know, was too tired to fix them)

wow

Maybe I'm dead wrong then, because this phrase seemed unnecessarily overcomplicated to me, like LLM like to generate 🙈

What do you mean?
Sorry I don't understand

Boost app performance and battery life: New Android Vitals Metrics are here New Android Vitals metrics focusing on excessive wake locks, giving developers tools to resolve consumption issues and improve app performance.

Kudos to the Android team for consistantly improving the performance tools

And anti-Kudos for starting using LLMs to write their articles ("continuously evolving to deliver exceptional user experiences" - who speaks like that?)

android-developers.googleblog.com/2025/04/boos...

#AndroidDev

🫂

After many years I've finally given up and started using vscode instead of sublime text.

I was a big fan of sublime, but it seems vscode is pretty much the industry standard now and many people around often me don't even know what sublime is🥲

This strategy can be very useful when we want to measure performance during a high-load system state, when tasks queues are full and an additional thread switch (measuredFunction giving control to the original thread) could take too much time, making metrics from users unreliable.

In the snippet above:
- uptimeMillis is first called on the thread which will invoke measuredFunction
- after measuredFunction returns, the execution is still within the measuredFunction's thread
- so we measure the time it takes to switch to the thread of measuredFunction and for it to get executed

withContext(Dispatchers.Unconfined) { val start = SystemClock.uptimeMillis() measuredFunction() val duration = SystemClock.uptimeMillis() - start report(duration) }

Personal opinion: although the Unconfined dispatcher could be tricky, it's quite useful when one wants to measure performance of suspending function in "real life", on user devices:

Dispatchers.Unconfined and why you actually want EmptyCoroutineContext Use EmptyCoroutineContext instead of Dispatchers.Unconfined.

A nice article about Dispatchers.Unconfined by @colinwhite.me, very useful if one wants to understand Kotlin Dispatchers a bit better: code.cash.app/dispatchers-...

I bet this talk would be of a great usefulness for someone, who just received an objective to improve the Jetpack Compose performance of some code base. It gives several good ideas of what to look at and where to start.

A very-very interesting #AndroidDev talk from Vitalii Markus, where shows quite a few examples of how the Flow app improves Jetpack Compose #performance in critical places, moving heavy work to later phases (developer.android.com/develop/ui/c...)

www.droidcon.com/2024/11/22/j...

I almost haven't worked with Jetpack Compose professionally yet so I learn about such nice changes a bit too late after they come out. It's nice seeing how Compose gets more and more mature with each year though.
But I still wish it used much less magic under the good.

New ways of optimizing stability in Jetpack Compose Master strong skipping, annotations, configuration file, and more to optimize stability.

A great #AndroidDev article on Strong Skipping Mode of Jetpack Compose, which was released in the summer of 2024 and is designed to greatly optimize the lib #performance without forcing devs to rewrite too much code.

medium.com/androiddevel...

YouTube video by droidconLisbon Sergio Sastre Flórez - Composable Preview Driven Development: TDD-fying your UI with ease!

Another #AndroidDev talk on Preview-Driven-Development. From Sergio Sastre Florez, who is unfortunately not on Bluesky yet.

www.youtube.com/watch?v=cDqd...

This is probably the best guide on PDD that I've seen. It's really good at explaining the first steps one could follow to try this approach.

now*

The company I worked at in 2023 one day started to apply a very similar approach to the modules structure.

I was in an entirely unrelated team so I didn't ask questions, but now I wonder if maybe this talk has influenced the transformation.

A wonderful #AndroidDev talk from @ralf-wondratschek.com on how Android modules were structured at @Square back in 2019 (it's the year of the talk), for build #performance.

www.droidcon.com/2019/11/15/a...

I wonder how much the modules approach at @Square has change since then.

I didn't yet have the opportunity to use it.
Back in the day all the devs were coming up with their own ways to determine how performant the device is - some were considering RAM size, some number of cores or screen resolution.
It was somewhat chaotic, and I wonder how much this lib helps nowadays.

Performance Class helps Google Maps deliver premium experiences The Media Performance Class (MPC) standard helps developers understand a device's capabilities and tailor user experience accordingly.

An interesting #AndroidDev #performance article about the (relatively) new Performance Class feature of Android (which helps to determine how performant is the device)

More specifically, the article demonstrates how Google Maps use this new feature

android-developers.googleblog.com/2025/01/perf...

I doubt that a lot of people who are not directly working on the low-level AOSP-things face similar issues to the ones described in the article, but nevertheless it's always fun to learn a bit more about how benchmarks work on a lower level.

A small #AndroidDev article from @romainguy.dev about how compiler optimizations can make your benchmark to measure a wrong thing:
www.romainguy.dev/posts/2024/y...

Speeding Up UI Tests 4x While Reducing Costs In software development, speed and reliability are everything. Achieving both meant a significant overhaul of how we handled UI tests.

A wonderful article on #AndroidDev CI/CD: engineering.traderepublic.com/speeding-up-...

The author tells a performance improvement story, sharing enough details about their journey to allow the reader to consider the author's approach for their own projects.

It's a pretty old article (2020) and googling the people mentioned in such articles leads to odd things sometimes.

E.g. here Aleksei Zakharov was mentioned as a source of Wisdom, but then I google him and find out that the company has laid him off, as of he never was a source of Wisdom...