Newsletter #112
Enjoy Newsletter #112.
A few interesting modern pixel fonts
Marcin Wichary surveys a few modern pixel fonts built around interesting ideas. Andrew Gleeson’s Analog Mono “atones for the sins” of VCR OSD Mono, the classic pixel font seen across 1990s VCRs, TVs, and camcorders whose baseline sat so low that every character with a descender was pulled upward. Kumiko Yoshida’s Coral Pixels is a color font that deliberately preserves the characteristic color fringing of 1990s–2000s subpixel rendering: what used to be a technical artifact is now nostalgic material and an intentional visual element. Joseph Fatula’s Two Slice pushes minimalism to the extreme at just 2 pixels tall while remaining “barely readable.”
The author notes that all of these are vector fonts masquerading as pixels so they can be installed on modern operating systems, which leads to Vercel’s Geist Pixel. Although its marketing pitch is slightly grandiose, it hits on an important problem: pixel fonts often break when put into real products because they don’t scale well across screen sizes, their metrics clash with existing typography systems, or they are purely decorative. According to the author, the Achilles’ heel of many fonts lies not in the letterforms themselves, but in the “invisible” work around them such as kerning, metadata, extended character sets, and vertical metrics. The lesson for UI designers is that nostalgia can be a starting point, but integration stability is what determines whether a font is actually usable in a product.
The Best Engineers Write Less Code
The author pushes back against the idea that we no longer need to write good software because LLMs can generate code. Bad software is still bad software, whether written by Claude Code or an inexperienced developer: latency, complexity, and maintenance costs remain real, and there will be plenty of work cleaning up the low-quality code currently being pushed to production. Businesses measure everything in time, because time is money; that is also why they are excited about AI—it is faster and cheaper.
According to the author, the best thing an engineer can do for stakeholders is avoid building unnecessary things, since every feature carries long-term costs in maintenance, debugging, infrastructure, support, migrations, and cognitive load. On the path to becoming a senior engineer, you shift from “I can build that, it’ll take a few days” to “Why are we building this?”, and the second question is critical: code is a liability unless it solves the right problem. The worst outcome is building the wrong thing. The way to reduce risk is genuine Agile in spirit rather than ceremony: align on why the work is needed, adjust requirements to deliver value faster, and work in short intervals to show progress and gather feedback. Great engineers are measured not by the volume of code they produce, but by the value they deliver relative to the complexity they leave behind—and the best use of spare time is deleting code.
Fast is better than slow
Patrick Dubroy noticed that the best programmers he has ever worked with all share one trait: they are fast, often turning up with a patch or prototype an hour or two after discussing a problem. He argues that they aren’t fast because they’re good, they’re good because they’re fast: moving quickly gets you data sooner, leads to better decisions, compounds learning over time, and lets you try multiple approaches before picking the best one. This does not mean hustle culture or working overtime; there are many ways to speed up without putting in extra hours.
His advice has more to do with day-to-day software engineering habits than raw coding skill. Don’t procrastinate just because you aren’t sure where to start, as waiting rarely makes the task easier. Make use of small pockets of time instead of waiting for long uninterrupted blocks, since fragmentation can eat up 25–35% of your day. Don’t be afraid to look silly: share work early using the “70% rule,” open a PR right away and welcome feedback instead of polishing endlessly, and proactively ask coworkers for help because software development is a team sport. Pick your battles: in code review, most disagreements are small enough that making the requested change is faster than arguing, and Dubroy himself often approves with “LGTM with comments.” Finally, build only what was asked for—trying to “overdeliver” usually means guessing at future requirements, and the less experience you have, the more likely you are to guess wrong.
Java Cheat Sheet
This is a quick Java reference by Bogdan Sandu focused on syntax, common patterns, and immediately applicable idioms. The material is organized into sections: data types and casting, operators, control flow, arrays, strings and StringBuilder, classes and objects, OOP concepts, access modifiers, the Collections Framework, exception handling, streams and lambdas, concurrency, I/O, and modern Java features. Helpfully, it doesn’t just list syntax—it also calls out classic beginner pitfalls like comparing String instances with ==, confusing array .length with string .length(), handling null, going out of array bounds, or concatenating strings in a loop instead of using StringBuilder.
For junior developers, a cheat sheet like this is well suited for a quick refresher when switching to Java from another language, or when recalling a standard API without wading through long documentation. Even so, it should be treated as an initial lookup map: it does not replace official docs, a deep understanding of the JVM, OOP, collections, and concurrency, or hands-on experience writing production code.
Swapping Go for Rust: 10x Cheaper K8s Ingress
Syed Ahmer Shah recounts cutting the AWS bill for a Kubernetes ingress layer from roughly $4,200 to about $390 per month. The original setup ran Traefik across 3 pods, averaging around 380MB RSS per pod (roughly 180MB idle, over 400MB under load), requiring t3.large nodes for headroom. The author attributes this to Go’s garbage collector, which optimizes for latency rather than memory footprint: in a proxy, every request allocates headers, buffers, and connection state, so under sustained load the GC rarely gets a “good moment” to clean up, whereas Rust frees memory deterministically as soon as values go out of scope. It is worth noting that this changed both the architecture and infrastructure (Envoy, smaller nodes), so it cannot be treated as an isolated benchmark of swapping languages alone.
Rather than rewriting Traefik, the team moved core proxying to Envoy (C++) alongside a small Rust service that took over custom routing logic previously living in middleware. The first week hit three incidents—not because of Rust, but because Envoy’s explicit configuration model differed sharply from Traefik’s annotation “magic.” After about three weeks, the ingress layer dropped from 3 Traefik pods at ~380MB RSS each to 2 Envoy pods plus the Rust layer at ~40MB per pod; node costs fell from roughly $340 to $30 per month. The takeaway isn’t “replace Go with Rust”: Go remains a great fit for APIs, CLIs, and standard microservices, while Rust is worth considering for high-performance data planes. The migration took two engineers about three weeks, so if Traefik is working fine and the bill isn’t hurting, leave it alone.
Persistent multiplayer state without chaos
Julien Singler shares an architecture for maintaining consistent state in a live multiplayer game, where PostgreSQL holds the canonical data and Redis handles speed-critical operations. In a single-player game, state is relatively straightforward; but when multiple players can act on the same target simultaneously, scheduled jobs must finish on time regardless of who is online, and players returning days later expect their progress intact, state becomes the hardest problem. Keeping critical data only in memory or flushing to disk only on logout easily leads to lost progress or economy bugs.
The Go backend is structured into handler, service, and repository layers. Every critical state change goes through a PostgreSQL transaction as the single source of truth. Read-heavy data is fetched from Redis first, falling back to PostgreSQL on a cache miss, and the cache is invalidated on writes before returning success so players never see stale state. Redis holds only rebuildable state such as caches, online presence, and short-lived locks: distributed locks via SetNX ensure periodic jobs run only once across multiple backend instances (though bare SetNX alone does not guarantee exactly-once processing if a crash or lock expiration occurs). Scheduled jobs rely on an indexed finishes_at column rather than scanning every player every minute, and per-player mutations use SELECT ... FOR UPDATE inside transactions instead of a custom lock manager.
We’re in the Over-engineering Game Now
Peter Clark writes that he spent his entire career priding himself on scoping projects to minimize engineering effort while maximizing flexibility, since engineering time is a software company’s scarcest resource. Yet he also loves product design and polished details, leaving him constantly torn between wanting to craft things more carefully and worrying about wasting resources. Now, using Claude and Codex on personal projects, he happily “over-engineers”: his blog has a dynamic changelog, a “vibe meter,” an MCP that generates weekly roundups, and hundreds of other ideas he tried and threw away.
His central thesis is that AI coding blurs the line between over-engineering and simply finishing a product well. His iOS app no longer starts as a bare-bones MVP, but launches feature-complete with built-in feedback loops that trigger agentic workflows. Improvements that used to languish forever in the backlog because they were never high enough priority—or too small to even file a ticket for—can now be iterated on and polished continuously. He argues this shift will raise user expectations: when building good software becomes nearly free, clunky products will be much harder to excuse. Rather than merely an era of vibe coding or apps for an audience of one, he believes we are entering a phase where product vision is no longer bottlenecked by engineering resources, leaving only one question: what do you actually want to build?
Package managers that package package managers
Andrew Nesbitt built a matrix mapping which package managers can install which other package managers. The idea started from a strange loop: PyPI has a package containing the Node binary, and npm has a package containing a portable CPython build, meaning pip install and npm install can hand control back and forth indefinitely. Covering 42 clients using data from ecosyste.ms for language registries and Repology for Linux distributions, the densest rows belong to system package managers like AUR (40/42), nixpkgs, Homebrew, DNF, and Debian, since packaging arbitrary binaries is their job; as columns, however, they are nearly empty because nobody needs to redistribute apt or DNF when they ship with the OS. Conda sits between the two worlds, while PyPI is the most prolific language registry because cross-language tools like Conan and Meson are written in Python.
The post also highlights notable software supply chain implications. Twenty-five of the 42 tools publish themselves through their own registry. A CVE in pip might be tracked under pkg:pypi/pip or pkg:deb/python3-pip, but copies of pip inside Homebrew, conda-forge, nixpkgs, or Spack carry the same vulnerability and each ecosystem must map advisories on its own, making upstream vulnerability tracing much harder. Searching by package name is also unreliable because short names on flat-namespace registries are often squatted by unrelated projects, whereas reverse-linking to the source repository yields cleaner matches. Finally, the author constructs a 14-step installation chain stretching from an Arch Linux machine to the Elm compiler.
Beyond the Prompt: Claude Code
Arpan Patel writes an extensive guide to using Claude Code as a workflow-driven agent rather than a prompt-in, code-out chatbot. The core focus is building feedback loops so Claude can verify its own work: reading code, planning, editing, running tests, reviewing, and updating its rules whenever it makes a mistake. The author recommends exploring before coding, using plan mode for multi-file changes, pointing directly to files or logs instead of giving vague descriptions, and delegating tasks the way you would to an engineer rather than micromanaging every small step.
A standout section covers organizing the .claude directory: CLAUDE.md for shared project rules, CLAUDE.local.md for personal notes, alongside settings, MCP servers, skills, commands, rules, and subagents. CLAUDE.md should stay concise like a guardrail—containing only rules that genuinely prevent mistakes rather than documenting the entire codebase—while recurring workflows should be turned into reusable skills, commands, or subagents in the repo. For larger teams, plugins, MCPs, and subagents help isolate context, run independent reviews, and execute parallel streams of work, delivering the most value when baked into shared onboarding rather than kept as personal tweaks.
How’s Linear so fast? A technical breakdown
Dennis Brotzky breaks down why Linear feels instantaneous despite being a client-side web application. The core idea is that Linear removes network latency from the primary interaction path. The data the UI reads is already in the browser, primarily via IndexedDB and an in-memory object pool; mutations are applied optimistically locally first, written to a persistent transaction queue, and then synced to the server. The server acts as an arbiter that acknowledges changes and broadcasts deltas back, rather than something the UI waits on before responding to the user. At runtime, MobX enables fine-grained updates so each delta re-renders only the specific fields and components affected rather than an entire list.
The post also dives into initial load performance, where speed comes from compounding small details: trimming JavaScript and CSS payloads, targeting only modern browsers, aggressive code splitting, preloading modules to avoid waterfall requests, service worker caching, preloading fonts with the proper crossorigin attribute, embedding an app shell, and rendering local data before background authentication finishes. Beyond engineering, speed comes from product design: every action has a keyboard shortcut, the command palette is always one keystroke away and runs against local data, and animations are brief and stick to cheap properties like transform and opacity. Performance is thus as much about user perception as it is about raw engineering.
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.
Comments