Programming: Weekly Summary (September 29 - October 05, 2025)

A week in programming, kind of messy and interesting

I would describe this week’s blog pile as a mix of low-level tinkering, language gossip, and a lot of tool fiddling. To me, it feels like sitting in a busy train station where some people are polishing brass, some are arguing about which map to use, and others are trying to get a vending machine to accept credit cards. There’s a clear current: folks are still wrestling with the same problems — performance, correctness, collaboration — but the toys and angles keep changing.

I’ll walk through the threads that kept repeating for me. I’m not trying to be exhaustive. Think of this as a window into the chatter. If something grabs you, follow the link and read the original posts — they go deeper, and many of them show code or benchmarks that I’m only hinting at here.

AI and the coder’s role: assist, not vanish

A few posts rammed the same idea into the room from different angles. Simon Willison wrote about Armin Ronacher’s ‘90%’ remark — that AI writes a lot of code but doesn’t replace skilled programmers. Eugene Zaikonnikov gave a practical how-to: use Codex to speed up a tricky frontend while still supervising design. Madhur Shrimal compared pre-LLM and post-LLM workflows and showed how tools now let you grok unfamiliar code faster.

I’d say the mood is cautious optimism. To me, it feels like people are treating AI as a very eager junior dev who can type fast and hallucinate confidently. The recurring advice: know the fundamentals. Threads, rate-limiting, correctness — these things still need human judgment. It’s like using a pressure cooker: the pressure cooker speeds up dinner, but you still need to know the recipe or you’ll burn the stew.

There’s a mild disagreement too. Some folks are excited and point to real wins — faster scaffolding, fewer tedious edits, less boilerplate. Others underline the pitfalls: excessive trust in AI, or treating it as a code oracle. That split shows up in posts about using LLMs to write parts of a Cloudflare Worker ZipReader versus the posts stressing compile-time checks and type safety.

Small language changes that matter

Tiny tweaks to languages got a lot of love this week. Leon Mika wrote twice — once celebrating Go 1.26 allowing new() to take expressions, and again arguing against the idea of collapsing programming languages into one syntax. Those are two very different vibes but related: the Go change is small but practical; the language-unification take is philosophical and a bit dramatic. He compares collapsing languages to eliminating natural languages. I’d say that’s a spicy analogy — feels like a dinner-table debate in a language nerd household.

The practical change in Go is interesting because it nudges everyday ergonomics. It’s one of those things you don’t notice until you write the code that would have been clunkier without it. Kind of like adding a pocket to a shirt you wear every day.

Elsewhere, Dayvi Schuster dug into Odin and asked whether it’s “just a more boring C.” The conclusion was favorable: Odin feels like C with fewer potholes for system work. It’s practical and sometimes elegant. That post is useful if you care about systems programming syntax that doesn’t try to be cute.

And then there was a short, pointed defense of language variety: some people really like their style and don’t want one mono-syntax. That point keeps coming up — programming languages are not just tools; they’re personal styles, like music tastes. You wouldn’t make everyone listen to country only because pop charts are big.

Concurrency, actors, threads — the same headaches in new clothes

Concurrency showed up a lot. Jacob Bartlett explained how actors are implemented in Swift. It’s a useful peek under the hood that covers executors, async boundaries, and how the compiler and runtime cooperate. Roughly: actors are reference types with an executor, and they enforce async boundaries so you don’t shoot yourself in the foot with shared state.

On a related note, Nicolas Fränkel tackled Spring transactions and ThreadLocal in the Loom era. There’s subtle danger when virtual threads and ThreadLocal meet. He walks through how Spring binds transaction context to threads and what that means for Loom’s virtual threads. This is not light reading, but if your day job involves Spring, it’s the kind of thing that keeps you awake at 2 a.m.

Jonathan Hall returned to iterator patterns in Go and goroutines — index loops, channels, range-over-func, and custom iterators. The post’s tone is practical: go beyond simple for-loops when your data size or concurrency model demands it. Handier patterns often beat clever hacks.

A pattern I noticed: people want concurrency that is both safe and predictable. Actors, Rust’s borrow checker whisper, or disciplined ThreadLocal use — they’re all different answers to the same worry: shared state explodes easily.

Performance, SIMD, and the joy of poking the metal

If you like poking at CPUs, Casey Muratori posted a Q&A that reads like a crash course in performance-aware programming. He talked about data parallelism, SIMD, substrate work (the stuff you need to glue a fast algorithm to a real system), and tools he’s skeptical or annoyed about — Git got some flak. He also mentioned Intel AMX and the trickiness of integrating new hardware features.

I’d say Casey’s posts are the ‘get-your-hands-dirty’ kind. He’s not speaking from an ivory tower. The conversation felt like: know the hardware, write for the cache, don’t be seduced by benchmarks that don’t reflect your real workload. It’s the kind of advice that’s obvious once someone points it out and yet easy to forget.

There’s also a small cluster of posts about reversing parameter order and stack manipulation. Re: Factor explored a std::flip concept and a macro for reversing sequences. It’s niche, but neat if you do functional composition or low-level call juggling.

And then there’s the PostgreSQL pseudo_encrypt exploration, again from Re: Factor. Folks love predictable bit-twiddling that produces stable unique values. It’s like collecting clever kitchen gadgets: you may not need them every day, but when you do, they’re magic.

Tooling and the new IDE dance

Tooling stole a lot of attention. Bart Wullems tried out Visual Studio 2026’s ‘Bring your own model’ feature. That’s a headline: the IDE lets you hook up custom models to Copilot Chat. Right now it can’t pick local models, but someone found a neat UX for swapping models. It’s one of those things that feels like the first step in a longer road.

Michael J. Tsai used Xcode’s Refactor tool to explain regex locally. That struck me as quietly satisfying: use your existing IDE to make cryptic regex readable rather than hauling another utility. It’s the kind of small trick that saves an afternoon and spares you regex-induced headaches.

There’s also a tiny but pleasant post about ssh-config-mode in Emacs by Winny's Blog. It’s unglamorous: syntax highlighting for ssh_config files that helps catch typos. The sort of small pleasure that feels like the universe briefly cooperating with you.

Then there’s the Cloudflare Worker zip story from Jeremy Morrell. He needed a lightweight zip reader and used an LLM to sketch a ZipReader implementation. That’s an accidental case study for AI-assisted tooling: it works but has limits, especially for large files. The post talks about R2 and ranged reads if you want to scale up — practical concerns.

Correctness, types, and API ergonomics

Type safety and compile-time checks came up a bunch. Laurent P. René de Cotret wrote about type-safe links in Haskell’s Servant. He shows how to derive string endpoint representations from type-level API definitions so you can’t accidentally construct a bad URL. It’s one of those posts where the payoff is quiet but real: less runtime nonsense, more safety up front.

Similarly, there were posts about macros, EDN, and expansions that fit into a general theme: programmers obsess over getting the right abstractions. Ekaitz Zárraga described wrestling with macro expansion in GNU Mes and splitting expansion from evaluation — a classic Lisp problem. Re: Factor added EDN support to Factor and switched parsing strategies for performance. Small wins, big in practice.

That same interest in correctness shows up in Rust posts. NorikiTech wrote a pair of posts — one about motivation for learning Rust and another listing favorite Rust books. The push here is straightforward: Rust’s borrow checker and type system are selling points for people who want fewer runtime surprises. The enthusiasm felt real and practical. If you’ve been on the fence about Rust, those posts make a case you can actually use.

Teaching, interviews, and house chores — odd corners that make the week fun

There’s always some delightful oddness. Javier posted common Ruby interview questions. Nothing revolutionary, but handy if you dread interviews. Luca Ferrari solved the Perl Weekly Challenge after a family trip to Japan — a warm mix of travel and code.

Then there’s Michael Gale who wrote about becoming a 10x developer of house chores — specifically, optimizing hanging laundry. He frames it as input-processing-output, peg optimization, and center-outward hanging. It’s cute but also a real algorithmic way to think about boring everyday tasks. If you ever thought hanging socks could be optimized, this is your post.

Projects, retro and hardware

Two posts hit the hardware/retro note. Bert Wagner built an IoT device called SplashFlag. It’s an adorable practical project: a servo flag, captive portal for WiFi setup, an LCD — a small product with real lessons on coding and hardware design.

On the retro side, Chris Garrett updated an online retro IDE for x86 and BBC Micro, added Auto-compile toggles, and added DOSBox targets. It’s the kind of niche tooling that makes hobbyists happy, and it’s surprisingly useful if you like poking at old toolchains.

And then Chris Dzombak celebrated 262 public GitHub repos. He split them into Popular, New, Useful, Weird, and Old. The ‘weird’ bucket is the best kind of internet museum tour.

Strange and edge-case things people couldn’t resist

If you like dark corners, Murage Kibicho dove into elliptic curve attacks for dormant Bitcoin wallets. It’s heavy math and a touch alarming. Read it like you would a true-crime podcast: fascinated but careful.

Re: Factor popped up multiple times with posts about pseudorandom integer transforms and EDN parsing. They clearly enjoy plumbing the design and representation layers.

There was also a provocative short one from Cal Henderson about rackets tutorials. It’s a diary-like note, small but neatly written — the kind of thing you skim and later remember when you need a tutorial approach.

Style notes and small pleasures

Some posts are pure craft. Joshua Rogers wrote a careful history of tail-call optimization and array flattening in JavaScript. That piece reminded me that language features have slow, messy lives. Browser vendors, standards bodies, and implementers all argue in different rooms. If you like the plumbing, it’s satisfying.

Ron Gilbert wrote a cheeky piece about Git, JSON, and Markdown — love, annoyance, and the little compromises we make. Git gets praise for being local and useful, JSON is adored for utility, and Markdown is blamed for being opinionated. I’d say that’s a mood many of us share; Ron’s voice is sharp and not afraid to be grumpy.

Recurring themes I kept seeing

• Tools are changing fast, but the hard problems persist. Whether it’s virtual threads or LLMs, the mechanical issues — state, performance, correctness — still hog the stage.
• Language design choices matter. Small syntax tweaks (like Go’s new()) or a language’s ethos (Odin vs C, maintainability in Rust) shape daily life.
• AI helps, but it doesn’t replace deep knowledge. Multiple posts drive that home politely and not-so-politely.
• People love tiny utilities. ssh-config-mode, EDN parsing tricks, a zip reader, or a Flip macro — these are the things that make a week interesting.

Where to poke next

If you care about concurrency internals, read the Swift actor piece and the Spring/Loom transaction analysis. If you care about performance and low-level code, Casey’s Q&A is worth the time. Interested in language ergonomics? Leon Mika on Go and Dayvi Schuster on Odin are pleasant reads. For practical tool tips, check the Xcode regex trick and Bart’s Visual Studio exploration.

There’s also a cluster of posts that are quietly useful: the Haskell Servant link construction, Rust book recommendations, and iterator patterns in Go. Those will save you time later. I’d say keep them bookmarked like you’d keep a good wrench in the kitchen drawer.

This week’s mix felt like a neighborhood market: some stalls are loud, others are small and useful, and a few are slightly strange. The constant is curiosity. People are trying things, sharing failures and neat hacks, and reminding each other to keep an eye on the fundamentals while playing with shiny new toys. If one of these threads pulls at you, follow the author link and dive in — there’s more detail, code, and cranky opinions where these came from.