Programming Leftovers

posted by Roy Schestowitz on May 23, 2025

• James Stanley ☛ Against exponential backoff

  When software uses some external dependency, like an HTTP service, it sometimes has to handle failures. Sometimes people choose exponential backoff: after each failure, you wait longer before retrying, for example by doubling the delay each time. In this post I'm going to argue that exponential backoff is a bad idea.

  I know why you are tempted by exponential backoff. It sounds clever and appealing. If your dependency is down for N minutes then you only make O(log N) attempts to contact it. Everybody loves O(log N)! What's not to like?

  But I think you shouldn't do it, for these reasons: [...]

• Rlang ☛ A step-by-step chart makeover

  We’re going to go through a series of steps and apply best practices to improve this chart. Before jumping in to making a chart, we need to know what we’re aiming to communicate. Here, we might want to show the change in income inequality over time for different countries. We might also want to focus in on something more specific e.g. biggest increases over time, a specific continent, or most recent values.

• Dirk Eddelbuettel ☛ Dirk Eddelbuettel: RcppArmadillo 14.4.3-1 on CRAN: Small Upstream Bug Fix

  widely used by (currently) 1251 other packages on CRAN, downloaded 39.8 million

  Conrad released a minor bugfix version yesterday which addresses corner cases with non-finite values in sparse matrices.

• Daniel Lemire ☛ Dividing an array into fair sized chunks

  Suppose that you have an array of N elements and you want to divide it into M chunks. It is a common task when trying to spread N units of work over M threads, for example.

• Yoshua Wuyts ☛ Open and Closed Effect Systems

  When discussing effect systems in the context of production programming languages, I believe that the most important distinction is whether effects are purely defined by the language, or whether users are also able to define them. When Magnus Madsen from the Flix programming language joined the Rust T-Lang call for two sessions last December, he used the terms “open” and “closed” to describe this distinction: [...]

• Bozhidar Batsov ☛ The origin of the pipeline operator (|>)

  I think I first saw the pipeline operator in Elixir and afterwards in OCaml. When I started to play with F# recently, I learned that F# was widely credited as the language that made the pipeline operator popular. While reading the excellent paper The Early History of F# I learned even more on the topic. Below, you’ll find the relevant excerpt from the paper.

• Erlang ☛ Erlang/OTP 28 Highlights - Erlang/OTP

  Erlang/OTP 28 is finally here. This blog post will introduce the new features that we are most excited about.

  A list of all changes is found in Erlang/OTP 28 Readme. Or, as always, look at the release notes of the application you are interested in. For instance: Erlang/OTP 28 - Erts Release Notes - Version 16.0.

  This year’s highlights mentioned in this blog post are: [...]

• TecAdmin ☛ Building a GitOps Workflow with Kubernetes and ArgoCD

  Hey there! Managing Kubernetes clusters can be tough, right? You’ve got so many YAML files, deployments, and changes to track. What if I told you there’s a smarter way to handle all this using GitOps? With GitOps, we use Git as the single source of truth for all our Kubernetes configurations.

• Qt ☛ Qt Creator 17 Beta2 released

  We are happy to announce the release of Qt Creator 17 Beta2.

• Dark Mode Is Now Available for Everyone! [Ed: That's like calling a second CSS file a "feature"]

  Last year, thanks to one of our most special collaborators, Moisés, we introduced a “Dark Mode” option for the Open Build Service (OBS) web interface. You might remember the section titled “Introducing the Dark Mode” from one of our blog posts. At that time, it was released under the beta program.

• KDAB ☛ Simplifying 3D Stereo Visualization – an Automated Approach

  KDAB and Schneider Digital developed a system that automates stereo 3D setup by dynamically calculating focal distance, camera separation, pop-out, and field of view. A focus-area method inspired by digital cameras continuously adjusts depth, enabling a plug-and-play experience without manual tuning.

• Ruben Schade ☛ ZuluIDE is a thing

  I’ve spent a lot of time talking about retrocomputer storage on this blog. I have great solutions for video, sound, and inputs for my fleet of beloved old machines, but internal storage remains a persistent issue. I have little interest in using original hard drives—despite their wonderful percussive sound—but modern options aren’t always feasible. They can be prohibitively expensive, have compatibility issues with legacy controllers and operating systems, come with frustrating limitations, or are otherwise painful to get working.

  I haven’t talked about it as much, but recently I’ve been getting back into SCSI; specifically BusLogic, Adaptec, and Sonnet controllers. I only had a SCSI card as a kid for use with our EPSON scanner (which I sorely wish I had saved from getting ewasted) and briefly an Iomega Jaz drive, but I’ve found it to be a surprisingly robust and easy to configure platform for retro storage… relatively speaking! Bypassing the machine’s internal IDE controller or bespoke MIO card with something standardised and familiar, then using something like a BlueSCSI to present block storage, has massively simplified the work required to boot my stuff, from a stubborn PowerMac G4, to a SPARCStation. That’s probably worth its own post.

• Andy Wingo: whippet lab notebook: guile, heuristics, and heap growth

  Greets all! Another brief note today. I have gotten Guile working with one of the Nofl-based collectors, specifically the one that scans all edges conservatively (heap-conservative-mmc / heap-conservative-parallel-mmc). Hurrah!

  It was a pleasant surprise how easy it was to switch—from the user’s point of view, you just pass --with-gc=heap-conservative-parallel-mmc to Guile’s build (on the wip-whippet branch); when developing I also pass --with-gc-debug, and I had a couple bugs to fix—but, but, there are still some issues. Today’s note thinks through the ones related to heap sizing heuristics.

• GCC ☛ GCC 14.3 Released

  
  
  The GNU Compiler Collection version 14.3 has been released.
  
  
  GCC 14.3 is a bug-fix release from the GCC 14 branch
  containing important fixes for regressions and serious bugs in
  GCC 14.2 with more than 211 bugs fixed since the previous release.
  
  
  This release is available from the FTP servers listed here:
  
  
    https://sourceware.org/pub/gcc/releases/gcc-14.3.0/
    https://gcc.gnu.org/mirrors.html
  
  
  Please do not contact me directly regarding questions or comments
  about this release.  Instead, use the resources available from
  http://gcc.gnu.org.
  
  
  As always, a vast number of people contributed to this GCC release
  -- far too many to thank them individually!
  
  
  

• Python

  • Paul Gross ☛ Visualizing Financial Data with DuckDB And Plotly

    I also recently learned about Plotly, a great graphing library for Python. Combine that with my love of DuckDB for querying data1, and I have found new ways to visualize my financial data.

  • Python Speed ☛ Loading Pydantic models from JSON without running out of memory

    There are two fundamental sources of peak memory usage when parsing JSON:

    1. The memory used during parsing; many JSON parsers aren’t careful about memory usage, and use more than necessary.
    2. The memory used by the final representation, the objects we’re creating.

    We’ll try to reduce memory usage in each.

• Golang

  • Ted Unangst ☛ another tale of go.mod bloat

    It’s been one year since our previous adventure, so it’s time for another round of guess why that dependency shows up in the tarball. This time we’re looking at honk, an ActivityPub server that’s supposed to be idiosyncratic with minimal dependencies, so you can keep all your attention focused where it’s needed.