Programming Leftovers

posted by Roy Schestowitz on Nov 01, 2025

• Nico Cartron ☛ Compiling a Sensor Watch Pro firmware on FreeBSD

  Writing this article following my previous one about the "regular" Sensor Watch firmware.

  I recently bought and assembled a Sensor Watch Pro, and compiling a firmware on FreeBSD has a few differences, so as usual I'm documenting it here for me, but might be useful to others.

• Tim Bradshaw ☛ Disentangling iteration from value accumulation

  Iteration forms and forms which accumulate values don’t have to be the same thing. I think that it turns out that separating them works rather well.

  There’s no one true way to write programs, especially in Lisp1: a language whose defining feature is that it supports and encourages the seamless construction of new programming languages2. In particular there are plenty of different approaches to iteration, and to accumulating values during iteration. In CL there are at least three approaches in the base language: [...]

• Uwe Friedrichsen ☛ It is your fault if your application is down

  I would rather like to focus on the companies that complained that their applications failed due to the partial outage. I would rather focus on the thousands of self-acclaimed “experts” who self-importantly had nothing better to do than lecturing AWS on the Internet what they did wrong and that they need to design their services more reliably. I would rather like to focus on the media that had nothing better to do than to blame AWS for the partial outage.

• Ned Batchelder ☛ Side project advice

  Side projects are a good opportunity to work differently. If work means messy code, your side project could be pristine. If work is very strict, your side project can be thrown together just for fun. You get to set the goals.

• Linuxiac ☛ Gitea 1.25 Released with 3D File Previews, Faster Archives

  One of the most notable improvements is the introduction of streamed repository archives. Formats such as ZIP, TAR.GZ, or bundles are now streamed by default, which significantly improves performance and reduces memory usage when downloading large repositories.

• Michael Tsai ☛ Swift 6.2: Subprocess

  Subprocess seems to be designed to transparently handle this. You can specify the output size limit (and the encoding, if you want a string output), and it will collect the pieces of output as they arrive.

• Michael Tsai ☛ Swift 6.2

  Swift 6.2 also includes some other big features, which I’m going to write separate posts about: [...]

• Kevin Burke ☛ Speeding up Javascript Test Time 1000x

  Eight months ago when I ran our core API tests at Shyp, it took 100 seconds from starting the test to seeing output on the screen. Today it takes about 100 milliseconds: [...]

• Cynthia Dunlop ☛ "The Bug Hunt" blog post pattern

  The “Bug Hunt” blog post pattern is the programming world’s equivalent of a detective story. It has a theme, a main plot, side plots, a protagonist (you), an antagonist (usually also you, having introduced the bug two weeks ago in the first place). It’s captivating, keeps readers in suspense, and ends with a satisfying plot twist, or a tactical cliffhanger. And the best part is…it’s even more fun to write than to read!

• Anirudh Oppiliappan ☛ Building for the future

  A good exercise to perform whenever the decentralization word is used is to define what exactly you mean by it in this context. In Tangled’s case, we wanted: [...]

• Sandor Dargo ☛ Three Meanings of Reference

  Conferences are a great source of inspiration, partly trought talks and partly trough the best track, the hallway track. I already mentioned that at CppCon one of my favourite talks was the one by Steve Downey on std::optional. He also mentioned that there are three different uses of references in C++. I was thinking whether it’s four and disucssed this the next day during the break between two talks.

  Let’s talk about the 3 usages and I’ll give you the extra one which is not a usage of references but what I was thinking about originally.

• Michael Tsai ☛ Swift 6.2: NotificationCenter Messages

  However, the new API is part of Foundation, not Swift 6.2, so even in a pure-Swift app you can only use it on macOS 26 and later. This is a bummer because notifications aren’t a new feature that you can make available in your app only on the latest OS. Rather, they’re central to the design of the app itself. You can’t even begin migrating your code to the new API until you drop support for all the previous OS versions.

• Jan Schaumann ☛ Stacking Threads

  Now normally, I'd answer questions about threads with a link to shouldiusethreads.com, but I figured "What the hell, let's explore this." My initial take was that, assuming the use of Address Space Layout Randomization (ASLR), the location of each thread's stack ought to be non-predictable. But of course the answer is never quite that easy.

• Andrew Kelley ☛ Zig's New Async I/O (Text Version)

  In celebration of the std.Io introduction patchset landing today, here is the text version of a short, interactive demo I gave at Zigtoberfest 2025.

  This is a preview of the new async I/O primitives that will be available in the upcoming Zig 0.16.0, to be released in about 3-4 months. There is a lot more to get into, but for now here is an introduction into some of the core synchronization API that will be available for all Zig code to use.

• Lawrence Tratt ☛ What Context Can Bring to Terminal Mouse Clicks

  Recently I added a seemingly trivial feature to my X11 terminal that has noticeably improved my programming productivity — I can click on filenames with line numbers (and column numbers when available) and have my editor jump to that file and line: [...]

• R / R-Script

  • Rlang ☛ Pledging My Time VII

    I couldn’t see an easy way to download the data, so I used R to scrape them. Note that these times are currently provisional, but they give us a good idea of what happened.

    The results are available with a search function to find an individual’s results. If we leave everything blank and set the number of results to display to the maximum, we get the first page of 16 showing all the results. The rule is: if we can see it, we can scrape it!

• Python

  • University of Toronto ☛ My mistake with swallowing EnvironmentError errors in our Django application

    One of the things that regularly happens with new graduate students is that they were already involved on the research side of the department. For example, as an undergraduate you might work on a research project with a professor, and then you get admitted as a graduate student (maybe with that professor, or maybe with someone else). When this happens, the new graduate student already has an account and we don't want to give them another one (for various reasons). To detect situations where someone already has an existing account, the bulk loader reads some historical data out of a couple of files and looks through it to match any existing accounts to the new graduate students.

  • Haki Benita ☛ Reliable Django Signals

    Django signals are extremely useful for decoupling modules and implementing complicated workflows. However, the underlying transport for signals makes them unreliable and subject to unexpected failures.

    In this article, I present an alternative transport implementation for Django signals using background tasks which makes them reliable and safer to use in mission critical workflows.

• Shell/Bash/Zsh/Ksh

  • Michael Kjörling ☛ Local music discovery on a *nix, Linux command line

    I like to keep my music local on my Linux system, and also mostly use a rather old-fashioned way to play it with a plain command-line player, but this also means that I sometimes lose out on discoverability. Sometimes, being surprised by surfacing something from oneʼs collection can be nice.

• Java/Golang

  • Ayer ☛ I'm Independently Verifying Go's Reproducible Builds

    Thanks to Go's Checksum Database and reproducible toolchains, Go developers get the usability benefits of a centralized package repository and binary toolchains without sacrificing the security benefits of decentralized packages and building from source. The Go team deserves enormous credit for making this a reality, particularly for building a system that is not too hard for a third party to verify. They've raised the bar, and I hope other language and package ecosystems can learn from what they've done.