Programming Leftovers

posted by Roy Schestowitz on Jan 06, 2026

• Fred Herbert ☛ Software Acceleration and Desynchronization

  Each of the steps above can imply a skip backwards to an earlier task, and emergencies can represent skips forwards. For the sake of the argument, it doesn't matter that our model is adequately detailed or just a rough estimation; we could go for more or less accurate (the “write tests” node could easily be expanded to fill a book), this is mostly for illustrative purposes.

  Overall, in all versions, tasks aim to go as quickly as possible from beginning to end, with an acceptable degree of quality. In a mindset of accelerating development, we can therefore take a look at individual nodes (writing code, debugging, or reviewing code) for elements to speed up, or at overall workflows by influencing the cycles themselves.

• Andrew Nesbitt ☛ Making git-pkgs feel like Git

  Git has strong conventions for colors, pagers, environment variables, and configuration that users expect without thinking about them. I wrote about extending git a while back, covering the extension points git provides. But knowing the patterns exist is different from implementing them well. If your subcommand ignores these conventions, it feels foreign. Getting them right is fiddly, but people notice when you skip them.

• Remi Collet ☛ Remi Collet: 🎲 PHP version 8.3.30RC1, 8.4.17RC1 and 8.5.2RC1

  Release Candidate versions are available in the testing repository for Fedora and Enterprise Linux (RHEL / CentOS / Alma / Rocky and other clones) to allow more people to test them. They are available as Software Collections, for parallel installation, the perfect solution for such tests, and as base packages.

  RPMs of PHP version 8.3.30RC1 are available

• Andy Wingo ☛ Andy Wingo: pre-tenuring in v8

  Hey hey happy new year, friends! Today I was going over some V8 code that touched pre-tenuring: allocating objects directly in the old space instead of the nursery. I knew the theory here but I had never looked into the mechanism. Today’s post is a quick overview of how it’s done.

  allocation sites

  In a JavaScript program, there are a number of source code locations that allocate. Statistically speaking, any given allocation is likely to be short-lived, so generational garbage collection partitions freshly-allocated objects into their own space. In that way, when the system runs out of memory, it can preferentially reclaim memory from the nursery space instead of groveling over the whole heap.

• SciML ☛ Introducing SciML Health Bots: Lowering Barriers While Raising Standards

  SciML has 200+ packages with stricter standards than most of the Julia ecosystem. We test for static compilability, type stability, and interface consistency. Many upstream packages don't—AD packages like Zygote and Enzyme frequently introduce regressions, and foundational packages like Distributions.jl don't test for juliac --trim compatibility or static interfaces.

• Perl / Raku

  • Rakulang ☛ Rakudo Weekly 2026.01 Year::Happy.new

    Antons’ Corners Anton has welcomed in the new year with two new posts: and: Looking forward to many more insightful and LLM friendly posts from Anton! Events Please mark your diaries for the German Perl/Raku Workshop, 16-18 March 2026 in Berlin Weeklies Weekly Challenge #355 is available for your enjoyment.

• Python

  • Michael Kennedy ☛ Python Numbers Every Programmer Should Know

    There are numbers every Python programmer should know. For example, how fast or slow is it to add an item to a list in Python? What about opening a file? Is that less than a millisecond? Is there something that makes that slower than you might have guessed? If you have a performance sensitive algorithm, which data structure should you use? How much memory does a floating point number use? What about a single character or the empty string? How fast is FastAPI compared to Django?

    I wanted to take a moment and write down performance numbers specifically focused on Python developers. Below you will find an extensive table of such values. They are grouped by category. And I provided a couple of graphs for the more significant analysis below the table.

  • Henrik Forstén ☛ Online radar image formation simulator

    I was making some radar image formation visualizations using Python and thought that it would be nice if it was instead written in Javascript and ran on my browser. That way I could put some real-time visualizations on my blog posts. I don't have much web development experience, so I gave my Python program to Claude AI and asked it to convert it to Javascript and it did okay job. After one day of manual work I think it's working pretty well and I decided to put it up as a separate web application. Click the above image to open it. It was quite fun to be able to focus on content and leave the web frontend part mostly to the AI, I don't think I would have had enough motivation to make this without it.

• Java/Golang

  • Filippo Valsorda ☛ go.sum Is Not a Lockfile

    I need everyone to stop looking at go.sum, especially to analyze dependency graphs. It is not a “lockfile,” and it has zero semantic effects on version resolution. There is truly no use case for ever parsing it outside of cmd/go.

  • Anton Zhiyanov ☛ Go 1.26 interactive tour

    Go 1.26 is coming out in February, so it's a good time to explore what's new. The official release notes are pretty dry, so I prepared an interactive version with lots of examples showing what has changed and what the new behavior is.

    Read on and see!

  • Vincent Bernat ☛ Using eBPF to load-balance traffic across UDP sockets with Go

    Akvorado collects sFlow and IPFIX flows over UDP. Because UDP does not retransmit lost packets, it needs to process them quickly. Akvorado runs several workers listening to the same port. The kernel should load-balance received packets fairly between these workers. However, this does not work as expected. A couple of workers exhibit high packet loss: [...]

• Rust

  • Rust Blog ☛ The Rust Programming Language Blog: Project goals update — December 2025

    The Rust project is currently working towards a slate of 41 project goals, with 13 of them designated as Flagship Goals. This post provides selected updates on our progress towards these goals (or, in some cases, lack thereof). The full details for any particular goal are available in its associated tracking issue on the rust-project-goals repository.