Programming: Weekly Summary (November 17-23, 2025)

I’d say this week in programming felt a bit like opening the fridge and finding half a dozen things that should match but don’t — dates in one corner, new language bits in another, an AI handing you a recipe with missing steps. The posts I read circle a few clear motifs: tool friction (breaking updates, weird defaults), AI in the loop (helpful but shaky), a hunger for low-level craft, and the small pleasures of clever toy problems. I would describe them as practical, sometimes peeved, often curious. To me, it feels like people are sorting their toolboxes and grumbling a little while discovering a few new shiny wrenches.

Cleaning up data and the small chores that never go away

There’s a humble, useful energy in posts about cleaning and shaping data. Alex Chan wrote about “Cleaning up messy dates in JSON” (11/17/2025). The piece walks through hunting all the little timestamp oddities in a blob of JSON — different formats, subtle timezone traps, machines that happily spit different styles. The author shares a Python script that finds and normalizes date strings. If you have ever wrestled with an API that calls one thing "2023-06-01T12:00Z" and another "06/01/2023 12:00 PM", you know the mood: part detective, part janitor. The analogy that stuck with me was a cutlery drawer full of spoons — they’re all spoons but some are teaspoons and some are ladles. You want uniform forks when you set the table.

Nearby is a practical post on iterator callbacks by Jonathan Hall (11/19/2025). He explains dealing with paginated REST results, proposing a pattern where the iterator yields items while a callback handles pagination metadata afterwards. It’s a small, elegant trick. It reminded me of doing the dishes: don’t stop rinsing plates while you wait for the slow pot to finish soaking. Both posts are about keeping a flow that won’t break when the real world throws messy input at you.

Tooling: code review helpers, copilot-like assistants, and the model economy

AI-powered tooling keeps showing up in different guises. Better than Random (11/17/2025) tried GitHub Copilot Code Review. The write-up is honest: Copilot’s Code Review is asynchronous and configurable, and it can suggest useful fixes — but it’s not a replacement for linters or a senior reviewer. It sometimes misses style violations or deeper bugs. I would describe Copilot’s review as an eager junior who knows many rules but not the local customs. Helpful, but you still need someone to explain the codebase’s peculiar rituals.

That idea — useful but fallible AI — threads through several posts. Ethan Mollick (11/18/2025) tracks the leap from GPT-3 to Gemini 3 and points out how AI has moved toward being a coworker rather than just a chat toy. The tone is excited but cautious: models are faster, better at code and data tasks, but human oversight is still essential.

Then there’s a sharper warning from Atilla Bilgic (11/22/2025) about LLMs as pattern machines. The piece explains why junior developers can be misled by confident-sounding AI outputs — because the models are excellent at pattern completion, not at actual reasoning about architecture or security. That post pairs well with Abdelkader Boudih (11/18/2025), who trash-talks new formats like TOON and advocates for the boring safety of JSON. Abdelkader’s experience — writing and then wiping a custom LLM instruction format after thousands of failed API calls — reads like a cranky, useful diary entry: test at scale, and don’t trust shiny formats.

On the model side, JP Posma (11/17/2025) highlights MiniMax M2 being free for a bit on Kilo Code and praises its interleaved thinking. That post felt like walking into a electronics shop and seeing a new radio with a good price tag. The ecosystem is noisy: new models, temporary free tiers, and lots of small promises. Use them, but test them, and don’t build a bridge on demo-day latency.

Language updates, breaking changes, and the work of staying current

A strong theme this week is the friction of language evolution. Trevoir Williams (11/17/2025) covers .NET 10 and C# 14 — LTS support, incremental improvements, and small, useful features like extension blocks and field-backed properties. It’s not flashy, but it smooths everyday work. But then Damien Guard (11/20/2025) rang the alarm: C# 14 breaks LINQ in places. Methods like Reverse and Contains are affected, and the tooling scuffle means you might have to rewrite calls to Enumerable. That’s the part that gets people grumpy: you update the SDK for a performance win and suddenly your well-used queries refuse to compile. The furniture gets moved and you can’t find the remote.

Swift also stirred the pot. Michael J. Tsai wrote two thoughtful pieces: one about attaching Xcode to multiple processes (11/19/2025), and another about Swift 6.2 making MainActor the default isolation mode for new app targets (11/20/2025). The latter sparked worry: defaulting to MainActor might push developers into surprising concurrency models, and split understanding across teams. It’s a classic tension: defaults are friendly for beginners, but they can confuse the seasoned dev who needs fine control. I’d say the vibe is wariness; the community wants helpful defaults, not hidden traps.

There’s also a heavy dose of nostalgia-meets-modern: Stephen Smith updated his Raspberry Pi Assembly book for 64-bit and modern OS expectations (11/18/2025). It’s a reminder that even low-level authors are adapting to new defaults.

Type systems, immutability, and the slow push for safer defaults

Type conversation was lively. Austin Gil (11/18/2025) walks through TypeScript generics and shows how to use constraints in JSDoc — practical tips to avoid the common 'length' or property-access errors. A small post, but it’s all about making types work where tooling is imperfect.

A more experimental tone comes from Evan Hahn (11/18/2025), who tries to make TypeScript immutable-by-default. That’s a big idea: treat values like Rust’s ownership model so mutation is explicitly opted into. Evan got arrays locked down but plain objects resisted. The write-up reads like a tinkerer’s lab book — useful fragments and open questions. If you’ve ever tried to make guests take off their muddy boots at the door, you’ll get the mental image: it’s easier to enforce a blanket rule with a coat rack than to control how everyone handles their shoes on the couch.

This week’s small pattern: people want safer defaults but keep tripping over legacy and ecosystem expectations. It’s one step forward, two careful refactors backward.

Low-level craft, algorithms, and the joy of the tiny problem

There’s a beautiful streak of low-level love. pmbanugo.me (11/17/2025) explains how to write a FIFO queue from scratch in Zig, with circular buffers and performance notes. It’s the kind of post that makes you want to try a tiny implementation in three languages over a weekend. Jeremy Kun (11/17/2025) digs deep into fully homomorphic encryption and bicyclic matrix multiplication — dense math, but practical for folks thinking about encrypted ML workloads.

Then there’s playful math: Susam Pal (11/20/2025) and Re: Factor (11/22/2025 and 11/21/2025) produce cosine- and Fourier-based approaches to FizzBuzz. Yes, FizzBuzz. People are taking a toy problem and showing you Fourier transforms and cosines to generate it. I’d describe it as proving a point with a sledgehammer, in the best way. It’s both clever and a little silly — like using a Maserati to run to the corner shop, but you learn something about how the car works.

Retrocomputing gets a look-in too. Chris Garrett (11/17/2025) tries building a 3D maze for the Commodore 64 with XC-BASIC, and Michael Coorlim (11/22/2025) refactors a TRS-80 Breakout game from 1983. These posts feel like tuning an old motorbike in the shed — satisfying and instructive.

Code quality, refactoring, and the long shadow of classics

Books and timeless reads were on people’s minds. Nicholas Wilt (11/19/2025) lists perennial technical reads — CLRS, Programming Pearls, Hacker’s Delight — and it’s a gentle reminder that some references age like good tools. Right next to that, Axol's Blog (11/18/2025) tears into the second edition of Uncle Bob’s Clean Code. The author liked some modernizations but criticized repeated poor examples. The piece rewrites a sample with better clarity, and it reads like someone insisting we can do better than our idols. That tension — respect for foundations, impatience with sloppy examples — is a recurring mood.

Also worth noting: posts like “Program Design and Engineering” by Paul Tarvydas (11/22/2025) revisit old ideas from Forth and immediate words versus modern tooling. There’s a pattern: some writers want systems that enable quick experimentation; others push for engineering rigor. Both matter, and both complain about each other in gentle ways.

Concurrency, observation, and the fine art of state

Apple platform writers had a lot to say. Nil Coalescing (11/21/2025) demonstrates how UIKit now handles automatic property observation through @Observable and updates in iOS 26 (backported to iOS 18). It’s the sort of change that quietly makes mixed UIKit/SwiftUI apps less fiddly. But there’s also the aforementioned debate over MainActor defaults by Michael J. Tsai. Both posts circle the same idea: the system is trying to take more responsibility for state updates, and developers are both relieved and suspicious. It’s like letting your car drive itself on the motorway — nice, but you’d better still keep your hands near the wheel.

Systems, databases, and architectural notes

On the systems side, Ari Seyhun (11/20/2025) walks through building an event-sourced app in Rust with SierraDB. The post focuses on aggregates, event persistence, optimistic locking — practical scaffolding for anyone building collaborative apps. It’s straightforward and useful. Meanwhile, Peeter Joot (11/21/2025) shares sample C++ module code, which is a reminder that language ecosystems keep layering on tools to cope with complexity.

There’s also a fun, fairly deep dive into how C’s trajectory accidentally pushed programming toward one paradigm by Paul Tarvydas (11/20/2025). He argues that ANSI C hardened function-based thinking and that languages should let programmers mix paradigms more fluidly. It’s argumentative in a way that invites you to imagine different kitchen layouts for cooking: sometimes an open plan is better than a one-stove galley.

Niche tooling and package managers

Janet’s new bundle manager “Jeep” by Michael Camilleri (11/19/2025) is a small, dedicated tool announcement. If you use Janet, this matters. The tone is pragmatic: fewer friction points for small-language users. Small languages and ecosystems keep nibbling away at their plumbing, and people who love minimalism celebrate these tiny wins.

Security, correctness, and the human angle

The recurring human throughline is responsibility. Whether it’s Abdelkader’s cautionary tale about custom LLM formats or Atilla’s piece on LLMs’ reasoning limits, authors are asking developers to not outsource judgment. The posts urge junior devs to build fundamentals. You can treat an LLM as a power tool, but don’t expect it to read the plans or check the load-bearing wall.

Little pleasures and the playful side of code

On a lighter note, there’s pixel art tips from JSLegendDev (11/17/2025). It’s not strictly programming, but it’s delightful: pick refs, limit your palette, think of pixel art as a puzzle. The post is practical, and it hints at the same idea that constraints breed creativity — a refrain that appears across code posts.

Also, the tiny wins: posts that take the simple and show another angle — cosine FizzBuzz, lazy FizzBuzz in Factor, or a TRS-80 refactor — are like finding a great coffee shop down a side street. You don’t need to change the world; you just get smarter and happier for an hour.

Agreement and argument: where people line up or diverge

A few clear agreements pop up.

• AI is useful but incomplete. People consistently recommend using it with caution. Read {Better than Random}, {Ethan Mollick}, {Atilla Bilgic}, and {Abdelkader Boudih} and you’ll see that pattern. They don’t all shout the same warning, but the chorus is there.

• Language and platform upgrades introduce friction. Whether it’s .NET 10’s small wins and C# 14’s breaking changes or Swift’s MainActor default, authors push back where defaults and breaking changes surprise teams.

• There’s still deep love for low-level craft. Zig queues, Raspberry Pi assembly, FHE matrix kernels — people still care about how things actually run on metal.

Where folks disagree is mostly tone and posture. Some posts lean into embracing new defaults (like features in .NET 10 or Swift observation), while others are skeptical and want conservatism (watch those defaults!). On tooling, some writers buzz about MiniMax M2 being free and useful, while others warn about untested data formats. Both views are valid — one’s optimism, the other’s caution.

If you want to dig deeper — places to start

If you enjoy practical fixes, go read Alex Chan for the date normalizer and Jonathan Hall for iterator callbacks. If you’re wrestling with language updates, Trevoir Williams and Damien Guard are a good pair: one lists the shiny parts, the other shows the tripwires. For AI sanity and tooling, check Ethan Mollick and Atilla Bilgic, and for a test-case horror story on inventing formats, see Abdelkader Boudih.

If your taste runs to the retro or low-level, don’t miss Chris Garrett, Michael Coorlim, and pmbanugo.me. If you want to be a little smug about fancy math applied to jokes, read the FizzBuzz cosine posts — they’ll make you laugh and think at the same time.

There’s a lot more tucked into the week’s feed — package managers for small languages, assembly updates, modular C++ experiments, and newsletter roundups for embedded Rust. Think of this week as a busy market: lots of small stalls, a few loud vendors, and a handful of gems if you poke around.

If you like the smell of fresh tooling and the sound of people arguing about defaults, dive in. The authors left useful breadcrumbs. Follow those links — each post gives a focused, opinionated take, often with code or examples. Read a couple and you’ll have one or two small projects to try and a dozen ideas you’ll keep thinking about on your next commute or when you make tea.