Enjoy Newsletter #42.

Challenging algorithms and data structures every programmer should try

Austin Z. Henley highlights six algorithms and data structures that are genuinely fun to build, have shown up in interviews, and reshaped how he thinks about software. Topological sort comes up whenever you need to order items with dependencies, such as task execution in a build system or cell evaluation in a spreadsheet. Recursive descent parsing maps each grammar rule directly to a function, letting you put together a working compiler for a small language in a few hours. The Myers diff algorithm is the default algorithm Git uses to compute clean differences between two versions of a file.

Bloom filters are a gateway into probabilistic data structures: using very little memory, a Bloom filter can tell you with certainty that an element is not in a set, or that it might be present—though Henley admits he has never needed one outside an interview. Piece tables represent editable text as a sequence of spans pointing into an immutable original buffer and an append-only add buffer, avoiding repeated full-string copies on every keystroke and making undo and incremental saves straightforward; VS Code uses a battle-tested variant of this design. Finally, Splay trees are self-adjusting binary search trees that move recently accessed nodes to the root without storing extra balance metadata, acting like a tree with a built-in cache that is far simpler to implement than a red-black tree. The post closes with honorable mentions like tries, segment trees, and union-find.

Everything I know about good system design

Sean Goedecke defines system design as how you assemble services like application servers, databases, caches, queues, and event buses—and argues that good system design usually looks boring: it runs quietly for years without anyone having to think about it. The hardest part of any system is state, because stateful components can get into corrupted states, so minimize the number of stateful pieces and make sure only a single service writes to any given database table. On the database side, align indexes with your hot queries, do JOINs in the database rather than stitching rows together in application memory, and offload read-heavy traffic to read replicas.

Slow operations should be split into the minimum synchronous work needed to respond to the user immediately, with the rest handed off to background workers via a queue. Caches are another source of state, so reach for them only after you have tried speeding up the underlying query; event hubs like Kafka are useful when multiple consumers genuinely need the same stream, but shouldn’t replace simple direct API calls that are much easier to trace. Goedecke also advises designing around your highest-load hot paths, logging richly on error branches, tracking p95 and p99 latencies, pairing retries with circuit breakers and idempotency keys, and deciding upfront whether a component should fail open or fail closed: rate limiters should usually fail open, while authentication must always fail closed. His takeaway: good design isn’t about clever tricks—it’s about putting boring, proven components in the right places.

AI Coding Agents are Already Commoditized

Sean Goedecke argues there is no “secret sauce” in AI coding agents. Back in 2023, he built an internal agent on GPT-3.5 and GPT-4 that required elaborate scaffolding just to keep the model on track; at the time, many assumed winning agents would need complex multi-agent swarms cross-checking each other or deep AST-level code indexing. In reality, all it took was a slightly smarter base model. Claude Sonnet 3.7 pulled ahead thanks to its ability to stay on task and make sound decisions over long horizons, while the surrounding agent harness is little more than a loop giving the model tools to read and write files.

That simplicity makes the agent market brutally hard to defend: open-source tools like OpenAI’s Codex CLI raise the baseline for everyone, while inference is interchangeable and switching model providers is trivial. Goedecke even wired up a working coding agent on GitHub Actions backed by GitHub Models—both free—in about 50 lines of YAML. In his view, the only durable ways to win are owning distribution, like GitHub’s built-in platform advantage, or training a frontier model and locking its best capabilities inside your own first-party agent.

Java, What’s Old? Part I: Collections

Anthony Goubard highlights hidden gems inside the JDK Collections framework—all available since Java 8 or earlier, so you can use them anywhere. Instead of boxing primitives with Optional<Integer>, Java provides OptionalInt, OptionalLong, and OptionalDouble. IntSummaryStatistics and DoubleSummaryStatistics track min, max, sum, count, and average in a single pass and can merge statistics across streams; Goubard discovered them during the One Billion Row Challenge. LinkedHashMap has a constructor flag that orders entries by access order rather than insertion order; combine that with overriding removeEldestEntry and you get a compact LRU cache that can be wrapped in Collections.synchronizedMap for multi-threaded access (though iteration and compound operations still require explicit synchronization).

WeakHashMap holds weak references to its keys so the garbage collector can evict entries once no strong references to a key remain; values are still strongly referenced, and because entries can vanish at any moment it isn’t suited for iteration or check-then-act patterns. Goubard uses it in his file manager Ant Commander Pro to cache formatted timestamp strings, cutting CPU usage while scrolling large tables. Finally, BitSet packs boolean flags at roughly one bit per value, grows dynamically, and exposes fast bitwise operations—using a fraction of the memory of boolean[] or List<Boolean>.

Challenging projects every programmer should try

Austin Z. Henley shares six challenging projects that taught him the most and that he revisits whenever he wants to learn a new language or framework. Building a text editor forces you to pick a text buffer data structure like a rope, gap buffer, or piece table, figure out how the cursor “remembers” its column across lines of different lengths, and implement undo/redo with the Command pattern alongside line wrapping. A 2D game like Space Invaders teaches rendering, the game loop, input handling, and managing entities with the Factory pattern. A compiler for a tiny language like Tiny BASIC—targeting whatever output language you already know—walks you through lexing, recursive descent parsing, abstract syntax trees, semantic analysis, and code generation. A mini operating system demystifies bootloading, memory management, paging, scheduling, and filesystems.

For an even steeper challenge, Henley suggests a spreadsheet—which combines the tricky parts of a text editor and a compiler with directed acyclic graphs (DAGs) and reactive evaluation—and a video game console emulator, starting with CHIP-8 before tackling the NES or Game Boy. Each project includes a checklist of concepts to learn and recommended reading, rounded out by community suggestions like building a relational database, a ray tracer, or a grep-style CLI tool.

Autonomous coding agents: A Codex example

Birgitta Böckeler distinguishes between two flavors of AI coding agents: supervised agents steered interactively inside an IDE (like GitHub Copilot, Cursor, or Claude Code) and autonomous background agents (like OpenAI Codex, Google Jules, or Devin) that work through a task in an isolated cloud environment and open a pull request. She gave OpenAI Codex a small ticket in the Haiven app—formatting the filter label "client-research" as "Client Research"—and published the full execution log. The agent read AGENTS.md and README.md, then ran repeated grep searches across keywords, wandering into node_modules three separate times without learning from the mistake before finally finding an existing toReadableText helper to extend. However, it failed to run the test suite, and its pull request broke two existing regression tests despite the fix itself being trivial.

From that experiment, Böckeler draws several observations. Agents increasingly rely on brute-force text search rather than structured code navigation. Pre-configuring the remote execution environment is critical, yet setting up all required runtimes and linters (Node, Python, Semgrep, Gitleaks) for cloud agents remains clunky. Across six runs of the same task on Codex, Jules, and Claude Code, every attempt produced working behavior, but only two reused the existing helper while the other four duplicated code. She closes by asking when a team is better off discarding a flawed agent PR outright rather than falling into the sunk-cost trap of fixing it up.

Implementing an Undo/Redo System in a Complex Visual Application

mlacast, lead developer of Alkemion Studio—a visual brainstorming and writing tool for tabletop RPGs—breaks down how he built a context-aware undo/redo system. Because users work across multiple distinct views such as the Board, the Editor, and Node panels, the core UX rule is that pressing undo should never silently revert something off-screen that the user cannot currently see. Every mutation is modeled as an Action class with undo and redo methods, while ActionGroup bundles related steps into a single undoable unit (such as deleting a Node and automatically removing its attached Tokens). A singleton ActionStore holds actions across two Action Volumes for performed and undone work, while a configuration file defines which action types are valid in the active view so the system can dynamically filter and sort the local undo/redo stacks by a global index.

Inspired by Docker, a container abstraction creates an isolated sandbox whenever the user opens a modal dialog: actions performed inside the modal can either be discarded on cancel or committed back into the main store like a database transaction. The trickiest part was preserving chronological order as users switch contexts, requiring the global index to increment and decrement carefully across creation, undo, and redo so the most recently redone action always sits at the top of the stack. The remaining limitation is cross-action dependencies, which the author plans to solve next with a declarative dependency graph.

The software engineering ‘squeeze’

Anton Zaides argues that for the past 10–15 years, software engineering offered the highest return on investment of any career for anyone willing to study hard for a year, with companies hiring almost anyone who could clear an interview bar. In his view, much of the day-to-day work wasn’t actually that hard, which produced a massive middle tier of average engineers now getting “squeezed” between a tighter market and AI automation. He candidly notes that many developers grew used to comfortable workloads and constant complaining, whereas newcomers in most other professions have always had to grind through tough, lower-paid early years to advance.

Even so, Zaides is optimistic about the long term: many startups launched by “vibe-coding” founders will find traction and need strong engineers to scale. To thrive, engineers need to add product-management instincts and design taste rather than waiting for detailed tickets to implement—because while the market has an oversupply of average developers, it still has a shortage of great ones. He advises unemployed engineers to experiment with modern AI tools and build solutions to real problems around them, while adding that there is no shame in changing careers: software engineering is once again a field for people who genuinely want to be in it.

Go is 80/20 language

Krzysztof Kowalczyk describes Go as an 80/20 language: it delivers 80% of the utility for 20% of the complexity, and most of the hate directed at Go comes from programmers who want 85% or 97%. Paraphrasing Rob Pike, he writes: “Nobody denies that 87% is more utility than 80%. The point is that those extra 7% of utility cost 36% more effort.” His examples include struct tags that are far simpler than annotations or macros, a standard testing package that fits in a few hundred lines of code while covering the essentials that take tens of thousands of lines in JUnit, goroutines that handle concurrency with a fraction of the complexity of async/await in C# or Rust, and built-in generic types like slices, maps, and channels that solved most day-to-day needs long before Go added user-defined generics.

Meanwhile, languages like C#, Swift, Rust, and even JavaScript keep accumulating features endlessly. There is a lower bound, of course: skipping enums is survivable, whereas skipping structs would make a language unusable. Every added feature imposes a tax on users—who must learn not just how a feature works, but when to use it and how to read teammates’ code that uses it, which is why Google needed a strict C++ style guide—and on compiler writers too: more than a decade in, the Swift compiler can still feel slow and fragile, whereas Go’s toolchain has been fast, cross-platform, and rock-solid since version 1.0.


This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.