Complete list of secondary accounts across Lemmy, claimed here to all be the same human:

henfredemars@lemdro.id
henfredemars@infosec.pub
henfredemars@hexbear.net

  • 3 Posts
  • 36 Comments
Joined 1 year ago
cake
Cake day: July 2nd, 2023

help-circle












  • I love that a service that isn’t making a buck off of us gets levels of engagement that for-profit social networks would kill for.

    This is happening because:

    • Novelty, because new is fun. This will go down over time.
    • The most passionate users are more likely to be early adopters. More casual users are coming.
    • Smaller network means your content is less likely to be covered before. This factor will go down over time.
    • Fediverse encourages multiple related communities, which means your specific contributions are more likely to be seen by other users.
    • Lack of bots/astroturfing leads to more positive interactions. Bots will likely increase over time.

    Therefore, I expect engagement will go down over time, but I am hopeful it will reach a higher point of stability because the fediverse design seems better at getting more varied content seen by its users, and it makes it harder for a small group of people or posts to dominate the discussion space.

    PS: Anybody know how to add a space after the last bullet in a list?





  • I have a love/hate relationship with desktop web apps on Linux. They are a great blessing in some ways because I get to run apps that just wouldn’t be available to me otherwise because Linux typically isn’t a priority for consumer-focused services. Often support exists as a convenient bonus because it came with the web app platform choice.

    On the other hand, you get a web app, which looks nice (hopefully) but gobbles down your resources.



  • Hello, and thank you for taking the time to compose this response.

    I think that I may have conflated the choice of language with the choice of distribution. I believe the choice of language is independent of the choice to distribute apps as native or not, for at least Java because Java has solutions for AOT compilation not the least of which was actually used before in Android 5 according to another response, and it was used prior to Android 7 according to this resource.

    For the sake of discussion, I propose that this existing AOT compiler for Android Java applications (used today in the hybrid solution) be run in its entirety on a server instead of on the user devices. I don’t see a motivating reason to have the compiler on every user device to include a complex profile-guided optimization framework and hybrid JIT compiler (described in my third link in the original post) when we could ship the finished code and be done with it.

    The benefit would be lower maintenance of the Android platform through a simpler design. (This benefit might shake out, but I get to that later.)

    The migration process would consist of doing nothing for the typical app developer making this change quite cheap. The same languages would be supported as they are now. Indeed, this transition has already happened before and shows that this approach works, except with the build process happening on the device in earlier Android versions. I don’t understand why Google did not go a step further and ship the binaries, instead choosing to take a step back and ship a JIT compiler with the AOT compiler. Why ship the intermediate bytecode representation and insist on a complex on-device build and optimization runtime?

    From the responses that I have received so far, I think the true answer as to why distribution isn’t native is likely composed of a combination of the following factors:

    • Android’s heritage and if it ain’t broke, don’t fix it mindset (very respectable IMHO).
    • Android practically supports more platforms than arm64 even if not officially stated, such as Chromebooks and some x86 tablets. Shipping native would make this cross-arch support a lot more complicated.
    • Loose coupling between hardware and software platforms as a good design decision.
    • JIT performance can actually exceed AOT because more information is available at runtime.
    • Backwards compatibility is very important to Android, and the impacts of not shipping bytecode to these old versions could be profound or practically impossible depending on how far back we wish to consider.

    I’m sure that I’m making further assumptions, and surely there are oddball apps out there that really depend on having dynamic optimization to be performant, but I suspect these apps are in the minority. At a glance, the current solution seems too complicated, but I think understanding the history of the platform and the selection of devices that are supported today mostly answers my original question. Briefly, arm64 is absolutely not the end of the story even if it’s listed as the supported CPU architecture, and officially committing to just one now and forever could come home to roost.



  • Thank you for the insight, however, I think that my question is somewhat different because I’m interested in the implementation choice rather than the language choice. To answer your question, I don’t think Android should switch to C/C++. Instead, I don’t understand why Android goes to such great lengths to avoid compiling whatever language is in use in advance. Naively from the outside looking in it appears this would greatly simplify the platform.

    For example, I think it would be an improvement to use Java but compile the whole thing to a native image in the cloud and distribute the compiled binaries. We already have Java AOT capabilities in Android, therefore this appears to be technically feasible. Only one ISA is targeted officially. It’s not a great academic leap to think apps could be built off the phone instead to avoid the complex optimization problems.

    I am ignoring Chromebooks a bit. I did not know that you could run Android apps on that platform and didn’t think to consider it because I didn’t see x86 listed on Wikipedia as an officially supported architecture.