automatically turning on new (creepy)feature with no single click to disable them
there's just this vague recommendation to "turn it off in settings." no link, no toggle, nothing.
had to hunt for the relevant setting in the app(even their settings menu is down under in the list when you tap on your avatar.
image transcription:
a screenshot of Google play store which has a popup that can only be disabled by pressing OK button at the bottom.
the popup contains the following text:
Google is optimising app installs with your help
Google Play makes apps faster to install, open and run based on what people are using most.
The first time that you open an app after installing, Google notes which parts of the app you use. When enough people do this, your apps will install faster.
App install optimisation is automatically turned on, but you can turn it off in settings. Learn more
Nobody here seems to understand the real technical purpose of this feature, so let me try to explain what's really happening.
Android applications and much of the system are written in Java. In the beginning, this decision was made because it provides portability at least in theory and the language was familiar to developers, but this decision wasn't without its disadvantages. This extra layer of the Java virtual machine led to laggy user experiences and increased memory use in the very first versions of Android.
The first attempt to fix this problem was the Dalvik runtime. This first solution incorporates a tracing style just in time compiler that translates Java into native code as it runs. An Android Kitkat, ART or Android runtime was introduced as a developer option and later became the default which offers full compilation to native code at install time. This led to a really long system update process and some complex apps took forever to install, so in Nougat Android moved to a hybrid design that only pre-compiles the most important parts of the application. This saves install time and system update time while still getting good performance by pre-compiling to native, and we fall back to JIT if unexpected code becomes a performance bottleneck when the user is actually using the app.
But which parts do we pre-compile? How do you know what code actually matters to the user experience?
This dialogue in Play is about sharing runtime information about which code was actually executed. Google aggregates this information so that when users install an app they also receive a file describing which parts are most commonly used and actually matter to performance so the system can focus on pre-compiling only this specific subset. Namely, this data is which classes and methods are expected to be hot, with special attention paid to the ones required to initialize the application.
From a technical perspective, I don't really see how this places private user information at risk, and I agree that it needs to be the default for this design to work because most users aren't savvy enough to understand what it actually does. Google tried to simplify it is much as possible in this dialogue, but it's led to a lot of confusion especially for more technical users.
Silly question, I'm a software dev but not as mobile dev so could be barking up the wrong tree here. Could Google play not cache precompiled versions for the most popular architectures and just download them precompiled? Sure some rarer configurations would still need to do the slower local process but the more popular configurations representing the vast majority of systems would be covered.
It's not impossible, but there are limitations to that alternative approach. For example, ARM processors are really heterogeneous with respect to exactly which extensions are supported. If you compile on the server, you might not be able to take advantage of features that only exist on a few phones like the latest flagships. It also requires the device to trust that the pre-compiled code is actually consistent and won't cause bad memory access for example that can lead to a crash. If the device compiles the code, it knows there's a true one-to-one correspondence with the actual Java byte code, closing an opportunity for inconsistency. The device knows the size of the CPU caches and might make different instruction scheduling decisions in the actual binary. Generally, it's easier to be more efficient when you have all the information about the target processor available on device. But, you could have done it a different way that's true. Google decided not to do that.
We should also think about what's to be gained by moving it all to the server? On the server, you still don't know the actual user patterns. It's not space efficient to compile the entire application even if the compile time is free on the server. You would have to download unnecessary native code that may only be used by an extremely small fraction of users, wasting storage space on user devices. What if I don't use that whole area in the application? What if most users don't use it? Why should we have to download an optimized version of it onto every device? Perhaps, the best optimization is to not ship any native code for the feature nobody uses.
If you want the best balance of high performance on the user device while not wasting extra space for binary code that isn't frequently used, I think this design makes more sense. You're never getting away from having a full compiler on every device because Google can't assume that you aren't using other app stores, and it's perfectly valid for Android apps to generate code dynamically at runtime that can never be compiled in advance.
My only question now is, What parts are in AOSP and what parts are Googled Android? Is reading and installing with these optomization files/API sys-app only? Are they using accessability to track thd open activity, or via the optomization API provided by android.
I cant really tell you if their acting in bad faith without this info.
I've done a dive of the source code and I can provide a partial answer.
The execution logging functionality is publicly available source code right here.. The code reveals how Android decides what and when to save hot methods.
Dex2oat uses the profile data. You can see references here to the profile directory.
Now, where is the code that ships and downloads these profiles? I can't find it. I suspect it's part of Play services. Thus, AOSP provides all the machinery, but Play probably handles the actual profile data delivery.
They could've added the detailed description under a button, so people who care can read it. Not doing that very simple tasks, tells me they try to hide something.
They did add a link to a more detailed description. The link points here on my device.
It's still not as technical as I'd prefer, but I don't think keeping the technical level down implies Google is trying to hide something. Consider that overwhelming technical detail that's wrong could also be used as a way to lie to users.
For the most technical look, AOSP publishes the source code of almost the whole profiling system. I linked to the source code in another comment that shows how the data is collected.
I knew it had something to do with art but didn't know you could pre-compile only certain segments. I thought the best you could do was to have a bundle for certain architecture (split apks). thanks for the explanation!
now I have another question:
can't Google just get that data by running the app itself (which it does anyway) on the servers? or do they trust real hardware more than emulators?
Google cannot do this because the code that matters to performance depends on all the inputs which includes the user's actual behavior. For example, I could write an app that contains a big feature that users overwhelmingly care nothing about, wasting time in compiling it and resources in storing the translated code for this unused feature.
Building on the server means giving up access to user behavior, which is important to what code really runs. It's tough to strike a good balance between not storing code that won't be used, install times, and runtime performance.
Look. I'm using a 4 year old phone, and apps seem to install in seconds. Downloading them takes longer than the install, and even that's a few seconds...
What problem is Google really trying to solve here?
Not all devices are supported. Building a list of what code is actually run is going to be device dependent, so it only handles popular configurations.
Or, it could be that you're running an older version of the play store, or maybe there's some other reason that it's not using this feature that I don't know about.
So Google basically wants to add a feature to allow for running apps before they are fully installed? Same way you can play WoW after a minimum amount of the game has been downloaded, but before it's entirely done. Definitely feels like overkill for the majority of apps I use.
@snaptik Sure some rarer configurations would still need to do the slower local process but the more popular configurations representing the vast majority of systems would be covered.
The conversation around the automatic optimization feature for app installations on Android, as discussed on tchncs.de, underscores the tension between technological advancement and privacy concerns. It's enlightening to see such a nuanced discussion, focusing on how these features, while aimed at enhancing user experience, also raise important questions about user consent and data security. y9
Yup... I've removed tons of them.
It's almost always a different garbage link, usually a tangentially related comment written by some GPT with a bs link slipped in there.
They're mostly single use accounts too.
Report them when you see them.
Thanks