Enjoy Newsletter #50.

There is No Memory Safety Without Thread Safety

Ralf Jung, a programming language theory researcher at ETH Zurich, argues that splitting “safety” into narrow categories like memory safety and thread safety isn’t very helpful. The property we actually need is that a program never triggers Undefined Behavior (UB)—meaning it cannot “break” the language’s own invariants. To prove the point, he presents a Go program that uses no unsafe operations yet still segfaults at address 0x2a (decimal 42): Go represents an interface value as a pair of a data pointer and a vtable pointer written in two separate instructions, so another thread can observe a torn state between the two writes, invoke the wrong method, and reinterpret an integer as a pointer.

Other languages take one of two paths to prevent this. Java, C#, OCaml, JavaScript, and WebAssembly accept a performance cost so that every program—even one with data races—preserves the language’s invariants; Rust and, more recently, Swift use a type system strong enough to rule out data races at compile time. Go takes neither path, so strictly speaking, the author argues Go is not a memory-safe language, even though in practice it remains much closer to safe languages than to C. The article helps developers understand what guarantees their language actually provides, especially when writing concurrent code.

I Know When You’re Vibe Coding

Alex Kondov says he doesn’t care whether code was written by hand, copied from a forum, or generated by an LLM; what he cares about is whether what gets merged produces the right result, whether teammates can understand it next quarter, and whether it can be modified cleanly. Lately, though, he can spot LLM-written code immediately—not from repetitive comments, but because it is written in a way nobody on the team would write it: rolling a custom HTTP client that handles every edge case when the project already has a data-fetching library, reimplementing utility functions that already exist in another module, mutating global configuration instead of using module-scoped mechanisms, or writing classes in the middle of a functional codebase. The code works, reads clearly, and has tests, yet completely ignores the conventions the team agreed on.

He compares it to a panicked new barista spilling coffee while the line grows out the door: customers still want a good cup even if they have to wait a moment longer. Speed is not the highest virtue; the real challenge of software has always been maintaining it over years. His advice is concrete: write better prompts, provide clearer descriptions, specify which libraries to use, give examples for the model to follow, keep files small, and stick to established patterns. Don’t outsource the maintainability of your codebase to a model’s weights.

The 7 Most Influential Papers in Computer Science History

Terrible Software puts together a subjective chronological list of the seven papers that have shaped modern computing the most. It opens with Alan Turing’s “On Computable Numbers” (1936), which introduced the Turing machine and defined what machines can and cannot compute; next is Claude Shannon’s “A Mathematical Theory of Communication” (1948), which founded information theory and laid the groundwork for data compression and error-correcting codes. In 1970, Edgar F. Codd introduced the relational model, leading to SQL and relational database systems; in 1971, Stephen Cook proved that SAT is NP-complete, creating a shared language for reasoning about computational hardness.

The remaining three papers underpin the internet: Vinton Cerf and Robert Kahn’s TCP protocol (1974), which stitched isolated networks into a global internet; Tim Berners-Lee’s “Information Management: A Proposal” (1989), which laid the foundation for the World Wide Web with hyperlinks, URLs, and HTTP; and Sergey Brin and Larry Page’s 1998 paper introducing PageRank, treating links as votes of trust to form the foundation of Google. The author also gives five honorable mentions: John McCarthy’s paper on Lisp, Dijkstra’s “Go To Statement Considered Harmful,” Leslie Lamport’s paper on logical clocks, Fred Brooks’s “No Silver Bullet,” and “Attention Is All You Need.” The overarching message: amid waves of new technology, understanding the foundations still matters.

Programming Vehicles in Games

Wassim (Wassimulator), drawing from his talk at the Better Software Conference, shares the core principles of programming vehicles in games. The starting point is that a game is not a physics simulator—it is an experience: Mario Kart and iRacing both simulate cars but prioritize very different feelings, so the first question is what experience you want to convey. The author’s first game, AV-Racer, relied entirely on hacks and “magic numbers”; it was fun enough, but broke down on edge cases, teaching him that you cannot bend reality convincingly unless you first understand what reality you are bending.

The model he proposes consists of three components connected by feedback loops: the engine and transmission, which is essentially a torque calculator driven by RPM; the wheels and tires, where forces between the tire and road are generated; and the chassis, which is just a rigid body in the game’s physics engine. Engine RPM and wheel rotation speed pull each other toward equilibrium through two differential equations solved sequentially each frame. Longitudinal tire force depends on slip ratio, lateral force depends on slip angle, and both can be approximated using Hans Pacejka’s “Magic Formula.” Because a tire only has a finite friction budget, a car cannot brake at full force and corner at maximum grip simultaneously. Once the tire model is right, phenomena like understeer and oversteer emerge naturally without being hardcoded.

Periodic Table of System Design Principles

Joy Arulraj (Georgia Tech) proposes a “periodic table” of computer system design principles. The problem he identifies is that system design is typically taught in silos—databases, operating systems, computer architecture—each with its own vocabulary, causing the exact same principle to appear under different names. For example, relaxing consistency to gain performance shows up as isolation levels in databases, weak memory ordering in hardware, and eventual consistency protocols in distributed systems; newcomers end up relearning the same trade-off in every domain.

From more than 100 influential papers, the author distills over 40 principles that meet two criteria: abstract enough not to be tied to a specific technology, and general enough to recur across multiple domains. The principles are grouped into eight categories such as Structure, Efficiency, Semantics, Distribution, Reliability, and Security, with each principle given a short symbol like Co for composability or Op for optimistic design. By focusing on design intent rather than specific mechanisms, the table helps students build a coherent mental map, helps researchers position their contributions more precisely, and helps engineers discuss cross-cutting design trade-offs more clearly.

Curing Your AI 10x Engineer Imposter Syndrome

Colton recounts the anxiety of watching social media constantly claim that AI-assisted engineers are now 10x to 100x more productive. After seriously testing Claude Code, Cursor, Roo Code, and Zed, he found AI to be merely “fine”: good at boilerplate—especially in React—but bad at following project conventions, still prone to hallucinating libraries, and struggling with the context of large codebases. Mathematically, 10x productivity would mean finishing a full quarter’s workload in about a week and a half, which would require product ideation, code review, testing, and deployment to also run 10x faster—something that simply doesn’t happen. AI delivers short bursts of speed, like writing a one-off ESLint rule, and those bursts do not compound across the whole job.

According to the author, “10x” claims come from people measuring the wrong things, people with a financial stake in AI, or executives who want employees to feel replaceable. A true “10x” engineer, if such a person exists, is someone who prevents unnecessary work from being done in the first place—something AI rarely does, and in fact actively worsens by making overbuilding easy. He also argues that it is completely fine to trade a bit of productivity for enjoying your craft, since forcing yourself to work in a way you hate only leads to burnout. His conclusion: you aren’t missing out on anything; trust yourself, you’re already doing fine, and spend less time on LinkedIn.

Demystifying Claude Code Hooks

Aaron Brethorst, a developer with 20 years of experience, found the official Claude Code hooks documentation hard to follow, so he wrote this guide explaining three key concepts through a practical example: running RuboCop and RSpec on a Rails project before every commit. First, hook configurations live in ~/.claude/settings.json for global behavior (best used sparingly) or .claude/settings.json per project, checked into the repository so every team member shares the same automated checks. Second, to catch every file-editing operation, use the regex matcher "Edit|MultiEdit|Write". Third, put hook logic into dedicated scripts inside a folder like claude-hooks rather than cramming unmaintainable one-liners into JSON. The hook below (note that current Claude Code docs describe hooks receiving JSON via stdin) reads the $CLAUDE_TOOL_INPUT environment variable (a JSON string describing the tool about to run), uses jq to extract the command field, and invokes the check script only when the command starts with git commit:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "if echo \"$CLAUDE_TOOL_INPUT\" | jq -r '.command' | grep -q '^git commit'; then ./claude-hooks/precommit.sh; fi",
            "timeout": 180
          }
        ]
      }
    ]
  }
}

The author also shares debugging tips: create a PostToolUse hook that dumps the entire input JSON to a file so you can see exactly what data Claude passes, and use the /hooks command to inspect and edit your configuration. In his view, hooks turn Claude Code from a chat assistant into a development workflow orchestrator, giving the entire team consistent quality checks checked right into the codebase.

What the Hell is GetOpaque in Java

This article demystifies VarHandle’s getOpaque() and setOpaque() in Java, an API with notoriously sparse documentation. The Javadoc states only that these operations access a variable “in program order, but with no assurance of memory ordering effects with respect to other threads.” In plain terms: opaque operations on the same variable cannot be reordered with respect to each other, but operations across different variables can. The author demonstrates this with JCStress tests running on a Google Axion ARM VM: a reader thread can observe the new value of b before the new value of a even though a was written first—something that does not show up on x86 or when upgrading to acquire-release mode. According to Doug Lea’s guide, opaque mode corresponds to relaxed ordering in C++ and Rust.

Opaque mode is suitable when sharing a single independent value across threads, such as a primitive or a reference to an immutable object; classic examples include signaling worker threads to stop or publishing progress counters. Unlike plain mode, it prevents the JIT compiler from hoisting a stop-flag check out of a loop or caching writes in a register. However, using opaque mode to publish references to objects with non-final fields is unsafe because it establishes no happens-before relationship; experiments show reader threads occasionally observing partially constructed objects. JMH benchmarks also show that opaque reads are barely any faster than volatile. The conclusion: opaque has valid niche uses but is too weak for most scenarios, and even when it is safe, volatile is usually the better choice.

How Far Can We Push AI Autonomy in Code Generation?

On Martin Fowler’s site, Birgitta Böckeler recounts an experiment testing whether AI can autonomously generate and maintain a working application without human intervention. The team picked a straightforward target—a Spring Boot CRUD API—using mainly Claude Sonnet 3.7 and 4 in Kilo Code, and iteratively applied strategies to improve reliability: choosing a popular tech stack, splitting the workflow across specialized multi-role agents, including code examples in prompts, providing a reference application as an anchor, running generate-and-review loops, and modularizing the codebase. With 3–5 entities, each run took about 25–30 minutes and usually produced a working app; with a 10-entity schema, runs took 4–5 hours and required repeated human intervention.

Despite improvements, the process still felt like playing whack-a-mole: every run introduced new issues. The AI invented unrequested features, guessed values when requirements were ambiguous, applied band-aid fixes, declared success while tests were failing, and left behind numerous issues flagged by SonarQube. The conclusion is that even for a simple application backed by extensive scaffolding, AI is not yet ready to autonomously maintain enterprise software without human oversight. Practical takeaways that do transfer immediately include building reusable prompts, exposing reference applications via MCP, leaning on static analysis, and maximizing deterministic tools like scripts and codemods.

Onboarding for Coding Agents

Matt Holden explains how he trimmed his CLAUDE.md file from hundreds of lines down to just 13. Because every AI tool looks for context in a different place (.cursor/rules, CLAUDE.md, AGENTS.md, etc.), he moved all project context into README files—a format that has been universal for 50 years and isn’t tied to any vendor. Instead of one massive README, he uses a convention of README.md for the high-level overview and README.<domain>.md for specific areas like architecture, dev commands, design system, or testing. The mental model is onboarding: every new Cursor or Claude Code session is like a new hire joining the team with zero context, so write down whatever you would want a new engineer to read before their first task, and instruct the agent to read all **/README.md and **/README.*.md files at the start of a session.

The second pillar is “Quality Gates”: instead of listing formatting rules in a prompt, he encodes constraints into the environment through tooling, instructing the agent not to finish until type checks, formatting, linting, and unit tests all pass. LLMs are bad at counting spaces or sorting imports by eye, but great at running tools and fixing errors until the build goes green, allowing modern models to run their own OODA loop (observe, orient, decide, act). He also sets a strict rule against letting AI “vibe code” the environment: humans decide the tech stack, libraries, database, and design system, while the AI works inside those guardrails.

Why Java is Still Worth Learning in 2025: A Developer’s 25-Year Journey

Markus Westergren looks back on his 25-year journey from Java skeptic to advocate. When he first encountered Java in 1999 after working in assembly and C, he found it sluggish and untrustworthy due to automatic memory management, sticking with C for the first eight years of his career. Everything changed when he studied for the SCJP 6 certification and realized how much the language had matured. In his view, Java’s greatest strength is evolving to reduce cognitive load: from generics that make collection types explicit, to records, sealed interfaces, pattern matching for switch, and virtual threads in modern Java. Backward compatibility is equally valuable: an enterprise application he helped migrate from Java 1.4 to Java 7 now runs on Java 21 without a major rewrite, meaning skills learned today stay relevant for decades.

The Java ecosystem is diverse without being fragmented, offering multiple JDK distributions (Oracle, Azul Zulu, Red Hat, Amazon Corretto), mature frameworks (Spring Boot, Quarkus, Jakarta EE), and build tools (Maven, Gradle). For newcomers, he advises starting directly with Java 17 or 21, mastering object-oriented fundamentals, the collections framework, exception handling, and basic concurrency, building real projects, engaging with the community, and getting comfortable with Maven, JUnit, and Spring Boot. In short, Java in 2025 offers something rare: stability without stagnation, and innovation without disruption.

Why You Should Rethink Legacy and Consider Event-Driven Architecture

James Moore of Scott Logic argues that we need to redefine “legacy”: the problem isn’t a system’s age, but whether it is slowing the business down. Modernization shouldn’t be a knee-jerk reflex, but a strategic decision grounded in clear business value; a legacy system that runs reliably and can be modified at a predictable cost doesn’t need to be replaced yet. Instead of a risky, expensive big-bang rewrite, a coexistence strategy lets the legacy system keep running while new capabilities are built alongside it.

Event-Driven Architecture is a practical way to execute that strategy. For example, suppose a legacy user-registration system doesn’t send welcome emails; rather than modifying the old codebase, you can use Change Data Capture (CDC) to watch the database, publish a UserSignedUp event to a broker like Kafka or RabbitMQ, and have a new email service subscribe to that event while the legacy system remains completely untouched. This decoupling makes scaling easier, enables parallel asynchronous processing, isolates failures in new services from core transactions, and improves testability and observability. The approach isn’t a silver bullet—it fits poorly with complex stateful workflows or tightly coupled processes, and older databases may require custom CDC solutions—but in many cases it offers a low-risk, cost-effective path to gradually replacing a legacy core via the Strangler Fig pattern.


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.