<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Programming Languages on miti99</title><link>https://miti99.com/en/tags/programming-languages/</link><description>Recent content in Programming Languages on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/tags/programming-languages/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #106</title><link>https://miti99.com/en/post/2026/05/28/</link><pubDate>Thu, 28 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #106.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-the-heck-does-gps-work-an-interactive-exploration"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-gps-work" rel="noopener noreferrer"&gt;How The Heck Does GPS Work? (An Interactive Exploration)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shri Khalpada&amp;rsquo;s interactive explainer shows that GPS is fundamentally a machine for turning time into distance. Satellites broadcast radio signals at the speed of light, your phone measures how long the signal took to arrive, and each nanosecond corresponds to roughly 0.3 meters. One satellite tells you that you lie somewhere on a sphere (or circle in 2D), a second narrows it to two intersection points, and a third pins down a single point — a method called trilateration. The catch is the clock: satellites carry atomic clocks, while your phone only has a cheap quartz oscillator, and a drift of just a few microseconds throws your position off by hundreds of meters. That is why a fourth satellite is required: there is only one clock-offset correction that makes all four spheres intersect at a single point, allowing the receiver to solve for both exact position and exact time simultaneously.&lt;/p&gt;
&lt;p&gt;Then comes the &amp;ldquo;relativity tax&amp;rdquo;: because satellites move so fast, their clocks tick about 7 microseconds slower per day (special relativity), but higher up in weaker gravity they tick about 45 microseconds faster (general relativity). Left uncorrected, positions would drift by roughly 10 km per day, so satellite clocks are engineered to tick slightly slower before launch on the ground. In practice, modern receivers lock onto 8–12 satellites at once across GPS (US), GLONASS (Russia), Galileo (EU), and BeiDou (China) to reduce error; in dense cities, signals bouncing off buildings (multipath error) remain the hardest problem.&lt;/p&gt;
&lt;h2 id="if-ai-writes-your-code-why-use-python"&gt;&lt;a href="https://medium.com/@NMitchem/if-ai-writes-your-code-why-use-python-bf8c4ba1a055" rel="noopener noreferrer"&gt;If AI Writes Your Code, Why Use Python?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Noah Mitchem argues that the decade-long &amp;ldquo;bargain&amp;rdquo; — picking Python or TypeScript for their huge ecosystems, easier hiring, and fast prototyping while accepting 10x to 100x worse performance than Rust, Go, or C++ — has expired, because AI has gotten good at the hard languages. By April 2026, Claude Opus 4.7, GPT-5.5, Gemini 3.1, and DeepSeek V4 all topped 80% on SWE-bench Verified. The strict type systems and tight compiler feedback loops of Rust and Go let agents iteratively self-correct. The proof is already here: Microsoft ported the TypeScript compiler to Go (roughly 10x faster); Nicholas Carlini at Anthropic orchestrated 16 Claude agents to write a 100,000-line C compiler in Rust across nearly 2,000 Claude Code sessions for under $20,000; and Andreas Kling ported Ladybird&amp;rsquo;s JavaScript engine from C++ to Rust in two weeks — roughly 25,000 lines with zero regressions.&lt;/p&gt;
&lt;p&gt;Even the Python ecosystem is increasingly a &amp;ldquo;Rust ecosystem wearing a Python hat&amp;rdquo;: pydantic, polars, tokenizers, and orjson are all written in Rust; OpenAI acquired Astral (uv, ruff), and Anthropic acquired Bun. The unit of open-source contribution is also shifting from patches to full ports: Armin Ronacher used an agent to port MiniJinja from Rust to Go in 10 hours with only 45 minutes of actual human effort. Exceptions remain: Prisma moved back to a TypeScript/WASM core for serverless, PyTorch still commands roughly 85% of deep learning research, and Zig, Haskell, and Gleam lack training data. As the developer&amp;rsquo;s role shifts toward design and review, Python&amp;rsquo;s ease-of-writing advantage fades while the performance advantage of harder languages compounds every day.&lt;/p&gt;
&lt;h2 id="on-rendering-the-sky-sunsets-and-planets"&gt;&lt;a href="https://blog.maximeheckel.com/posts/on-rendering-the-sky-sunsets-and-planets/" rel="noopener noreferrer"&gt;On Rendering the Sky, Sunsets, and Planets&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Maxime Heckel walks through rendering atmospheric scattering in WebGL shaders from first principles up to near-photorealistic results. The foundation is raymarching: sampling atmospheric density along the view ray, computing transmittance via Beer&amp;rsquo;s Law, and using phase functions to describe scattering direction. Three physical mechanisms are combined: Rayleigh scattering (shorter wavelengths scatter more strongly, which is why the sky is blue), Mie scattering (larger particles like dust and aerosols that create the bright halo around the sun), and ozone absorption (filtering out specific wavelengths and deepening sunset colors).&lt;/p&gt;
&lt;p&gt;After building a flat sky, the author wraps the atmosphere around a spherical planet: reconstructing world-space coordinates from the depth buffer, using ray-sphere intersection to find atmospheric bounds, and handling depth so the atmosphere blends seamlessly with rendered geometry. With the exact same simulation framework, tweaking parameters produces a solar eclipse or a Martian sky. Finally, to hit real-time frame rates, the article implements Sébastien Hillaire&amp;rsquo;s lookup-table (LUT) method: precomputing transmittance, sky-view, and aerial perspective into textures and sampling them instead of running nested raymarching loops every frame. Packed with interactive widgets to tweak sun angle, altitude, Mie scattering, and ozone density, it is well worth reading directly.&lt;/p&gt;
&lt;h2 id="starting-systems-programming-pt-1-programmers-write-programs"&gt;&lt;a href="https://eblog.fly.dev/startingsystems1.html" rel="noopener noreferrer"&gt;Starting Systems Programming, Pt 1: Programmers Write Programs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the opening installment of Efron Amber Licht&amp;rsquo;s series on systems programming, built around a simple premise: to get good, you have to do the thing, and programmers write programs. In the author&amp;rsquo;s view, a problem counts as &amp;ldquo;systems&amp;rdquo; programming when it interacts with the OS or hardware, operates under tight performance constraints, or manipulates bytes and registers directly. A systems programmer views the computer as a physical machine that can be understood completely rather than an opaque abstraction, and isn&amp;rsquo;t afraid to take things apart to see how they work.&lt;/p&gt;
&lt;p&gt;The article opens the &amp;ldquo;black box&amp;rdquo; of a program by compiling a Go &amp;ldquo;hello world&amp;rdquo; binary and inspecting the executable directly. Readers build small tools from scratch along the way: &lt;code&gt;findoffset&lt;/code&gt; to locate a string inside a file, &lt;code&gt;echo&lt;/code&gt; and &lt;code&gt;cat&lt;/code&gt; to write and print files, &lt;code&gt;binpatch&lt;/code&gt; to patch binary contents directly without recompiling, and hexdump utilities to inspect machine code. Through these exercises, readers see that an executable is just an organized sequence of bytes: the string &lt;code&gt;&amp;quot;hello, world!&amp;quot;&lt;/code&gt; sits at a fixed offset, while the ELF header holds the magic number, target architecture, and the entry point where the CPU begins execution, with values stored in little-endian order on x86-64. The ethos the author wants to pass on: build your own tools, look at the raw data with your own eyes, and understand the system rather than hiding behind abstractions — because at the end of the day, it&amp;rsquo;s all just bytes.&lt;/p&gt;
&lt;h2 id="learning-software-architecture"&gt;&lt;a href="https://matklad.github.io/2026/05/12/software-architecture.html" rel="noopener noreferrer"&gt;Learning Software Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Replying to a physicist asking how to learn software architecture, Matklad argues that the skill is best learned by doing. University design courses felt to him like &amp;ldquo;kindergarteners playing firefighters&amp;rdquo;; what actually taught him architecture was unexpectedly becoming the lead of the IntelliJ Rust project. His second observation is Conway&amp;rsquo;s Law: software mirrors the social structure of the organization that builds it. He quotes neugierig: code ultimately matters less than architecture, and architecture matters less than social problems. Poor &amp;ldquo;scientific code,&amp;rdquo; therefore, stems mainly from incentive structures — like pressure to publish a paper in three months — rather than a lack of programming knowledge.&lt;/p&gt;
&lt;p&gt;There are two ways forward: very rarely, you get a chance to redesign a project&amp;rsquo;s incentive structure; most of the time, you have to accept the constraints and adapt the architecture around them. &lt;code&gt;rust-analyzer&lt;/code&gt; is a prime example: its deep, compiler-like core is kept trivial to build with a test suite that runs in seconds so it can attract strong contributors, while its wide surface of IDE features is isolated so that each feature is wrapped in &lt;code&gt;catch_unwind&lt;/code&gt; and operates on an immutable snapshot of data — allowing weekend contributors to submit imperfect code without crashes cascading or corrupting state. While he has no single &amp;ldquo;bible&amp;rdquo; book to recommend, he points readers to Gary Bernhardt&amp;rsquo;s talk &amp;ldquo;Boundaries,&amp;rdquo; Pieter Hintjens&amp;rsquo;s writings, Ted Kaminski&amp;rsquo;s blog, and Jamii&amp;rsquo;s post &amp;ldquo;Reflections on a decade of coding.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="i"&gt;&lt;a href="https://newsletter.weskao.com/p/im-an-introvert-this-is-how-i-get-myself-to-speak-up" rel="noopener noreferrer"&gt;I&amp;rsquo;m an introvert. This is how I get myself to speak up.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao shares her experience as an introvert in the workplace, where meetings naturally favor people who speak first and think out loud. Introverts prefer time to process before responding, putting them at a systematic disadvantage. Rather than waiting until you feel confident — a moment that usually never arrives — she recommends preparing ahead of time and using concrete tactics she relies on herself.&lt;/p&gt;
&lt;p&gt;Before a meeting, decide in advance that you are going to speak so you don&amp;rsquo;t waste energy debating yourself in the moment, and chime in early before prolonged self-doubt lets the opportunity slip away. Keeping a few go-to opening phrases ready, such as &amp;ldquo;That&amp;rsquo;s a great point. My POV on this is…&amp;rdquo;, makes jumping into a fast-moving discussion much easier. Written channels like docs and meeting notes serve as a parallel track for contributing and leave behind durable artifacts. Remote meetings also offer unique advantages for introverts (controlled lighting, framing, and small video tiles reduce pressure), and you can enlist a trusted colleague to give you a gentle prompt to hold yourself accountable.&lt;/p&gt;
&lt;h2 id="how-i-use-llms-as-a-staff-engineer-in-2026"&gt;&lt;a href="https://www.seangoedecke.com/how-i-use-llms-in-2026/" rel="noopener noreferrer"&gt;How I use LLMs as a staff engineer in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke reflects on how his LLM usage as a staff engineer has evolved over the past year, and the biggest shift is that agents have gotten genuinely good. In 2025 he only used AI for autocomplete, small edits in unfamiliar codebases, or Q&amp;amp;A; today, every code change starts by handing it to an agent (primarily via the GitHub Copilot app, running dozens of sessions a day). He skims the result for about 30 seconds, throws away most attempts because they aren&amp;rsquo;t what he had in mind, and carefully reviews and polishes the ones that survive. For bug reports, he feeds every single one to an agent first because it diagnoses the issue correctly about 80% of the time. Human expertise still matters, though: one bug took until the 14th agent session to crack, after he supplied context from logs and Slack, reproduced the issue himself, and narrowed the search space.&lt;/p&gt;
&lt;p&gt;He offloads a lot of testing and environment setup to agents: having them test their own changes and inspect the logs, write integration tests, and troubleshoot local machine configs. Test code is treated as &amp;ldquo;cheap,&amp;rdquo; whereas he avoids delegating UI work because agents still lack visual sensibility. Conversely, he still writes all his own PR descriptions, ADRs, Slack messages, and blog posts, because LLMs are overly verbose, struggle to surface the core point, and writing things yourself signals to coworkers that a real human is thinking on the other end. In his view, the most important AI skill today is delegating as much as possible to agents without pushing it too far.&lt;/p&gt;
&lt;h2 id="interrogatory-llm"&gt;&lt;a href="https://martinfowler.com/bliki/InterrogatoryLLM.html" rel="noopener noreferrer"&gt;Interrogatory LLM&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martin Fowler introduces the &amp;ldquo;Interrogatory LLM&amp;rdquo; pattern: instead of a human writing pages of context up front for a complex task, you ask the LLM to interview you, ask every question it needs answered, and synthesize the conversation into a context report that a subsequent session (potentially running a different model) uses to execute the task. He first spotted this technique on Harper Reed&amp;rsquo;s blog, noting the key trick of forcing the LLM to ask only one question at a time — a constraint Fowler found he had to remind the model of repeatedly when trying it himself.&lt;/p&gt;
&lt;p&gt;The pattern also works in reverse: hand an LLM an existing document, such as a software specification, and have it interview a domain expert to verify whether the spec is still accurate, replacing the tedious document review process that many experts struggle with. You can even combine both directions: one LLM drafts the document through an interview, and other LLMs take it to different experts for cross-examination. More broadly, while Fowler himself treats writing as an integral part of thinking, many people find writing painful; a structured conversation with an LLM can help them turn their tacit knowledge into written documentation.&lt;/p&gt;
&lt;h2 id="i-don"&gt;&lt;a href="https://frederickvanbrabant.com/blog/2026-05-15-i-dont-think-ai-will-make-your-processes-go-faster/" rel="noopener noreferrer"&gt;I don&amp;rsquo;t think AI will make your processes go faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After rereading the classics &lt;em&gt;The Toyota Way&lt;/em&gt; and &lt;em&gt;The Goal&lt;/em&gt;, Frederick Van Brabant argues that AI won&amp;rsquo;t speed up organizational processes the way many expect, because we keep misidentifying the bottleneck. Looking at a project timeline, software development takes the longest chunk of time, so the knee-jerk reaction is to add headcount or assume AI will speed it up. But taking a long time doesn&amp;rsquo;t mean the problem originates there: nobody makes a project faster by typing faster. Most of that time is actually spent deciphering vague, title-only tickets like &amp;ldquo;send an email to the user when the order is completed&amp;rdquo; — what goes in the email, what happens on failure, and what counts as completed?&lt;/p&gt;
&lt;p&gt;AI generates code fast, but that doesn&amp;rsquo;t mean it generates the &lt;em&gt;right&lt;/em&gt; code. Comparisons between humans and AI routinely ignore the hand-holding required: to get AI to build the right thing, product and domain experts have to specify every feature and edge case down to the tiniest detail, ballooning the specification phase. Yet that level of clarity is what developers have wanted all along; if human engineers received specs that detailed, their productivity would skyrocket too. If you want faster processes, make sure the people doing the work have what they need to succeed — echoing &lt;em&gt;The Goal&lt;/em&gt;&amp;rsquo;s lesson that a bottleneck must be fed high-quality, predictable inputs.&lt;/p&gt;
&lt;h2 id="using-an-engineering-notebook"&gt;&lt;a href="https://ntietz.com/blog/using-an-engineering-notebook/" rel="noopener noreferrer"&gt;Using an Engineering Notebook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicole Tietz shares what she considers perhaps her single most important productivity habit: handwriting in an engineering notebook, a practice borrowed from laboratory notebooks. The notebook records in rich detail what she is doing and why, thoroughly enough that someone else could reproduce the work; every entry is dated, written contemporaneously as the work happens, append-only without erasures or edits, and serves as the primary record rather than a neat copy transcribed from elsewhere. That level of detail matters because your future self is also &amp;ldquo;someone else&amp;rdquo; and will forget most of the context. She started the habit in 2016 while consulting for multiple clients at once, and now uses an e-ink tablet instead of paper notebooks because she is left-handed and doesn&amp;rsquo;t want to carry multiple physical notebooks around.&lt;/p&gt;
&lt;p&gt;The notebook delivers two main benefits. First, it acts as a memory aid: both as a log she can read back to recover context after an interruption, and because the physical act of handwriting improves retention. Second, it is a thinking tool: she routinely writes out a description of a planned code change in her notebook before touching the keyboard, forcing herself to think carefully and spot gaps in her understanding before writing a single line of code. She rarely rereads old notebooks and never shows them to anyone, because &amp;ldquo;the writing &lt;em&gt;is&lt;/em&gt; the work.&amp;rdquo; Her advice: if you haven&amp;rsquo;t tried keeping one, give it a shot and adapt the format, medium, and level of detail to fit your own style.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Documents:&lt;/strong&gt;
&lt;a href="https://static1.squarespace.com/static/50363cf324ac8e905e7df861/t/6a0af5d0484fbf5fe9a7743e/1779103184855/2026-Spring-AI.pdf" rel="noopener noreferrer"&gt;AI eats the world&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #105</title><link>https://miti99.com/en/post/2026/05/27/</link><pubDate>Wed, 27 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/27/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #105.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="virtual-memory-a-deep-dive-into-page-tables-tlbs-and-linux-internals"&gt;&lt;a href="https://blog.codingconfessions.com/p/virtual-memory" rel="noopener noreferrer"&gt;Virtual Memory: A Deep Dive into Page Tables, TLBs, and Linux Internals&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abhinav Upadhyay (of the blog &lt;em&gt;Confessions of a Code Addict&lt;/em&gt;) wrote a massive ~25,000-word deep dive explaining virtual memory on x86-64 Linux from first principles down to kernel implementation details. Framed as a dialogue between a process named &amp;ldquo;Alloca&amp;rdquo; and the &amp;ldquo;Kernel,&amp;rdquo; each question from Alloca unlocks a new concept, guiding the reader naturally from &amp;ldquo;why do we need virtual memory?&amp;rdquo; (process isolation, memory protection, the illusion of abundant memory) to the underlying mechanisms. Each process gets a 128 TiB user-space half of the 48-bit virtual address space, divided into text, data, BSS, heap, memory-mapped, and stack segments.&lt;/p&gt;
&lt;p&gt;The centerpiece is the address translation journey: the CR3 register points to a four-level page table (PGD, PUD, PMD, PTE), where each level consumes 9 bits of the address and the final 12 bits index into a 4 KB page. Because walking four levels on every memory access would be prohibitively slow, the TLB (Translation Lookaside Buffer) caches translations, making TLB hit rate a direct driver of application performance. The article then covers demand paging (allocating physical frames only on first access, distinguishing minor faults that require no I/O from major faults that must read from disk), copy-on-write after &lt;code&gt;fork()&lt;/code&gt; (parent and child share read-only frames and only copy on write), &lt;code&gt;mmap()&lt;/code&gt; mapping files through the page cache to skip &lt;code&gt;read()&lt;/code&gt;&amp;rsquo;s extra copy, and how the MMU enforces permissions via page table bits, including the NX bit used for W^X protection.&lt;/p&gt;
&lt;h2 id="orchestrating-ai-code-review-at-scale"&gt;&lt;a href="https://blog.cloudflare.com/ai-code-review/" rel="noopener noreferrer"&gt;Orchestrating AI Code Review at scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare shares how they brought AI code review into CI across their entire engineering organization, using OpenCode to orchestrate multiple specialized agents rather than asking a single giant model to inspect everything. Each merge request can be evaluated by up to seven domain-specific agents covering security, performance, code quality, documentation, release management, and compliance; an orchestrator agent aggregates the findings, deduplicates them, and makes the final call. Each agent&amp;rsquo;s prompt is narrowly scoped and explicitly lists &amp;ldquo;what NOT to flag&amp;rdquo; to keep noise down. A plugin architecture behind a &lt;code&gt;ReviewPlugin&lt;/code&gt; interface decouples version control systems, AI providers, and internal standards, avoiding vendor lock-in.&lt;/p&gt;
&lt;p&gt;To balance cost and quality, the system tiers its models: frontier models (Claude Opus 4.7, GPT-5.4) handle orchestration only, standard models (Claude Sonnet 4.6, GPT-5.3) do the bulk of the reviewing, and lightweight models handle text-heavy tasks like documentation. Merge requests are triaged by risk into trivial, lite, or full, so minor edits don&amp;rsquo;t spin up all seven agents while security-sensitive files always receive a full review. Circuit breakers, timeouts, and a control plane running on Cloudflare Workers keep the system resilient. In its first 30 days, the system ran 131,246 reviews at an average cost of $1.19 per review and an 85.7% cache hit rate.&lt;/p&gt;
&lt;h2 id="the-8-levels-of-agentic-engineering"&gt;&lt;a href="https://www.bassimeledath.com/blog/levels-of-agentic-engineering" rel="noopener noreferrer"&gt;The 8 Levels of Agentic Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bassim Eledath proposes an eight-level framework describing how development teams progressively get more leverage out of AI in software engineering, starting from the observation that &amp;ldquo;AI&amp;rsquo;s coding ability is outpacing our ability to harness it.&amp;rdquo; Levels 1 and 2 are autocomplete and AI-first IDEs like Cursor; Level 3 is context engineering, optimizing every token fed into the model; Level 4 is compounding engineering, with a loop of planning, delegating, evaluating, and recording lessons so each session improves on the last; Level 5 uses MCP and skills to connect databases, APIs, and CI; Level 6 is harness engineering, building environments with automated feedback loops so agents can self-correct; Level 7 is asynchronous background agents; and Level 8 is autonomous agent teams coordinating directly without a central orchestrator — an early, still-challenging frontier.&lt;/p&gt;
&lt;p&gt;The author highlights several cross-cutting lessons. A &amp;ldquo;multiplayer&amp;rdquo; effect means an individual&amp;rsquo;s productivity depends heavily on their teammates&amp;rsquo; level: a Level 7 engineer is still bottlenecked if colleagues manually review PRs at Level 2. Giving agents constraints works better than giving step-by-step instructions, because agents tend to follow instructions rigidly while missing unstated requirements. Finally, using different models for different roles yields better overall results, and the implementing model should never review its own output to avoid self-preference bias.&lt;/p&gt;
&lt;h2 id="hexagonal-architecture-is-not-a-layered-architecture-topology-safety-and-when-to-walk-away"&gt;&lt;a href="https://dev.to/bing_yu/hexagonal-architecture-is-not-a-layered-architecture-topology-safety-and-when-to-walk-away-4dln" rel="noopener noreferrer"&gt;Hexagonal Architecture is Not a Layered Architecture: Topology, Safety, and When to Walk Away&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article points out that the core difference between hexagonal architecture and layered architecture lies in the direction of dependencies rather than complexity. Layered architecture lets dependencies flow vertically down a chain of controller, service, and repository; in hexagonal architecture, dependencies point inward toward the center: adapters depend on ports, ports belong to the domain, and business logic has no idea what implements an outbound port. Alistair Cockburn&amp;rsquo;s original 2005 model split ports into driving and driven sides while allowing multiple ports by communication purpose; many modern implementations influenced by Clean Architecture add concentric inner rings, and each ring adds data-mapping overhead that wasn&amp;rsquo;t part of the original design.&lt;/p&gt;
&lt;p&gt;Port ownership matters too: in the author&amp;rsquo;s chosen layout, Inbound Ports belong to the application layer while Outbound Ports belong to the domain layer, and keeping that distinction clear helps tell whether a change reflects a shift in business requirements or merely a swapped implementation. Adapters handle protocol translation and structural validation like JSON syntax or field types, whereas the domain handles semantic validation like business invariants; if a rule still holds after swapping out the underlying technology, it belongs in the domain. The author is also candid that hexagonal architecture does not automatically give you deployment isolation, input sanitization, or security hardening, and for a CRUD system with 3 controllers, 5 services, and 2 tables, its indirection is a concrete tax paid for abstract benefits; the payoff only grows as complexity grows.&lt;/p&gt;
&lt;h2 id="spec-driven-development-how-ai-coding-moves-beyond-vibe-coding"&gt;&lt;a href="https://www.vitaliihonchar.com/insights/spec-driven-development" rel="noopener noreferrer"&gt;Spec-Driven Development: How AI Coding Moves Beyond Vibe Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vitalii Honchar introduces spec-driven development as the next step beyond &amp;ldquo;vibe coding&amp;rdquo;: instead of steering AI through an endless series of small conversational nudges, the developer writes a detailed technical specification up front and lets the AI implement from it autonomously. The workflow follows four sequential stages: co-author a requirements specification in Markdown with the AI, have the AI generate an implementation plan from the spec, break the plan into small manageable tasks, and let the AI execute the whole thing with minimal intervention. The author uses GitHub Spec Kit to bootstrap projects around this workflow.&lt;/p&gt;
&lt;p&gt;Compared to vibe coding, this approach keeps the AI aligned with defined requirements, produces documentation from day one, and frees the developer to focus on other work while the AI builds. As a practical example, the author built AgentD — a local service for scheduling and running AI agents — in about five hours without writing code by hand, a project that would have taken weeks manually. In his view, software engineers should shift their focus toward architectural thinking, requirements definition, and quality verification rather than competing with AI on raw coding speed.&lt;/p&gt;
&lt;h2 id="go-vs-java-the-minimalist-vs-the-enterprise-veteran"&gt;&lt;a href="https://dev.to/adamthedeveloper/go-vs-java-the-minimalist-vs-the-enterprise-veteran-1gg3" rel="noopener noreferrer"&gt;Go vs Java: The Minimalist vs The Enterprise Veteran&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares two languages built on opposite philosophies: Go embraces radical minimalism (no classes, no inheritance, and no generics until 2022), while Java offers a rich toolkit of generics, inheritance, interfaces, and annotations. According to the author, Go&amp;rsquo;s minimalism lets new team members read and understand a codebase from day one. On performance, Go compiles to native binaries that start in milliseconds, making it a natural fit for containerized workloads; Java runs on the JVM, starting slower but warming up to high peak throughput thanks to JIT compilation in long-running services.&lt;/p&gt;
&lt;p&gt;The concurrency gap has narrowed considerably: Go&amp;rsquo;s goroutines and channels have long been lightweight and ergonomic, but Virtual Threads in Java 21 now bring M:N scheduling to Java&amp;rsquo;s familiar thread API, even if the underlying mechanics and trade-offs still differ from goroutines. In terms of ecosystem, Java boasts millions of mature libraries with Spring dominating enterprise development, while Go favors quality over quantity with a standard library sufficient for most tasks. Go shines for infrastructure, CLIs, microservices, and cloud-native apps; Java excels in complex enterprise systems. The author concludes that neither language is universally superior — the right choice depends on project requirements and team expertise.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-goal"&gt;&lt;a href="https://x.com/Saboo_Shubham_/status/2054988166541770782" rel="noopener noreferrer"&gt;The ultimate guide to /goal&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shubham Saboo argues that &lt;code&gt;/goal&lt;/code&gt; is not just a feature, but is emerging as a foundational primitive for coding agents, much like HTTP or JSON. With normal prompting, you steer turn by turn: read the response, evaluate it, and nudge the agent to the next step. &lt;code&gt;/goal&lt;/code&gt; flips that model: you describe what &amp;ldquo;done&amp;rdquo; looks like, send it once, and the agent loops autonomously until it gets there — for example, &amp;ldquo;build the app according to SPEC.md; done means tests pass, build passes, README is accurate, and git status is clean.&amp;rdquo; It shifts the interaction from micromanaging steps to delegating against a clear objective. Notably, three separate ecosystems — OpenAI Codex CLI, Claude Code, and the Hermes Agent orchestrator — have converged on the same command pattern, making them composable.&lt;/p&gt;
&lt;p&gt;Saboo outlines three enduring roles regardless of how tools evolve: the orchestrator that coordinates, selects workers, manages the Kanban board, and performs final verification (Hermes); the builder that takes a spec and generates code (Codex&amp;rsquo;s strength); and the reviewer that hunts for bugs in plausible-looking code (Claude Code&amp;rsquo;s strength). The golden rule is independent verification: Hermes never trusts Codex&amp;rsquo;s self-reported completion and instead runs &lt;code&gt;npm test&lt;/code&gt; and &lt;code&gt;npm run build&lt;/code&gt; itself — turning &lt;code&gt;/goal&lt;/code&gt; from a promise into a contract. Multiple goals can run in parallel, though each file should only have a single writing agent at a time to avoid conflicts.&lt;/p&gt;
&lt;h2 id="the-ai-native-developer"&gt;&lt;a href="https://newsletter.getdx.com/p/the-ai-native-developer" rel="noopener noreferrer"&gt;The AI-Native Developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brian Houck presents research on how AI is reshaping the developer role, drawing on a survey of more than 1,300 developers and interviews with 22 practitioners. Developer work falls into three buckets: core tasks like coding, debugging, and testing score high across every dimension and represent the biggest opportunity for AI; cross-component debugging and environment provisioning are areas where developers want deeper AI help, though current tools still fall short; and relational work like stakeholder communication sits in the &amp;ldquo;low priority for AI&amp;rdquo; zone where developers want to retain their own voice and final accountability.&lt;/p&gt;
&lt;p&gt;The study identifies four stages of AI maturity: Skeptics, who adopt only when competitive pressure forces their hand; Explorers, who build confidence through small wins; Collaborators, who bring AI into their workflow much earlier; and Strategists, who orchestrate multiple agents in parallel, shifting from code producers to &amp;ldquo;architects of intent.&amp;rdquo; Alongside this progression sit three unresolved tensions: the learning paradox (are we becoming better engineers or just better prompt writers?), the risk of skill atrophy among junior developers, and an accountability gap when verification standards fail to keep pace with generation speed. Houck sketches three possible futures: maintaining deep craft at AI speed, focusing on orchestration and judgment, or becoming a &amp;ldquo;Clerical Coder&amp;rdquo; who rubber-stamps generated code without truly understanding it.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #16</title><link>https://miti99.com/en/post/2025/05/03/</link><pubDate>Sat, 03 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #16.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="choosing-languages"&gt;&lt;a href="https://steveklabnik.com/writing/choosing-languages" rel="noopener noreferrer"&gt;Choosing Languages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steve Klabnik wrote this piece after Microsoft announced it was porting the TypeScript compiler to Go, sparking immediate community arguments of &amp;ldquo;why not C#?&amp;rdquo; and &amp;ldquo;why not Rust?&amp;rdquo;. His view is simple: write your programs in whatever language you want. Technical constraints are usually contextual rather than absolute, and outsiders rarely know the real context of a project. Microsoft&amp;rsquo;s primary reason is that they are porting an existing codebase rather than rewriting it from scratch, and the existing code is structurally quite close to Go, making the port much easier. Klabnik also dislikes the cliché &amp;ldquo;choose the right tool for the job,&amp;rdquo; because almost nobody intentionally picks the wrong tool; what looks like a bad choice from the outside usually just reflects requirements we can&amp;rsquo;t see.&lt;/p&gt;
&lt;p&gt;The most personal part of the essay comes from 2013, when he was on the Rails team and publicly mocked someone who wrote a &lt;code&gt;grep&lt;/code&gt; tool in Node, hurting the author. That experience made him realize his words carried weight and that the &amp;ldquo;culture of contempt&amp;rdquo; in the Ruby community at the time had rubbed off on him. When he joined the Rust community, he deliberately worked to build a culture that discussed Rust on its own merits rather than putting down other languages—which is why today&amp;rsquo;s &amp;ldquo;rewrite it in Rust&amp;rdquo; crowd frustrates him so much. His closing message: people choose languages for their own reasons, and even when you disagree, there is no excuse to be a jerk about it.&lt;/p&gt;
&lt;h2 id="how-long-should-functions-be"&gt;&lt;a href="https://tidyfirst.substack.com/p/how-long-should-functions-be" rel="noopener noreferrer"&gt;How Long Should Functions Be?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck argues that asking &amp;ldquo;how many lines long should a function be?&amp;rdquo; is the wrong question from the start, because software is grown rather than built all at once. No matter how short functions start out, they tend to grow over time, and the longer a function already is, the more likely it is to grow even longer. To test this, he measured the lengths of 12,513 functions in JUnit 5: most are just 1–4 lines long (5,491 of them are 2-line functions alone), while the longest is 74 lines. The data fits a power-law distribution remarkably well, with an exponent α ≈ 2.46, an R² of 0.96, and a mean length of about 3.49 lines.&lt;/p&gt;
&lt;p&gt;Because it follows a power law, the central limit theorem does not apply: the larger the project, the higher the average function length, and the longest function will keep growing as the system expands. The right answer is therefore a distribution, not a single number: many short functions and a few long ones. We cannot change the fact that function lengths follow a power law, but we can steepen the slope of the distribution—meaning more short functions and a shorter maximum length. The only empirical result Beck knows of is research by Keith Braithwaite showing that test-driven development (TDD) correlates with a steeper slope.&lt;/p&gt;
&lt;h2 id="what-makes-code-hard-to-read-visual-patterns-of-complexity"&gt;&lt;a href="https://seeinglogic.com/posts/visual-readability-patterns/" rel="noopener noreferrer"&gt;What Makes Code Hard To Read: Visual Patterns of Complexity&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;While auditing a codebase for bugs, the author noticed himself getting mentally fatigued very quickly despite the code being high quality, and realized the culprit wasn&amp;rsquo;t cyclomatic complexity as he had expected, but readability. Since there is no universally accepted metric for readability, he draws on the two closest proxies. Halstead metrics from the 1970s count operators and operands: the more there are, the more a reader has to reason about how they interact. SonarSource&amp;rsquo;s Cognitive Complexity adds points whenever control flow breaks linear order and whenever control structures are nested. Beyond those, he examines function shape, naming, and variable lifespans.&lt;/p&gt;
&lt;p&gt;From this analysis, he distills 8 visual patterns that apply across languages: write small functions with few variables and operators; avoid esoteric syntax in favor of idiomatic project patterns; break long &lt;code&gt;map&lt;/code&gt;/&lt;code&gt;filter&lt;/code&gt; chains or complex expressions into logical groups using helper functions or intermediate variables; keep conditionals short and avoid mixing multiple boolean operators; never use &lt;code&gt;goto&lt;/code&gt; outside rare special cases; minimize nesting, extracting helper functions when needed; choose clear, distinct variable names and avoid variable shadowing; and keep variable lifespans as short as possible. Together, they form a practical vocabulary for code review discussions.&lt;/p&gt;
&lt;h2 id="io-devices-and-latency"&gt;&lt;a href="https://planetscale.com/blog/io-devices-and-latency" rel="noopener noreferrer"&gt;IO Devices and Latency&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Benjamin Dicken (PlanetScale) uses interactive visualizations to trace the history of storage devices and their latency profiles. Magnetic tape stores data sequentially, making random access painfully slow. Hard disk drives (HDDs) use rapidly spinning magnetic platters and a moving read/write head, dramatically improving random access times. SSDs have no moving parts, making them far faster and capable of parallel reads and writes, though performance can dip when the drive must run garbage collection to erase stale pages before writing new data.&lt;/p&gt;
&lt;p&gt;In the cloud, providers typically decouple storage from compute using network-attached block storage like EBS. This improves durability and makes scaling capacity easy, but each read or write takes around 250 microseconds compared to roughly 50 microseconds on a locally attached NVMe drive—while a CPU accessing RAM takes only about 100 nanoseconds. On top of that, IOPS are capped: EBS GP3 defaults to 3,000 IOPS, and going higher costs extra. The article serves as an introduction to PlanetScale Metal, where each database (Vitess or Postgres) runs on locally attached NVMe drives with one primary and two replicas for durability, allowing zero-downtime storage scaling and uncapped IOPS.&lt;/p&gt;
&lt;h2 id="the-good-times-in-tech-are-over"&gt;&lt;a href="https://www.seangoedecke.com/good-times-are-over/" rel="noopener noreferrer"&gt;The good times in tech are over&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke observes that for nearly a decade, being a software engineer was extraordinarily comfortable: generous perks, rare layoffs, and being treated like resident geniuses. Over the past two years, everything has changed—layoffs began in 2023, and companies like Meta now publicly cut employees labeled as low performers. According to Goedecke, the root cause is interest rates. Throughout the 2010s, near-zero interest rates meant investors flooded tech companies with cheap capital, fueling massive hiring sprees and speculative projects regardless of profitability. When interest rates rose to around 5% in 2023, profitability suddenly mattered. COVID only created a temporary boom, and AI is not yet the driver behind layoffs.&lt;/p&gt;
&lt;p&gt;As a result, companies are forced to focus on the handful of priorities leadership actually cares about, while budgets for open-source contributions and developer experience get slashed. Goedecke advises engineers to accept that their personal interests may now conflict with their employer&amp;rsquo;s; you can still pursue what you believe is right, but it comes at a career cost, especially for junior engineers. The silver lining is that the tech industry is now closer to reality and the rules of the game are clearer: generating value for the company is rewarded, failing to do so is penalized, and &amp;ldquo;value&amp;rdquo; means advancing leadership&amp;rsquo;s specific plans.&lt;/p&gt;
&lt;h2 id="once-you"&gt;&lt;del&gt;&lt;a href="https://mertbulan.com/2025/01/26/once-you-are-laid-off-you-will-never-be-the-same-again/" rel="noopener noreferrer"&gt;Once You&amp;rsquo;re Laid Off, You&amp;rsquo;ll Never Be the Same Again&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Mert Bulan recounts the day he was laid off alongside most of his teammates. Looking back, he points out five warning signs: team events abruptly canceled; employees receiving notifications about incoming packages (boxes for returning company equipment); leadership lacking clear direction and constantly reorganizing; mandatory meetings appearing on calendars with no concrete agenda; and quarterly earnings season at public companies. What stung most was realizing that all his extra effort—teaching himself React Native, taking on special projects from the CEO, referring talented engineers—meant nothing in the end. During a layoff, you are just a row in an Excel spreadsheet decided by people who don&amp;rsquo;t even know who you are.&lt;/p&gt;
&lt;p&gt;According to the author, trust between companies and employees has been broken as layoffs happen even while companies post record profits. He also notes that German labor laws do not prevent mass layoffs. Many people who have been through a layoff now simply do the exact job they were hired to do. His advice for those who haven&amp;rsquo;t been laid off yet: work your contracted hours; don&amp;rsquo;t overextend yourself hoping for an internal promotion—switch companies to move up instead; keep interviewing elsewhere; use external offers to grow your compensation; and stop worrying so much about having short stints on your resume.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/840e868d-2c83-4b1b-a881-df1da6c6e332_1309x1536.gif" alt="What is MCP?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/6ff106a0-de83-48b0-9eb4-3f8bf0d43a57_1280x1566.gif" alt="How to Design a System like Instagram"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/214c0c6c-2426-49d0-9fa8-cdb9ce089dcc_1280x1585.gif" alt="How to load your websites at lightning speed"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #4</title><link>https://miti99.com/en/post/2025/02/27/</link><pubDate>Thu, 27 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/27/</guid><description>&lt;i&gt;
Hello everyone, I found quite a lot of articles last week, and cramming them all into a single issue would have made it way too long. So today I'm posting an extra mid-week newsletter ^^.
&lt;/i&gt;
&lt;h2 id="management-mantras"&gt;&lt;a href="https://blog.staysaasy.com/p/management-mantras" rel="noopener noreferrer"&gt;Management Mantras&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on the Stay SaaSy blog distills four mantras for engineering managers. The first is &amp;ldquo;don&amp;rsquo;t do anyone any favors&amp;rdquo;: everyone at a company should be working on the highest-priority thing they can do, so when someone says &amp;ldquo;let me do you a favor,&amp;rdquo; it&amp;rsquo;s usually either already their job, a broken process, or a subversion of priorities. That leads directly to the second mantra: employees don&amp;rsquo;t need charity. Whatever the company provides to employees is either compensation they have earned or a core responsibility of management—so when you tell a report they got a raise and they thank you, tell them &amp;ldquo;don&amp;rsquo;t thank me, you earned it.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The third mantra is &amp;ldquo;I can fix it.&amp;rdquo; The larger a company grows, the easier it is to point fingers elsewhere. At good companies, if every project you touch fails, the burden is on you to prove it wasn&amp;rsquo;t your fault; managers must coach their teams to take ownership of anything blocking their results. Finally, management is an everyday job: most of the work consists of uncomfortable tasks like pushing people to do better, resolving conflicts, and delivering tough feedback. A manager&amp;rsquo;s value lies in changing behavior, and that comes from the compounding effect of small daily nudges and coaching moments rather than a few dramatic decisions a year.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-programming-languages-choosing-the-right-tool-for-the-job"&gt;&lt;a href="https://dev.to/mohammad-reza-mahdiani/the-ultimate-guide-to-programming-languages-choosing-the-right-tool-for-the-job-4be2" rel="noopener noreferrer"&gt;The Ultimate Guide to Programming Languages: Choosing the Right Tool for the Job&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DEV Community article surveys five popular programming languages in 2025 along with their strengths and trade-offs. Python is easy to learn and boasts a rich ecosystem for machine learning, data science, web development, and automation, though it is slower than compiled languages and poorly suited for mobile apps. JavaScript remains the &amp;ldquo;king of the web&amp;rdquo;: running natively in browsers, on servers via Node.js, and across platforms with Electron or React Native, at the cost of dynamic typing pitfalls at runtime. Java is the enterprise workhorse thanks to the JVM, stability, and scalability, despite verbose syntax and slower startup for small apps. C++ excels at raw performance and hardware control—ideal for game engines, embedded systems, and simulations—but has a steep learning curve and manual memory management. Rust is the rising star offering memory safety without a garbage collector, well suited for systems programming, WebAssembly, and cryptography, though its ecosystem is still smaller.&lt;/p&gt;
&lt;p&gt;Looking at broader trends, Python still leads in machine learning even as Julia gains ground in high-performance numerical computing; Solidity and Rust stand out in blockchain development; and Kotlin Multiplatform and Flutter (Dart) are popular for unifying mobile, web, and desktop development. The author&amp;rsquo;s conclusion: there is no silver-bullet language, and the right choice depends on project requirements, team expertise, and long-term goals.&lt;/p&gt;
&lt;h2 id="discovery-coding"&gt;&lt;a href="http://jimmyhmiller.com/discovery-coding" rel="noopener noreferrer"&gt;Discovery Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jimmy Miller borrows a familiar distinction from fiction writing: some writers outline everything in advance, while others discover the story in the act of writing. He calls the programming equivalent &amp;ldquo;Discovery Coding&amp;rdquo;—understanding a problem by writing code first rather than designing everything up front. A discovery coder asks what the new code needs to accomplish and how different parts of the system interact, and only by writing code and feeling where the system &amp;ldquo;pushes back&amp;rdquo; do they chart a path forward. This style is easily dismissed as messy, especially in a culture that prizes static type systems and rigid upfront constraints, but the author stresses separating the creative process from the finished artifact: discovery coders can still produce clean, rigorous code once they understand the problem.&lt;/p&gt;
&lt;p&gt;Even natural outliners can benefit from this approach: because you don&amp;rsquo;t walk in with a pre-baked solution, exploratory coding helps you avoid forcing a familiar pattern onto a new problem and loads the system&amp;rsquo;s real constraints into your head. Tools that support live programming against a running system (like Clojure or Smalltalk) and instant visual feedback are especially helpful here. The post closes with a call to accept that programmers think in different ways: a less tidy process doesn&amp;rsquo;t mean a worse outcome, and software design is ultimately a human activity.&lt;/p&gt;
&lt;h2 id="building-a-best-selling-game-with-a-tiny-team"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/thronefall" rel="noopener noreferrer"&gt;Building a best-selling game with a tiny team&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This episode of The Pragmatic Engineer Podcast features Jonas Tyroller, one of the two developers behind &lt;em&gt;Thronefall&lt;/em&gt;, a minimalist strategy game blending tower defense and kingdom building that sold roughly one million copies in its first year. Jonas built the game using Unity, C#, and Blender, structuring each level as a scene populated with scripted game objects. Surprisingly, the duo did no code reviews, wrote no unit tests, and pushed straight to &lt;code&gt;main&lt;/code&gt;: for a small, ship-once game built by two experienced developers, those practices weren&amp;rsquo;t worth the overhead, even if they matter on larger teams. Bugs were caught primarily through constant playtesting, beta testing, and post-launch player feedback.&lt;/p&gt;
&lt;p&gt;Their workflow started with rapid prototyping—spending just 1–2 days per prototype and prioritizing gameplay feel before visuals—to find an idea that was both commercially viable and fun for them to build. The biggest technical challenge was unit pathfinding: they bought an off-the-shelf A* plugin and customized it so troop movement felt natural. Jonas also used ChatGPT to generate boilerplate code, translate shader code, and get up to speed on unfamiliar topics. Key takeaways: indie game development demands wearing many hats—from design and programming to music composition and marketing; the way to get good at making games is to make lots of them; and with Unity and today&amp;rsquo;s wealth of tutorials, getting started has never been more accessible.&lt;/p&gt;
&lt;h2 id="serving-a-billion-web-requests-with-boring-code"&gt;&lt;a href="https://notes.billmill.org/blog/2024/06/Serving_a_billion_web_requests_with_boring_code.html" rel="noopener noreferrer"&gt;Serving a billion web requests with boring code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bill Mill recounts designing the backend API system for the US government&amp;rsquo;s Medicare Plan Finder, where millions of Americans compare and enroll in health insurance plans. The system serves around 5 million requests a day with an average latency under 10 milliseconds, totaling well over a billion requests. Guided by the &amp;ldquo;Choose Boring Technology&amp;rdquo; philosophy, the team picked PostgreSQL, Go, and React. Their only two architectural bets were splitting the backend into three coarse-grained services (&lt;code&gt;druginfo&lt;/code&gt;, &lt;code&gt;planinfo&lt;/code&gt;, &lt;code&gt;beneinfo&lt;/code&gt;), each with its own database, and using gRPC for inter-service communication. While gRPC provided code-defined interfaces, its tooling proved clunky and the author admits they probably would have been better off without it; on the flip side, &lt;code&gt;grpc-gateway&lt;/code&gt; served over a billion requests without a single outage.&lt;/p&gt;
&lt;p&gt;Several other decisions leaned heavily into simplicity: enforcing strict backward compatibility (only adding fields, never removing them), building multi-criteria search by concatenating SQL strings inside a single long but thoroughly commented function instead of standing up Elasticsearch, and rebuilding the databases from scratch every day via a shell-script-and-cron ETL pipeline that used PostgreSQL&amp;rsquo;s &lt;code&gt;COPY&lt;/code&gt; command to load over 250 million rows. The author&amp;rsquo;s biggest regret was writing brittle SQL-mock unit tests that were painful to maintain instead of testing against a real database instance. The takeaway: high-quality, resilient software can absolutely be built within the constraints of government contracting.&lt;/p&gt;
&lt;h2 id="java-language-evolution-in-2025---inside-java-newscast-84"&gt;&lt;a href="https://www.youtube.com/watch?v=dPzle3EN4CM" rel="noopener noreferrer"&gt;Java Language Evolution in 2025 - Inside Java Newscast #84&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Episode #84 of the Inside Java Newscast reviews how the Java language is evolving in 2025 under Project Amber, the initiative focused on language syntax and developer productivity features. Active preview features include flexible constructor bodies (allowing statements to run before &lt;code&gt;super()&lt;/code&gt; or &lt;code&gt;this()&lt;/code&gt;), simplified &lt;code&gt;main&lt;/code&gt; methods and compact source files for smaller programs, single-statement module imports, and primitive types in &lt;code&gt;instanceof&lt;/code&gt; and &lt;code&gt;switch&lt;/code&gt; pattern matching. The video distinguishes these from earlier-stage explorations such as deconstruction patterns for extracting data from objects, &amp;ldquo;withers&amp;rdquo; for creating modified copies of records, and the redesign of string templates, before touching briefly on serialization improvements.&lt;/p&gt;
&lt;h2 id="valhalla---java"&gt;&lt;a href="https://www.youtube.com/watch?v=Dhn-JgZaBWo" rel="noopener noreferrer"&gt;Valhalla - Java&amp;rsquo;s Epic Refactor&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this Devoxx Belgium 2024 talk, Brian Goetz explains Project Valhalla, the long-running effort to heal the rift between objects and primitives in Java. At the center are value classes, which let developers model data with standard class abstractions while enabling flat, dense memory layouts like primitives. The talk also covers null-restricted types, tearing analysis under concurrent updates, and stricter object initialization rules.&lt;/p&gt;
&lt;h2 id="how-might-ai-change-programming"&gt;&lt;a href="https://registerspill.thorstenball.com/p/how-might-ai-change-programming" rel="noopener noreferrer"&gt;How might AI change programming?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball argues that AI is undeniably going to change programming, pointing to a string of tools Claude wrote for him: a Python script that converts a newsletter RSS feed into Markdown, an MCP server for Tailscale, over 200 lines of Rust, and a small Go server that renders Markdown files—most of which worked on the very first try. Even though AI isn&amp;rsquo;t equally effective across every codebase yet, writing and rewriting certain kinds of code has become dirt cheap, and that shift will reshape software development just as compilers, the Internet, version control, and Stack Overflow did. The real question is how.&lt;/p&gt;
&lt;p&gt;The author poses a series of thought-provoking open questions: will new programming languages struggle to gain traction when LLMs lack training data for them? Will we check prompts into version control alongside source code, or structure systems as collections of tiny programs that fit neatly into an AI&amp;rsquo;s context window? Will &lt;code&gt;CONTEXT.md&lt;/code&gt; become the new &lt;code&gt;robots.txt&lt;/code&gt;, guiding AI agents through a repository? Will we see a new form of technical debt when codebases are over-optimized for the quirks of today&amp;rsquo;s models? Will compilers emit richer, more contextual error messages tailored for AI self-correction, and will function names grow longer and more descriptive because they help LLMs reason better? The post doesn&amp;rsquo;t claim to have the answers, but offers plenty of food for thought about the future of the craft.&lt;/p&gt;
&lt;h2 id="hands-on-career-the-evolution-of-a-java-champion"&gt;&lt;a href="https://blog.vanillajava.blog/2025/01/hands-on-career-evolution-of-java.html" rel="noopener noreferrer"&gt;Hands-On Career: The Evolution of a Java Champion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Lawrey, founder of Chronicle Software and a ten-year Java Champion, reflects on more than 30 years of coding and what a programming career looks like in the era of generative AI. He outlines eight dimensions of career growth—ranging from technical depth, problem-solving, and collaboration/communication to business acumen and strategic management—and traces how an engineer&amp;rsquo;s focus shifts from junior developer up to principal engineer or solutions architect. When you start your own company, that scope expands further into sales, finance, legal, and HR. Just as ATMs didn&amp;rsquo;t eliminate bank tellers but shifted them toward higher-value relationship work, developers will adapt and gravitate toward problems that still demand human judgment.&lt;/p&gt;
&lt;p&gt;On working with AI, the author emphasizes that LLMs are statistical rather than deterministic, meaning their output is only probabilistically correct and requires domain experts to verify. A practical tip is to ask the AI to produce a plan before writing code, which consistently yields more complete results; maintaining living requirements and design documents alongside the project (documentation-driven development) also keeps AI outputs much more consistent. AI remains weak at self-evaluation, quantitative performance analysis, and aesthetic judgment. His conclusion: the ability to choose the right code matters more than the ability to type it out, and AI cannot replace hard-won experience, domain expertise, or engineering judgment.&lt;/p&gt;
&lt;h2 id="token-bucket-rate-limiter-redis--java"&gt;&lt;a href="https://foojay.io/today/token-bucket-rate-limiter-redis-java/" rel="noopener noreferrer"&gt;Token Bucket Rate Limiter (Redis &amp;amp; Java)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This tutorial walks through implementing the Token Bucket rate-limiting algorithm using Redis and Java. The core idea is a &amp;ldquo;bucket&amp;rdquo; that refills with tokens at a constant rate; each incoming request consumes one token and is rejected if the bucket is empty, while the bucket&amp;rsquo;s maximum capacity allows the system to absorb short bursts of traffic. In Redis, each client has two keys storing its current token count and the timestamp of the last refill; on every request, the application reads both values, calculates how many tokens to add based on elapsed time (capped at the bucket capacity), deducts one token if available, and writes the updated state back inside a &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction (because the reads happen outside the transaction, the operation is not strictly atomic under concurrent requests). The author uses Jedis to build a &lt;code&gt;TokenBucketRateLimiter&lt;/code&gt; class and tests it with Redis TestContainers, JUnit 5, and AssertJ across scenarios such as allowing requests within capacity, rejecting when tokens are exhausted, refilling over time, isolating multiple clients, and not counting rejected requests. Full source code in both Java and Kotlin is available on GitHub.&lt;/p&gt;
&lt;p&gt;One subtlety to watch out for: the code floors the number of newly generated tokens using integer division, yet updates the last-refill timestamp on every request—including rejected ones. If requests arrive continuously faster than the time needed to mint a single token, the accumulated fractional time is lost and the bucket fails to refill at the intended rate.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus?&lt;/h2&gt;&lt;p&gt;Boohoo, no bonus items this time around, folks :&amp;lt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;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.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>