Programming Leftovers

posted by Roy Schestowitz on Nov 26, 2025

• Julia Programming Language ☛ Launching the Julia Security Working Group

  There's been a lot of security work in the Julia ecosystem recently, and those of us pushing on this effort have informally self-organized around a slack channel (#security-dev) and a handful of repositories and pull requests. We are past due in officially organizing our efforts into a working group! With this blog post, we are announcing the creation of the Julia Security Working Group (JLSEC): an official community effort to improve the security tooling of the Julia package ecosystem.

• Michał Karbowiak ☛ Building a Simple Search Engine That Actually Works

  The concept is simple: tokenize everything, store it, then match tokens when searching.

  Here's how it works: [...]

• Radical Elements ☛ We Rewrote Our Startup from PHP to Gleam in 3 Weeks

  Gleam is a general-purpose, concurrent, functional, high-level programming language that compiles to Erlang or JavaScript. Gleam is a statically-typed language that runs on Erlang's virtual machine BEAM. It has its own type-safe implementation of OTP, Erlang's actor framework.

• Chris ☛ Software Never Fails

  If software contains a bug, it’s not something it did to itself. All bugs we suffer because we put them in there. For every 10–100 lines of code you write, you add a bug.

  The normal response to this is to shrug it off. We’re going to do something controversial: we’re going to take the perspective that the software hasn’t failed – it did what we designed it to do.

• Noel Rappin ☛ Ruby And Its Neighbors: Lisp

  We’ve already talked about Perl and Smalltalk. I don’t know much about Eiffel or Ada, though I assume Eiffel inspired some of Ruby’s object structure somehow. Ada is perhaps the most statically typed language in existence and it’s hard to see how it could have possibly influenced Ruby in any significant way, but I guess it must have.

  Which brings us to Lisp. I’ve been a little nervous about approaching Lisp because, while I have actually done projects in Lisp, it’s been a while. And I assume there’s a whole cadre of Lisp-knowers waiting to jump on misstatements. Hi, Lisp-knowers!

• Bert Peters ☛ Misunderstanding that "Dependency" comic

  The original comic is a joke and expression of concern at the fact that lots of our modern technology depends on small projects that largely are maintained by a single driven developer writing code in their spare time. They are important, yet fragile. This is not comparable to the outages we’ve seen this year.

  To contrast, these four cloud providers are, for better or worse, important to the web as we know it. But they’re not small. We should recognize that these are huge players, with revenues larger than the GDP of many countries.1 Cloudflare isn’t anywhere near as big as the other three, but it still has a proportionally gigantic impact on the web due to how much data flows through them.

  In addition to how important they are, they are all also among the largest and most valuable companies in the world. It’s concerning how reliant we are on just this handful of players, and when governments become more reliant on them, that is a huge risk. It is however the same, boring risk of influence and dependence it always is with large companies, rather than a risk of single individuals disappearing and taking our technology with them.

• Andrew Helwer ☛ Let go of StackOverflow; communities must take ownership -

  Despite the title this is less a directive and more a description of what has already happened, and how I came to realize it. Still, there are many who remember StackOverflow as a revelation in the mid-2010s and think some vestige of those times remain. They think if they make an effort to distill their confusion into a question and post it there they will be rewarded. Perhaps some scarce few will, but a better way exists.

• Perl / Raku

  • Arne Sommer ☛ Power Pointing with Raku

    Write a script to return the power of the given string.

    The power of the string is the maximum length of a non-empty substring that contains only one unique character.

• Python

  • Daniel Holden ☛ Implementing Control Operators

    This year at SIGGRAPH Asia we are presenting "Control Operators for Interactive Character Animation", which is a paper about our new framework for implementing and thinking about control mechanisms for interactive character controllers.

    This topic is something which has been bubbling away in my brain over the last few years, and was an incredibly fun project to work on with Ruiyu Gou, and in particular to see Control Operators combined with the really powerful Flow-Matching model she developed.

• Java/Golang

  • Wouter Groeneveld ☛ Rendering Your Java Code Less Error Prone

    Error Prone is Yet Another Programming Cog invented by Google to improve their Java build system. I’ve used the multi-language PMD static code analyser before (don’t shoot the messenger!), but Error Prone takes it a step further: it hooks itself into your build system, converting programming errors as compile-time errors. Great, right, detecting errors earlier, without having to kick an external process like PMD into gear?

    Until you’re forced to deal with hundreds of errors after enabling it: sure. Expect a world of hurt when your intention is to switch to Error Prone just to improve code linting, especially for big existing code bases. Luckily, there’s a way to gradually tighten the screw: first let it generate a bunch of warnings and only when you’ve tackled most of them, turn on Error! Halt! mode.

• Rust

  • Alisa Sireneva ☛ A look at Rust from 2012

    I heard tales of old Rust before, but not of how the language felt to programmers. So I thought it’d be cool to give a (relatively) quick summary of Rust as presented in the tutorial and yap a bit about how far we’ve come since then.