Programming Leftovers

posted by Roy Schestowitz on Oct 14, 2025

• Artyom Bologov ☛ Line-based Lisp Editing

  So I have these two wolves in me: Lisp and ed(1). One problem with uniting these weird parts of me, though: Lisp is not editable in ed! At all. ed is a line-oriented editor, while Lisp is tree-based, with most forms and “statements” spanning multiple lines. ed was made to program Assembly, C, or configs; not Lisp.

  So are there any ways to converge on these two: somehow making Lisp line-editable, and somehow making ed(1) Lisp-aware? That’s what I’m tumbling over in this post: [...]

• Alex Petros ☛ What Dynamic Typing Is For

  Unplanned Obsolescence is a blog is about writing maintainable, long-lasting software. It also frequently touts—or is, at the very least, not inherently hostile to—writing software in dynamically-typed programming languages.

  These two positions are somewhat at odds.

• Carl Barenbrug ☛ When QA is Kaput

  This isn’t just an Apple problem. Across the tech industry (especially SaaS), when companies face financial cuts, one of the first casualties is often the QA (Quality Assurance) team. Testing is absorbed by engineers, who already struggle with the demands of building features at speed. It’ll come as no shock that quality suffers. Products are pushed out with half-assed functionality, broken flows, unintuitive gestures, or regressions that frustrate the very people they’re meant to serve. Ultimately, trust suffers.

• Perl / Raku

  • Rakulang ☛ Rakudo Weekly 2025.41 Tchotchke

    Fosdem 2026 Devroom Submission Coming off Liz‘s post a couple of weeks back, we have made a joint submission with the Perl folks via TPRF to the FOSDEM 2026 Call for Participation. Kudos to all those who suggested talks.

  • Noel Rappin ☛ Ruby And Its Neighbors: Perl

    Perl was a couple of things. It was the first really popular open source language and language community. It was also the language of the very early web, as the first dynamic web pages were overwhelmingly written in Perl.

    There are two things that help Perl make sense:

    • It was designed to make string manipulation super-easy, especially with regular expressions. And in this case “super-easy” means: with a minimum of typing.

    • Larry Wall had a linguistics background, and wanted Perl to have the flexibility of natural language, and as a result, there are many different ways to do most things.

  • Arne Sommer ☛ Maximum Balance with Raku

    You are given a string made up of lowercase English letters and digits only.

    Write a script to format the given string where no letter is followed by another letter and no digit is followed by another digit. If there are multiple valid rearrangements, always return the lexicographically smallest one. Return empty string if it is impossible to format the string.

• Java/Golang

  • Frank Delporte ☛ Java 21+ on Raspberry Pi Zero 2 is Back In Business

    As described before on Java 21+ Not Working on Raspberry Pi Zero 2, a problem appeared to execute Java code on the Raspberry Pi Zero 2 with OpenJDK 21 or higher. Reason: in OpenJDK 21 the Just-In-Time (JIT) compiler has been improved, but this change doesn’t work correctly on the ARM Cortex-A53 processor as used in the Zero 2. It’s another type of processor compared to, for instance, the Raspberry Pi 4 (Cortex-A72) and 5 (Cortex-A76).

    A bug was reported in the OpenJDK project: [AArch64] Incorrect result of VectorizedHashCode intrinsic on Cortex-A53 with a solution to become available in a future release.

    Let’s check, with the latest releases of OpenJDK 21 and 25 if the problem is solved.

• Rust

  • Niko Matsakis: We need (at least) ergonomic, explicit handles

    Continuing my discussion on Ergonomic RC, I want to focus on the core question: should users have to explicitly invoke handle/clone, or not? This whole “Ergonomic RC” work was originally proposed by Dioxus and their answer is simple: definitely not. For the kind of high-level GUI applications they are building, having to call cx.handle() to clone a ref-counted value is pure noise. For that matter, for a lot of Rust apps, even cloning a string or a vector is no big deal. On the other hand, for a lot of applications, the answer is definitely yes – knowing where handles are created can impact performance, memory usage, and even correctness (don’t worry, I’ll give examples later in the post). So how do we reconcile this?