Programming: Weekly Summary (November 24-30, 2025)

I would describe this week in programming blogs as a messy stew — comforting in parts, too salty in others, but full of bits worth picking out and chewing on. There are posts that feel like workshop chatter, posts that read like letters from people learning new tools, and a few that are straight-up grumbles about the state of the trade. If you like poking at language design, tooling, career hygiene, and the odd retro-nerd hobby, this batch has something for you. I’d say it leans a little nostalgic and a little anxious, and sometimes both at once.

Language moods: Lisp, Rust, TypeScript and the old guard

There are two clusters here that keep nudging at each other. One is a soft hymn to strange, older ideas — Lisp, macros, the pleasures of small languages. The other is a set of reactions to modern language trends: Rust’s rise, TypeScript’s friction, and the feeling some people have that tooling is getting more corporate and less friendly.

If you like Lisp, Red Planet Labs and Noel Rappin are both poking that sore spot where mainstream practice meets Lisp’s different worldview. Red Planet Labs uses the Flatland metaphor — programmers stuck seeing only a plane — to make a point about superstition in tool choice. It’s a cozy picture: macros are like a hidden dimension, and to ignore them is, well, living in two dimensions when three are waiting. Meanwhile, Noel Rappin traces Lisp’s influence on Ruby and reminds the reader that parentheses are not the enemy; they’re a different rhythm. To me, it feels like hearing two old friends argue gently about whether vinyl sounds better than streaming — both right in places, both stubborn.

On the other hand, dorinlazar_ro huffs about Rust with a very particular flavor: it’s a language that has been weaponized by corporate interests, according to the piece. The author remembers earlier, more idealistic days of open source and argues the modern complexity undercuts hobbyist contribution. It reads like someone grumbling that the local bakery now sells artisanal sourdough at a price that puts a dent in weekend pocket money. There’s some truth and a fair amount of emotion there.

Then there’s the quieter but earnest “finally learning Rust” log from matthew_brunelle. It’s the other side of that coin — not a manifesto, but a personal campaign to learn something hard. The tone is different: less culture-war, more “okay, time to actually do the work.” That contrast is fun. One post sees the language as a symptom; the other sees it as a problem to solve for oneself.

TypeScript gets a short, salty rant from maybe_ray@mayberay.bearblog.dev. The author expected a miracle and got something more like a fancier traffic cone — useful in places, awkward in others. The take: TypeScript can be useful, but its safety promises are not always fulfilled in practice, particularly around exceptions and nulls. It’s very much a marmite opinion — people will either nod vigorously or roll their eyes.

Finally, there’s a small practical fragment from Luca Ferrari — a dive into Perl Weekly Challenge solutions that are delightfully polyglot (Raku, PL/Perl, Python, PL/Java). These posts are like postcards from people who still enjoy tooling diversity. The message there is simple and familiar: solve puzzles, keep your skills sharp, learn new languages by doing tiny, actual work.

Learning, craft and the hum of practice

A clear current runs through a handful of posts: practice matters, and not the flashy kind. If the internet had a gym, these authors are the people telling you to stop doing 10,000-situps-of-the-day and to go lift something real.

Juha-Matti Santala sings the Advent of Code hymn again, now trimmed down (50 to 12 puzzles this year). The point — and it’s a good one — is that a small, steady practice beats panic cramming. Advent of Code is cast as community glue and a learning mechanism. It’s like a neighborhood soccer pitch where people show up regularly; you get better by playing, not by buying shin pads and reading tactics articles.

James is direct: avoid interview prep courses. He paints a bleak jobs market — fewer roles, layoffs, and people hawking miracle courses. The advice is blunt and practical: build a routine, keep a practice journal, tailor your practice. That bit about a journal keeps echoing in these posts. It’s not glamorous, but it’s the difference between a collection of polished one-off solutions and a visible track record.

andrew_quinn offers a counterintuitive nugget: messy, long-lived projects are valuable signals for juniors. Employers fear false positives — someone who looks polished but isn’t — so a messy project that runs and breathes proves stamina. It reminded me of the person who keeps an old, battered car and can fix it themselves; it tells you something that a showroom model cannot.

There’s a philosophical sibling to these ideas in imapenguin’s “First Principles.” The core: learn the basics before you rely on AI. The post folds Dorothy Vaughan’s story into a broader point: expertise is built on foundations, not shortcuts. It reads like being told to learn how to change a tyre before buying a car with self-driving hype plastered to the windshield.

And then tsvibt rails against the “Ease Disease” — a cultural drift where people prefer simple shiny things over effortful craft. The author uses Portuguese pavement as a metaphor: real art takes labor. This is not just romanticizing hard work; it’s a warning that easy paths can leave you shallow. A theme repeats: slow, real, often unglamorous practice beats quick fixes. It’s said a few times in different ways, and it’s said that way because it matters.

AI, determinism, and prompt hygiene

AI is woven through several posts, with a mix of optimism and caution. The tenor is: AI helps, but don’t hand over the keys without understanding the engine.

Kyrylo Silin argues that AI amplifies programmers, not replaces them. The simple point is this: software solves human problems, and AI can’t invent those problems. That’s a nice, human-centered take — AI is a power tool, not a new species of developer.

That said, jack_vanlightly dives into something more technical: determinism in durable execution systems (Temporal, Restate, DBOS, Resonate). This is the sort of post that matters if you’re building systems where re-execution must produce the same control flow. The author breaks down where determinism is required and where idempotent side effects are enough. It’s a bit like explaining which parts of a recipe must be done exactly every time and which can be fiddled with (a spoonful of spice here or there) without ruining the stew.

indiantinker gets practical about prompt engineering and introduces DSPy (Declarative Self-improving Python) as a way to make LLM apps more reliable. The post is pragmatic: structure your prompts, separate roles, use signatures and modules. It’s a toolbox for people who want robust LLM behavior without doing the same trial-and-error dance forever.

There’s tension between “use AI to speed up” and “understand the underlying thing.” imapenguin and Kyrylo Silin both touch that seam. And then nikita_prokopov@tonsky.me throws a different, practical worry into the mix: hiring in 2025 means your test assignments might get flagged as AI-written. Make your work human: rough edges, realistic mistakes, perhaps even the odd comment that smells like a person. That’s a maddening piece of advice but also oddly freeing: if you want to pass their detectors, produce the kind of human work that detectors search for.

And on a lighter, playful note, memaligngithubio shows how AI (ChatGPT) can be used to make casual games like Wolfers. It’s a reminder that AI isn’t only for enterprise-grade things: it’s also good for making dinner-party entertainment or a new family board game.

Tooling, infra and the small things that matter

Bits of the week celebrate the plumbing. These posts are for people who like to know how wheels turn.

Bart Wullems walks through building an MCP server in C#. It’s practical, stepwise, and reminds you that exposing resources (static and templated) is often more about conventions than wizardry. It’s the sort of post that reads like a gentle how-to: do this, add that package, test with a tool called MCP Inspector. Simple, useful.

Ian Duncan breaks down JSON Schema. This one is useful if you ever wrestle with data validation. Dialects, vocabularies, metaschemas — it’s all disambiguated without being dry. Think of it like learning the different types of screws before you build a bookshelf. You’ll be glad you did.

There’s also a lovely niche piece from Ryan Liptak about Windows drive letters beyond A-Z. It’s the kind of thing that makes you smile if you’ve ever typed something weird into a terminal and wondered why the world didn’t explode. The post digs into Object Manager, symbolic links, and non-ASCII letters. Fans of OS internals will like this little rabbit hole.

On the theoretical side, Philip Zucker writes about union-find variants (primitive, leveled, quantifier union-finds). It’s dense in places but also fascinating if your brain likes gluey algorithmic structures that help type inference and equational reasoning. These are the kind of topics that live in the attic of programming theory — not flashy, but they keep the lights on.

And then there’s Alex Kladov with a thoughtful bit on size: functions, files, and “inverted hourglass” shapes. The opinion is mild but precise: size matters in relation to interface, and screen real estate subtly shapes how we write code. The post is the type that makes you think twice before carving an enormous public API without a narrow waist.

Craft and nostalgia: retro computing and small joys

A few pieces in this set are pure sentimental joy. They’re reminders that programming is sometimes about toys as much as systems.

Chris Garrett adds compiled ZX Spectrum BASIC to an online retro IDE. It’s a hands-on, geeky delight: inline assembly, user-defined functions, compiling to .Tap files. If you grew up with old microcomputers, this post is like discovering a dusty box of cassette tapes under the bed and finding your childhood in good shape.

Michael Coorlim does the C64 Burrow.BAS reconstruction. There’s a tactile pleasure here: poke, peek, color flashes on screen, the sweet smell of hobbyist computing. These posts are little time machines. They’re not trying to change the world; they’re trying to re-open a window to an earlier, messier kind of fun.

Luca Ferrari and the Perl Weekly Challenge also feed this itch for craft-through-practice. Those micro-challenges are the programming equivalent of crossword puzzles or Sudoku. They keep the edges of the brain sharp.

Hiring, signals and the uneasy job market

Two themes keep colliding here: hiring processes that fear AI, and the scarcity of roles.

James warns against the snake-oil of interview-prep courses. The market is tough; people are anxious; influencers sell quick security. The antidote the author pushes is steady practice, not shortcuts. It’s a repeat of the learning themes above, but with direct, job-market urgency.

Nikita Prokopov writes about hiring in 2025; the twist is that too-perfect test assignments may be black marks. Employers may suspect AI or outsourcing if work looks too clean. So there’s an odd new signal in the hiring game: embrace the human scratch, let your code show the fingerprints of a real person. It’s almost tragicomic — presentable but imperfect work may be more honest and more valuable.

The hiring posts and the “courage to quit” essay from andrew_quinn intersect nicely: employers want signals that show human effort and curiosity. A messy, long-running side project signals that; a polished one-off may not.

Shape of agreement and argument

Across these posts there are a few repeated beats. Some of them agree; some of them spar. Here’s the shorthand:

• Agreement: Practice matters. Real, long-term engagement beats quick fixes. Advent of Code, journaling, and long messy projects all get the nod. The chorus is loud and steady on this.
• Argument: Is modern tooling an improvement or a barrier? Rust is the poster child for this debate. For some authors it’s necessary, for others it’s evidence of corporate capture. The discussion is not resolved here.
• Caution: Don’t outsource basic understanding to AI. Use it, yes, but don’t stop learning fundamentals. Multiple posts echo this warning — in hiring, in durable systems, and in daily craft.
• Curiosity: Retro computing, odd OS details, and algorithms still delight people. There’s no shame in nerdy hobbies; they are small islands of joy in a noisy sea.

These are not abstract claims. They’re specific, repeated in different idioms: recipes, toolchains, job searches, and even pavement stones. The variety helps. Hearing the same lesson from a systems engineer, a language fan, and a hobbyist feels more persuasive than a single sermon.

A few tiny, picky standouts you might not expect

• If you like regex and word boundaries, Artyom Bologov has a compact, thoughtful riff on “word” definitions and how text editors and programming languages should respect diverse naming conventions. It’s a small design nitpick but matters when you deal with identifiers across scripts and languages.

• Ian Duncan’s JSON Schema explainer is genuinely useful if you’ve ever wrestled with validation rules. It clears up a fog of terms.

• Philip Zucker’s union-find variants are for the intersection of logicians and compiler nerds. Read it if you enjoy deep, structural thinking about inference.

• Ryan Liptak’s piece on Windows drive letters reminds you that odd corners of real systems still surprise people. It’s a good reminder: not everything interesting is new.

If you want to go deeper

These posts feel like invitations rather than final words. Read Luca Ferrari for puzzle practice, Juha-Matti Santala if you want a gentle push into Advent of Code, and Jack Vanlightly if you’re building durable systems and need to think about determinism properly. For the cultural takes, dorinlazarro and matthewbrunelle present different relationships to Rust worth wrestling with. If hiring or interview craft is your worry, read James and Nikita Prokopov back-to-back — they’ll give you both the job-market reality and a weird new set of signals about what counts as human work.

There are some lovely rabbit holes too: ZX Spectrum compilation from Chris Garrett, C64 BASIC from Michael Coorlim, and the Union-Find deep dive by Philip Zucker. The week feels like a small flea market of ideas. Walk around slowly; you’ll find a few treasures.

It’s interesting how the same concerns keep showing up in different clothing: learning vs shortcuts, craft vs convenience, human signal vs machine polish. The arguments are not new, but the battleground is shifting — prompt engineering, AI suspicion in hiring, and language politics like Rust’s rise make the old debates feel new again. Like a radio station that keeps playing different covers of the same song, each author gives a different beat to the tune.

If one had to pick a mood for the week, it’d be a kind of restless warmth. People still love building things. They’re just a bit wary of the shiny, new shortcuts. The past calls, the future buzzes, and somewhere in between are the small daily practices that, stubbornly, still make someone into a better developer. Read the posts linked above if you want the details; they’re worth a proper sit-down with a cup of tea or a late-night snack. Some of them will annoy you, some will cheer you, and a few will quietly change how you write your next small program.