• the history of Java in Android (was Re: =?utf-8?Q?What=E2=80=99s?= Your Least Favourite Programming Language?)

    From Kragen Javier Sitaker@kragen@canonical.org to comp.lang.misc,alt.folklore.computers on Fri Aug 28 20:27:04 2026
    From Newsgroup: comp.lang.misc

    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
    On Fri, 28 Aug 2026 16:43:56 -0300, Kragen Javier Sitaker wrote:
    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
    But J2SE was available in an open-source form, namely OpenJDK. So
    they adapted that instead.

    With respect, I think you may have gotten this wrong. Originally
    they used Apache Harmony (presumably they preferred its non-copyleft
    licensing) but switched to OpenJDK in 02016 in response to the
    Oracle lawsuit
    <https://arstechnica.com/tech-policy/2016/01/android-n-switches-to-openjdk-google-tells-oracle-it-is-protected-by-the-gpl/>

    You are mixing up the language implementation with the library implementation.

    Your statement, rCLSo [the Android team] adapted [OpenJDK] instead [when
    they could have chosen J2ME],rCY is not true of *either* the language implementation (Dalvik) *or* the library implementation (initially they
    adapted Harmony, and many years later they adapted OpenJDK).

    Kragen
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Kragen Javier Sitaker@kragen@canonical.org to comp.lang.misc on Fri Aug 28 21:03:13 2026
    From Newsgroup: comp.lang.misc

    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
    On Thu, 27 Aug 2026 21:11:55 -0300, Kragen Javier Sitaker wrote:
    the Python maintainers have adopted a policy of deliberately
    breaking standard library backward compatibility in every point
    release.

    In what way?

    They call it rCLremoving dead batteries from the standard libraryrCY ...

    So they donrCOt want to keep accumulating legacy baggage that just adds
    to the ongoing support burden.

    Yes, that is their motivation for adopting the policy of deliberately
    breaking standard library backward compatibility in every point release. However, their motivation, understandable though it is, is irrelevant to
    my point, which is that as a result of this policy, Python has, in
    practice, gone from being one of the *most* portable languages to one of
    the *least*; you canrCOt even reliably run a Python application you wrote
    on Ubuntu 25.10 (Python 3.13) on Ubuntu 26.04 (Python 3.14).

    In Python 3.14, the list of things removed to deliberately break
    backwards compatibility in it is relatively small; it includes ast.Num, asyncio.FastChildWatcher, pickling itertools iterators,
    `pty.master_open()`, and sqlite3.version. And theyrCOre changing the
    default start method of `multiprocessing` from `fork()`, which usually
    wonrCOt crash peoplerCOs code but will introduce massive performance regressions in some cases. <https://docs.python.org/3.13/deprecations/index.html>

    Every open-source project does that. The key is to support the
    important stuff that people care about.

    In some sense, this is obviously true, but there are enormous
    differences of degree. The current Python policy is way down at the gratuitous-instability end of the spectrum. JavaScript, by contrast,
    still supports `with`, and glibc still supports `gets`.

    Does anybody still want to use the rCLcgirCY module?

    Yes. Although CGI was pretty costly when it went out of style in the
    01990s, hardware has improved dramatically, and CGI can now handle half
    a billion hits per second on one server <https://jacob.gold/posts/serving-half-billion-requests-with-rust-cgi/>
    which is enough for all but the biggest public websites. CGI is a
    relatively low-tech, simple interface that is extremely widely supported
    by web servers. For cases where the Python startup overhead is killing
    you, even on current hardware, you can use the `cgi` module with FastCGI <https://www.asmallorange.com/help/article/aso-using-python-with-fastcgi>.

    Nowadays, hardware is so fast that the CGI execution model has seen a
    huge resurgence, mostly using a slightly different interface from the
    original CGIrCerCorCethey call it rCLserverlessrCY now.

    I have three or four CGI scripts written in Python that IrCOve been using
    for many years without having to maintain them.

    The `cgi` module probably should not have been added to the standard
    library in the first placerCerCorCeits interface is kind of error-prone and clumsy. But, having been added, it should not have been removed.

    In addition to `cgi` they also removed `cgitb`, which was an invaluable
    aid to debugging Python programs that had nothing to do with CGI or the
    Web; simply by running

    import cgitb; cgitb.enable(format="text")

    at the beginning of program execution, your stack traces include the
    values of local variables, which is very frequently enough to make bugs
    trivial to track down. I assume the Python maintainers removed this functionality because they didnrCOt know about it.

    Sun rCLaurCY file format?

    Yes, obviously? There are plenty of audio data files from 30 years ago
    in .au format. If you have an existing Python application that can read
    them, how is it beneficial to break it? Was there a lot of maintenance
    load involved due to the rapid changes in the .au file spec? Moreover,
    users of such an application would suffer even if they donrCOt have any
    .au filesrCerCorCethe application will crash at startup with an ImportError, because it foolishly used the standard library support for the most
    popular audio file format.

    A Unix password encryption library that doesnrCOt keep up with current password encryption formats?

    This one IrCOm more skeptical of the importance of. But your other two examples are obviously egregiously bad.

    Kragen
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Keith Thompson@Keith.S.Thompson+u@gmail.com to comp.lang.misc on Fri Aug 28 18:10:09 2026
    From Newsgroup: comp.lang.misc

    Kragen Javier Sitaker <kragen@canonical.org> writes:
    [...]
    Yes. Although CGI was pretty costly when it went out of style in the
    01990s, hardware has improved dramatically, and CGI can now handle half
    [...]

    Why do you write years like this?
    --
    Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
    void Void(void) { Void(); } /* The recursive call of the void */
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Lawrence =?iso-8859-13?q?D=FFOliveiro?=@ldo@nz.invalid to comp.lang.misc,alt.folklore.computers on Sat Aug 29 01:30:46 2026
    From Newsgroup: comp.lang.misc

    On Fri, 28 Aug 2026 20:27:04 -0300, Kragen Javier Sitaker wrote:

    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:

    On Fri, 28 Aug 2026 16:43:56 -0300, Kragen Javier Sitaker wrote:

    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:

    But J2SE was available in an open-source form, namely OpenJDK. So
    they adapted that instead.

    With respect, I think you may have gotten this wrong. Originally
    they used Apache Harmony (presumably they preferred its non-copyleft
    licensing) but switched to OpenJDK in 02016 in response to the
    Oracle lawsuit
    <https://arstechnica.com/tech-policy/2016/01/android-n-switches-to-openjdk-google-tells-oracle-it-is-protected-by-the-gpl/>

    You are mixing up the language implementation with the library
    implementation.

    Your statement, rCLSo [the Android team] adapted [OpenJDK] instead [when
    they could have chosen J2ME],rCY is not true of *either* the language implementation (Dalvik) *or* the library implementation (initially they adapted Harmony, and many years later they adapted OpenJDK).

    rCLDalvikrCY was the original bytecode interpreter that Google came up
    with for Android. That was not a rCLlanguage implementationrCY for any particular rCLlanguagerCY.

    By rCLlanguage implementationrCY I was talking about SunJDK versus
    OpenJDK.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Janis Papanagnou@janis_papanagnou+ng@hotmail.com to comp.lang.misc on Sat Aug 29 06:39:50 2026
    From Newsgroup: comp.lang.misc

    On 2026-08-29 03:10, Keith Thompson wrote:
    Kragen Javier Sitaker <kragen@canonical.org> writes:
    [...]
    Yes. Although CGI was pretty costly when it went out of style in the
    01990s, hardware has improved dramatically, and CGI can now handle half
    [...]

    Why do you write years like this?

    Some brainstorming...

    Anticipation of potential "Y10k issues".[*]
    Prevention of presumed misinterpretations of his posts.
    Fostering non-standard formats; a still quite common habit.
    Showing an individualistic peculiarity as Usenet poster.
    Naive(?) believe that someone would gain something by that.
    Spreading confusion to distract from the contents of the post.
    Making it harder for AI-bots to extract semantics from posts.
    Keeping communication busy for self-purpose or citation counts.
    A religious convention. (Maybe from the Pastafarianism? - IDK.)
    Aggravating the pedants as well as all the "normal" people.

    Just a few random thoughts. - My guess is that it's #4.

    Janis

    [*] In that case we should of course consider that the world
    (unless already ended before[**]) might exist yet longer[***],
    so even five digits for the year might not suffice.[****]

    [**] https://en.wikipedia.org/wiki/List_of_dates_predicted_for_apocalyptic_events

    [***] Ignoring a human race's factual self-genocide that may
    end the story even a lot earlier.

    [****] To be about safe, and not overestimate the statistical
    factors (impacts etc.), I'd suggest to use at least 9 digits
    for the year.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Kragen Javier Sitaker@kragen@canonical.org to comp.lang.misc,alt.folklore.computers on Sat Aug 29 15:24:51 2026
    From Newsgroup: comp.lang.misc

    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:
    On Fri, 28 Aug 2026 20:27:04 -0300, Kragen Javier Sitaker wrote:
    Your statement, rCLSo [the Android team] adapted [OpenJDK] instead [when
    they could have chosen J2ME],rCY is not true of *either* the language
    implementation (Dalvik) *or* the library implementation (initially they
    adapted Harmony, and many years later they adapted OpenJDK).

    rCLDalvikrCY was the original bytecode interpreter that Google came up
    with for Android. That was not a rCLlanguage implementationrCY for any particular rCLlanguagerCY.

    By rCLlanguage implementationrCY I was talking about SunJDK versus
    OpenJDK.

    We've agreed that they werenrCOt using the Sun JDKrCOs class library;
    instead they used Apache Harmony. We've agreed that they werenrCOt using
    the Sun JDKrCOs bytecode interpreter; instead they used Dalvik. I'm
    pretty sure they werenrCOt using the Sun JDKrCOs compiler from Java source
    to Java bytecode, because Dalvik couldnrCOt interpret the standard stack-oriented JVM bytecode. Was there some other part of the Sun JDK
    that they *were* using? If so, what part? What does the JDK contain,
    other than the class library, the virtual machine, and the compiler to
    that virtual machine?

    Kragen
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Lawrence =?iso-8859-13?q?D=FFOliveiro?=@ldo@nz.invalid to comp.lang.misc,alt.folklore.computers on Sat Aug 29 21:57:09 2026
    From Newsgroup: comp.lang.misc

    On Sat, 29 Aug 2026 15:24:51 -0300, Kragen Javier Sitaker wrote:

    I'm pretty sure they werenrCOt using the Sun JDKrCOs compiler from Java source to Java bytecode, because Dalvik couldnrCOt interpret the
    standard stack-oriented JVM bytecode.

    The whole point about using SunrCOs JDK was precisely to get its
    compiler.
    --- Synchronet 3.22a-Linux NewsLink 1.2