this post was submitted on 02 Jul 2023
109 points (95.8% liked)

Android

28184 readers
310 users here now

DROID DOES

Welcome to the droidymcdroidface-iest, Lemmyest (Lemmiest), test, bestest, phoniest, pluckiest, snarkiest, and spiciest Android community on Lemmy (Do not respond)! Here you can participate in amazing discussions and events relating to all things Android.

The rules for posting and commenting, besides the rules defined here for lemmy.world, are as follows:

Rules


1. All posts must be relevant to Android devices/operating system.


2. Posts cannot be illegal or NSFW material.


3. No spam, self promotion, or upvote farming. Sources engaging in these behavior will be added to the Blacklist.


4. Non-whitelisted bots will be banned.


5. Engage respectfully: Harassment, flamebaiting, bad faith engagement, or agenda posting will result in your posts being removed. Excessive violations will result in temporary or permanent ban, depending on severity.


6. Memes are not allowed to be posts, but are allowed in the comments.


7. Posts from clickbait sources are heavily discouraged. Please de-clickbait titles if it needs to be submitted.


8. Submission statements of any length composed of your own thoughts inside the post text field are mandatory for any microblog posts, and are optional but recommended for article/image/video posts.


Community Resources:


We are Android girls*,

In our Lemmy.world.

The back is plastic,

It's fantastic.

*Well, not just girls: people of all gender identities are welcomed here.


Our Partner Communities:

[email protected]


founded 2 years ago
MODERATORS
 

More concretely, I'm asking this: why aren't applications compiled fully to native code before distribution rather than bytecode that runs on some virtual machine or runtime environment?

Implementation details aside, fundamentally, an Android application consists of bytecode, static resources, etc. In the Java world, I understand that the main appeal of having the JVM is to allow for enhanced portability and maybe also improved security. I know Android uses ART, but it remains that the applications are composed of processor-independent bytecode that leads to all this complex design to convert it into runnable code in some efficient manner. See: ART optimizing profiles, JIT compilation, JIT/AOT Hybrid Compilation... that's a lot of work to support this complex design.

Android only officially supports arm64 currently, so why the extra complexity? Is this a vestigial remnant of the past? If so, with the move up in minimum supported versions, I should think Android should be transitioning to a binary distribution model at a natural point where compatibility is breaking. What benefit is being realized from all this runtime complexity?

you are viewing a single comment's thread
view the rest of the comments
[โ€“] minorninth 12 points 2 years ago (1 children)

I think the main issue is who it'd be simpler for. Let's say that they switched to AOT compiling. That enables them to "simplify" the way Android works internally.

Who does that actually make things simpler for?

Literally ONE subteam of the Android team at Google. Nobody else.

It wouldn't make things any simpler for developers. In fact, it'd make things worse because AOT compilation is slower and doesn't allow things like hot-swapping code while your app is running - something you can do now with Java.

It wouldn't make things any simpler for OEMs. They don't have to worry about the Java runtime at all, they just worry about drivers.

It wouldn't make things any simpler for the other 99% of the Android team that builds new APIs, new drivers, etc.

Basically you're proposing a radical change that would make the platform worse for almost everyone, just so that one pretty small team at Google that builds the Java runtime portion of Android could make it a little simpler???

You say the current system seems "too complicated". I agree it's complex, but for a reason. Actually just about everything in tech is complex if you peek behind the curtain and learn how it works inside. The only difference here is that the code is open so anyone can see how it works. But for the most part these are just hidden details.

I guarantee that if you looked into how video frame compositing on Android works, or how low-latency audio works, or any of a hundred other things, you'd realize they're incredibly complex too - probably "too complicated" at first. But that complexity is for a reason.

[โ€“] henfredemars 7 points 2 years ago

QED, I think this response completely addresses my concerns. I often miss the social aspect of systems that involve people. I can't think of any further questions.

I reverse native binaries across a few different platforms for a living, but I'm just getting into Android. I will definitely take a look at those systems!