Programming Leftovers

posted by Roy Schestowitz on Mar 20, 2025

• LWN ☛ Zig's 0.14 release inches the project toward stability

  The Zig project has announced the release of the 0.14 version of the language, including changes from more than 250 contributors. Zig is a low-level, memory-unsafe programming language that aims to compete with C instead of depending on it. Even though the language has not yet had a stable release, there are a number of projects using it as an alternative to C with better metaprogramming. While the project's release schedule has been a bit inconsistent, with the release of version 0.14 being delayed several times, the release contains a number of new convenience features, broader architecture support, and the next steps toward removing Zig's dependency on LLVM.

• Sean Conner ☛ How I vibe code

  Good Lord! If you thought software today was bloated and slow, this sounds like it would produce software that is gigantically glacial in comparison (and by “embrace exponentials” I think he means “accept code with O(n2), O(2n) or even O(n!) behavior”).

• [Repeat] Buttondown LLC ☛ Verification-First Development

  I'm using "code" as a standin for anything we programmers make, not just software programs. When using constraint solvers, I try to find representative problems I know the answers to. When writing formal specifications, I figure out the system's properties before the design that satisfies those properties. There's probably equivalents in security and other topics, too.

• Rlang ☛ A Guide to Quality Assurance in Pharma (With a Look at Drug Flow Optimizer)

  The Drug Flow Optimizer is designed to help pharmaceutical manufacturers track and improve batch quality in real time. It provides a clear, visual overview of the entire manufacturing process – from raw materials through to the final product – and makes it easier to spot issues and ensure the highest quality standards.

  Powered by Appsilon’s open-source Rhino package, it integrates analytics and compliance tracking and enhances quality control across different production stages.

• Sandor Dargo ☛ C++26: Deprecating or removing library features

  In the previous article, we discussed what language features are removed from C++26. In this one, we are going to cover both language features that are finally removed after a few years of deprecation, and also those that are getting deprecated by C++26.

• Michael Lynch ☛ No Longer My Favorite Git Commit

  Commit messages should present the most important information first and gradually transition to finer details. Journalists call this the inverted pyramid style of writing.

  If I’m scrolling through a commit history, I want to find out quickly if each commit is relevant. The commit message should provide a high-level summary of the change right from the start.

• Juha-Matti Santala ☛ UX of home-cooked software

  One thing I do often focus a lot on my own projects is the technical/admin user documentation. I have a bunch of tools I’ve built that I use either once a month or once every three months. Since I can’t remember what I need to do with each, I’ve built command line utilities and written extensive documentation to make sure I don’t have to remember things by heart.

• Perl / Raku

  • Arne Sommer ☛ Reverse Broken with Raku - Arne Sommer

    You have a broken keyboard which sometimes type a character more than once.

    You are given a string and actual typed string.

    Write a script to find out if the actual typed string is meant for the given string.

• Python

  • LWN ☛ New terms of service for PyPI

    On February 25, the Python Software Foundation (PSF), which runs the Python Package Index (PyPI), announced new terms of service (ToS) for the repository. That has led to some questions about the new ToS, and the process of coming up with them. For one thing, the previous terms of use for the service were shorter and simpler, but there are other concerns with specific wording in the new agreement.

    According to the announcement, which was posted by PyPI administrator (and PSF director of infrastructure) Ee Durbin, the new terms will go into effect on March 27. Anyone continuing to use PyPI after that date is implicitly agreeing to the terms. Durbin outlined the history of the terms, going back to the initial opening for uploads in 2005; the terms have been updated twice since, in 2009 and in 2016, they said. In the past, the terms were primarily meant to protect PyPI and the PSF; now the organization has worked with its legal team to create the new terms. They are meant to be compatible with the old, ""while adding as permissive a set of new terms as possible to ensure that PyPI users and the PSF are protected"".

    Another reason for the update is to help enable the Organization accounts feature for PyPI. That feature, which was announced almost two years ago during PyCon in 2023, has languished, in part because of staffing difficulties that likely stem from unanticipated demand. Organizations will be able to apply for special status on PyPI, with their own namespace that can house multiple projects; organizations for community projects would be free, while companies would pay a small fee, with the revenue targeted for PyPI operations and maintenance. The feature is currently in a closed beta and is expected to be rolled out more widely soon.

• Golang

  • Ruben Schade ☛ Learning Go

    So I went to the Go site and started reading the free sample chapter of The Go Programming Language. Twenty minutes later, this happened: [...]

  • University of Toronto ☛ Go's multiple return values and (Go) types

    One problem with tuple types in a statically typed language is that they must exist as types, whether declared explicitly or implicitly. In a language like Go, where type definitions create new distinct types even if the structure is the same, it isn't particularly difficult to wind up with an ergonomics problem. Suppose that you want to return a tuple that is a net.Conn and an error, a common pair of return values in the net package today. If that tuple is given a named type, everyone must use that type in various places; merely returning or storing an implicitly declared type that's structurally the same is not acceptable under Go's current type rules. Conversely, if that tuple is not given a type name in the net package, everyone is forced to stick to an anonymous tuple type. In addition, this up front choice is now an API; it's not API compatible to give your previously anonymous tuple type a name or vice versa, even if the types are structurally compatible.