<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>LLMs on miti99</title><link>https://miti99.com/en/tags/llms/</link><description>Recent content in LLMs 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/llms/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #138</title><link>https://miti99.com/en/post/2026/10/06/</link><pubDate>Tue, 06 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #138.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-i-believe-about-the-future-of-software-development"&gt;&lt;a href="https://thorstenball.com/blog/2026/09/19/what-i-believe-about-the-future-of-software-development/" rel="noopener noreferrer"&gt;What I believe about the future of software development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball reposts to his blog a series of predictions that sparked intense debate on X, capturing a snapshot of what he believes in September 2026. In his view, line-by-line human code review is effectively dead: humans will stop hunting for syntax or logic bugs in model-generated diffs and instead review system architecture and how components fit together. Unit tests as we know them may fade too, now that frontier models can one-shot 900 lines of working Arduino C on the first try. The craft of hand-writing code will atrophy much like cobbling shoes by hand, while the craft of &lt;em&gt;building software&lt;/em&gt;—solving real business problems, knowing when to ship, and tightening feedback loops—will matter more than ever. Most future bugs will be specification bugs (&amp;ldquo;you asked for the wrong thing&amp;rdquo;) rather than implementation bugs, and hand-crafted performance optimization by humans will remain a rare specialty.&lt;/p&gt;
&lt;p&gt;His spicier predictions go further: terminals, shells, and CLIs will cease to be human-first interfaces; tokens are the new compute primitive of the &amp;ldquo;post-binary&amp;rdquo; era; the classic PM/Design/Engineering triad alongside Agile and Scrum rituals will dissolve, and engineers who act merely as &amp;ldquo;meat proxies&amp;rdquo; translating Jira tickets into agent prompts will lose their jobs. Even our notion of &amp;ldquo;clean, maintainable code&amp;rdquo; exists primarily to serve human working-memory limits, so it may stop mattering once agents perform the vast majority of edits. Developers priced out of frontier token budgets risk getting left behind, and bespoke UIs will be generated on the fly. Still, Ball acknowledges it will take a full generation for &amp;ldquo;new software&amp;rdquo; to replace &amp;ldquo;old software&amp;rdquo;—ten years from now people will still be hired to write code by hand, though the real question is whether you&amp;rsquo;ll want that job.&lt;/p&gt;
&lt;h2 id="trying-the-software-factory-pattern"&gt;&lt;a href="https://lethain.com/software-factory-experiment/" rel="noopener noreferrer"&gt;Trying the Software Factory pattern.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Larson reflects that in 2026, effective AI engineering patterns are emerging faster than he can adopt them. At his company Imprint, the year&amp;rsquo;s progression moved rapidly: in January, getting every engineer using Claude Code daily; in March, expanding Claude Code and Claude Cowork to every non-engineering function; in April, hitting the limits of local &lt;code&gt;git worktree&lt;/code&gt; setups and provisioning ~10 full multi-repo workspace checkouts per developer so agents could open coordinated PRs across monorepos; in June, migrating the entire company off Jira onto Linear so agents had clean, low-friction access to task context without permission headaches; and in July, launching &amp;ldquo;Agent Fleet,&amp;rdquo; an internal cloud orchestration harness inspired by Stripe&amp;rsquo;s Minions for autonomously knocking out small tickets.&lt;/p&gt;
&lt;p&gt;The next frontier Larson is experimenting with is the &lt;strong&gt;Software Factory&lt;/strong&gt; pattern: pointing a long-running harness at a broad multi-week project goal and letting it drive progress continuously. His first prototype, a &lt;code&gt;/linear-project-loop&lt;/code&gt; skill, reads a Linear project and checks whether it has both a Notion RFC (defining goals, metrics, and technical approach) and a Datadog dashboard or Snowflake query tracking those metrics—collaborating with the human to create them if missing. On subsequent runs, the loop checks live metrics and open issues, files missing follow-up tasks, and picks up unblocked work like drafting PRs, nudging reviewers, or posting clarifying questions. Running the loop immediately exposed how much project context Larson had been keeping in his own head rather than writing down, and proved especially valuable &lt;em&gt;after&lt;/em&gt; launch—automatically flagging a spike in passkey error rates and queueing up remediation tasks. His takeaway: these pieces only compound when wired together—Datadog MCP, Snowflake, Linear as a single source of truth, and a cloud harness that keeps running when your laptop closes.&lt;/p&gt;
&lt;h2 id="back-to-coupling-and-cohesion"&gt;&lt;a href="https://bastrich.tech/coupling-and-cohesion/" rel="noopener noreferrer"&gt;Back to Coupling and Cohesion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniil Bastrich argues that junior developers and Clean Code zealots routinely over-apply acronyms like SOLID, GRASP, and KISS, producing labyrinthine codebases that look impressive on a whiteboard but are miserable to maintain. In his view, every one of those principles is really just a specialized corollary of managing &lt;strong&gt;coupling&lt;/strong&gt; and &lt;strong&gt;cohesion&lt;/strong&gt; across different scales. Coupling measures how tightly components are entangled such that changing one forces changes in others; cohesion measures the degree to which everything inside a single component serves one unified purpose. To move past hand-wavy intuition, Bastrich proposes quantifying both directly from real development history: for every task, log the effort spent across each touched component; for each component, log the effort spent across each business concern. Using formulas analogous to the Gini-Simpson diversity index and Herfindahl-Hirschman index, coupling is $1 - \frac{\sum e_i^2}{(\sum e_i)^2}$ across components for a task, while cohesion is $\frac{\sum e_i^2}{(\sum e_i)^2}$ across concerns inside a component.&lt;/p&gt;
&lt;p&gt;For example, if changing a password-length rule requires editing both the registration form (effort 4) and the password-reset form (effort 6), the task&amp;rsquo;s coupling score is &lt;code&gt;0.48&lt;/code&gt;, even though each form has a cohesion of &lt;code&gt;1.0&lt;/code&gt;. Framing design around these two forces maps every classic rule back to first principles: Single Responsibility is simply high cohesion; Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, DRY, and the Law of Demeter all exist to reduce coupling or raise cohesion; and KISS bounds the working memory required to hold a component in your head. Even so, Bastrich reminds readers that low coupling and high cohesion aren&amp;rsquo;t free—in ultra-low-latency trading systems, embedded firmware, or throwaway scripts, tightly coupled code is often the right engineering trade-off.&lt;/p&gt;
&lt;h2 id="introducing-system-one-models--jev"&gt;&lt;a href="https://typesafe.ai/blog/introducing-system-one-models-and-jev" rel="noopener noreferrer"&gt;Introducing System One Models &amp;amp; Jev&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Diogo Almeida—founder of TypeSafe AI and an early OpenAI researcher who worked on the foundations of ChatGPT—poses a pointed question: LLMs surpassed human-level chat years ago, so why hasn&amp;rsquo;t enterprise automation caught up? Coming out of two years in stealth, TypeSafe AI introduces &lt;strong&gt;System One Models&lt;/strong&gt;, a new class of frontier models purpose-built to make fast, structured, calibrated decisions inside software pipelines rather than chatting with humans. Built on a custom architecture, a parallel sampler, and a training methodology called &lt;em&gt;Reinforcement Learning for Calibrated Decisions&lt;/em&gt; (RLCD), their debut model &lt;strong&gt;Jev&lt;/strong&gt; (now in early access) acts like a &amp;ldquo;frontier-intelligence function call&amp;rdquo;: it ingests unstructured context and returns strongly typed decisions paired with calibrated probabilities. By abandoning token-by-token autoregressive text generation, Jev cannot produce syntax/type errors or free-form hallucinations, evaluates multiple structured questions in parallel in a single pass, responds in 70–500 ms, and costs just &lt;code&gt;$0.042&lt;/code&gt; per million input tokens with &lt;strong&gt;free output&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;To benchmark real-world utility, the team built a code-level workflow evaluation suite comparing Jev against an ensemble consensus of &lt;code&gt;GPT-6 Astra&lt;/code&gt; and &lt;code&gt;Fable 5.1&lt;/code&gt;. Across those workflows, Jev ran &lt;strong&gt;193.6x faster&lt;/strong&gt; and &lt;strong&gt;444.6x cheaper&lt;/strong&gt; at matching accuracy (though the team transparently notes that benchmark figure sits at the upper end of their target distribution). Ideal use cases include acting as a &amp;ldquo;smart &lt;code&gt;if&lt;/code&gt; statement&amp;rdquo; inside application control flow, massive map-reduce classification over unstructured data, real-time interactive agents, and fast guardrail verification over LLM outputs—illustrated by live demos of Jev playing &lt;em&gt;DOOM&lt;/em&gt; at 10 queries per second for ~$7/hour and playing Wikipedia &lt;em&gt;Wikiracing&lt;/em&gt;. The category name nods to Daniel Kahneman&amp;rsquo;s &lt;em&gt;Thinking, Fast and Slow&lt;/em&gt;, while &amp;ldquo;Jev&amp;rdquo; honors economist William Stanley Jevons: make machine intelligence orders of magnitude faster and cheaper, and entirely new software architectures become viable.&lt;/p&gt;
&lt;h2 id="system-one-models--explained"&gt;&lt;a href="https://unzip.dev/0x025-system-one-models/" rel="noopener noreferrer"&gt;System One Models 🚦 Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Agam More breaks down how System One models—led by TypeSafe AI&amp;rsquo;s Jev—work in practice, describing them as a fast, dirt-cheap &lt;code&gt;if&lt;/code&gt; statement that knows exactly how confident it is. Instead of asking a model to generate an essay, you pass unstructured context alongside a typed schema of closed-ended questions, and the model returns a JSON object with calibrated probabilities for every option, like grading a multiple-choice exam in a single forward pass. Jev exposes three primitives: &lt;code&gt;Choice&lt;/code&gt; (picking one option from an enum), &lt;code&gt;Score&lt;/code&gt; (rating along a defined rubric scale), and &lt;code&gt;Noul&lt;/code&gt; (estimating the boolean probability that a proposition is true). Given a support ticket complaining that a Stripe integration has been broken for three days, for instance, Jev routes it to &lt;code&gt;technical&lt;/code&gt; with probability &lt;code&gt;0.85&lt;/code&gt; and flags &lt;code&gt;urgent: true&lt;/code&gt; in under 100 ms. Under the hood, Jev undergoes standard pretraining followed by RLCD post-training on synthetic data that explicitly rewards Brier-score calibration so a &lt;code&gt;0.80&lt;/code&gt; confidence score genuinely means the model is right 80% of the time.&lt;/p&gt;
&lt;p&gt;More advises reaching for a System One model whenever your backend asks an LLM the exact same closed-ended routing, triage, moderation, or extraction question thousands of times a second—letting you auto-execute high-confidence predictions (&lt;code&gt;p &amp;gt; 0.95&lt;/code&gt;) and route low-confidence edge cases to a heavier reasoning model or human queue. On the public &lt;code&gt;JevBench&lt;/code&gt; suite, Jev is 6x to 7x cheaper per decision than &lt;code&gt;GPT-5.6 Luna&lt;/code&gt; or &lt;code&gt;Gemini 3.1 Flash-Lite&lt;/code&gt;. Conversely, don&amp;rsquo;t use it when the answer space isn&amp;rsquo;t known up front, when you need free-form text generation, or when deep multi-step reasoning matters more than latency; also remember to include an explicit &lt;code&gt;&amp;quot;none_of_the_above&amp;quot;&lt;/code&gt; enum variant if inputs can fall outside your categories. Competing approaches in this emerging space include SemIf, Laya, Kev, GLiNER2, and grammar-constrained decoding via Outlines.&lt;/p&gt;
&lt;h2 id="how-data-is-replicated-in-distributed-systems--raft-from-scratch---part-1"&gt;&lt;a href="https://sushantdhiman.dev/blog/raft/" rel="noopener noreferrer"&gt;How Data Is Replicated In Distributed Systems | Raft From Scratch - Part 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sushant Dhiman kicks off a two-part hands-on series with a foundational distributed systems problem: when you replicate a stateful service like a database across five machines for fault tolerance, how do the nodes agree on a single leader without split-brain? His answer walks through &lt;strong&gt;Raft&lt;/strong&gt;, the consensus algorithm designed by Diego Ongaro and John Ousterhout specifically to be easier to understand and implement than Paxos. Consensus ensures that a cluster of replicas agrees on a single ordered sequence of operations even in the face of crashes and network partitions, preventing scenarios where one replica commits 10 transactions while another only sees 7. Part 1 focuses entirely on &lt;strong&gt;Leader Election&lt;/strong&gt;. In Raft, every node is in one of three states at any moment: the &lt;em&gt;Leader&lt;/em&gt; handles client writes and coordinates replication, &lt;em&gt;Followers&lt;/em&gt; passively respond to RPCs from the leader, and a &lt;em&gt;Candidate&lt;/em&gt; is a follower that steps up to call an election after its leader heartbeat times out. Two RPCs drive the entire protocol: &lt;code&gt;AppendEntries&lt;/code&gt; (used both to replicate log entries and to send periodic empty heartbeats) and &lt;code&gt;RequestVote&lt;/code&gt; (sent by candidates campaigning for leadership).&lt;/p&gt;
&lt;p&gt;When a leader crashes or gets partitioned away, followers stop receiving heartbeats; once a follower&amp;rsquo;s randomized election timeout (say, between 150 ms and 300 ms) expires, it increments its monotonic &lt;em&gt;election term&lt;/em&gt; (which acts as a Lamport logical clock), transitions to Candidate, votes for itself, and sends &lt;code&gt;RequestVote&lt;/code&gt; RPCs to all peers. Randomized timeouts ensure nodes rarely campaign at the exact same millisecond, preventing endless split votes; within any given term, each node grants its vote to at most one candidate on a first-come, first-served basis, and any node that observes a message carrying a higher term number immediately steps down to Follower. Dhiman concludes with a clean educational implementation in Go and gRPC—wiring up the election timer loop, &lt;code&gt;RequestVote&lt;/code&gt;, heartbeat &lt;code&gt;AppendEntries&lt;/code&gt;, and protobuf definitions across three local nodes on ports &lt;code&gt;5001–5003&lt;/code&gt;—saving log replication and persistence for Part 2.&lt;/p&gt;
&lt;h2 id="jev-means-structured-output-is-interesting-again"&gt;&lt;a href="https://www.seangoedecke.com/jev-means-structured-output-is-interesting-again/" rel="noopener noreferrer"&gt;Jev means structured output is interesting again&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke rarely writes about new model releases, but makes an exception for TypeSafe AI&amp;rsquo;s &lt;strong&gt;Jev&lt;/strong&gt;. Standard LLMs generate text autoregressively one token at a time, which makes them wonderfully general-purpose at the cost of high latency and occasional formatting quirks. Jev accepts arbitrary natural-language prompts but &lt;em&gt;only&lt;/em&gt; emits structured classification/scoring outputs—and leaning completely into that constraint unlocks compelling systems properties. Because Jev doesn&amp;rsquo;t generate tokens sequentially and instead evaluates multiple structured decisions in parallel within a single pass, its latency is tightly bounded between 70 ms and 500 ms—fast enough to play &lt;em&gt;DOOM&lt;/em&gt; in real time from text descriptions of the screen state. To Goedecke, sub-100 ms, dirt-cheap structured intelligence feels like a genuine new computing primitive: once you can sprinkle 100 ms probabilistic judgements directly into standard control flow, you can build software that looks nothing like a chatbot.&lt;/p&gt;
&lt;p&gt;That said, Goedecke offers a sober technical reality check: fast structured output from small models was already possible if you cared to optimize for it. Most structured-output pipelines feel slow only because developers ask frontier chat models to emit massive nested JSON schemas via grammar-constrained decoding. For closed-ended classification, you can simply prefill the assistant response up to &lt;code&gt;&amp;quot;choice&amp;quot;: &amp;quot;&lt;/code&gt; and run a single forward pass constrained to valid option tokens—an experiment Goedecke ran locally with &lt;code&gt;Qwen2.5-1.5B-Instruct&lt;/code&gt; that immediately sped up classification by 2x to 3x. Consequently, Jev&amp;rsquo;s architectural moat may be shallower than advertised (though post-training specifically for calibrated probabilities via RLCD is a real differentiator), it will never match frontier reasoning models on problems that require test-time chain-of-thought compute, and calling wrong answers &amp;ldquo;classification errors&amp;rdquo; instead of &amp;ldquo;hallucinations&amp;rdquo; is mostly semantics. Even so, he hopes Jev succeeds and pressures the major labs to ship dedicated ultra-low-latency structured-output endpoints of their own.&lt;/p&gt;
&lt;h2 id="why-do-we-listen-to-people-with-no-skin-in-the-game"&gt;&lt;a href="https://rednafi.com/zephyr/no-skin-in-the-game/" rel="noopener noreferrer"&gt;Why do we listen to people with no skin in the game?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing from the trenches of industrial software engineering, Redowan Delowar argues a simple rule borrowed from Nassim Taleb: if someone doesn&amp;rsquo;t bear the consequences of running the software in production, their opinions about how to build it are probably wrong. Influence does not equal correctness, and talking about code online is a completely different sport from shipping and maintaining production systems under real organizational constraints. A classic culprit is the &amp;ldquo;AI-pilled&amp;rdquo; executive or director who spends a Saturday afternoon vibe-coding a throwaway greenfield app, concludes that software engineering is completely solved, and shows up Monday demanding 10x feature velocity while dismissing compliance, legacy integration, and operational friction as excuses. Delowar uses LLMs heavily every day, which is precisely why he hits their sharp edges far more often than someone who only one-shots toy todo apps. You still have to humor your management chain to keep your paycheck, he notes, but never confuse organizational authority with technical truth—the person with real skin in the game is the one holding the pager when &amp;ldquo;vibe-slop&amp;rdquo; catches fire at 3 a.m.&lt;/p&gt;
&lt;p&gt;The second group with zero skin in the game is software influencers peddling engagement-bait absolutes like &lt;em&gt;&amp;ldquo;rewrite everything in Rust,&amp;rdquo;&lt;/em&gt; &lt;em&gt;&amp;ldquo;TypeScript is dead,&amp;rdquo;&lt;/em&gt; or &lt;em&gt;&amp;ldquo;Kotlin is Temu Java&amp;rdquo;&lt;/em&gt;—because nuanced engineering trade-offs don&amp;rsquo;t please social media algorithms, and selling hot takes and courses is far more lucrative than maintaining a five-year-old billing service. Podcast guests who actually built systems are often worth listening to, while professional hosts and course-sellers—many of whom pivoted seamlessly from JS framework bootcamps to Web3/NFTs and now to &amp;ldquo;AI agent mastery&amp;rdquo;—should be tuned out. Real companies choose tech stacks based on local hiring pools, iteration speed, and what the founding engineers already know, and LLMs haven&amp;rsquo;t changed that fundamental reality. Talk is cheap; always check whether the speaker will be around when the pager goes off.&lt;/p&gt;
&lt;h2 id="you-can-run-git-on-object-storage-if-you-re-make-packfiles"&gt;&lt;a href="https://www.tigrisdata.com/blog/objgit-packfiles/" rel="noopener noreferrer"&gt;You can run git on object storage if you re-make packfiles&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Xe Iaso is building &lt;code&gt;objgit&lt;/code&gt;, an open-source Git server backed directly by Tigris S3-compatible object storage. A naive first prototype that mapped loose Git objects onto an object-storage filesystem hit a brick wall on real-world repositories. At its core, Git is a content-addressable store of millions of tiny objects—the Linux kernel repository alone contains roughly 11 million objects, so fetching them one by one at 10 ms per &lt;code&gt;GetObject&lt;/code&gt; HTTP call would take over 30 hours. Standard Git solves this with &lt;em&gt;packfiles&lt;/em&gt; (&lt;code&gt;.pack&lt;/code&gt; + &lt;code&gt;.idx&lt;/code&gt;), which bundle objects together and delta-compress them, but the Git packfile format was designed around local disks and &lt;code&gt;mmap&lt;/code&gt;, where random seeks cost nanoseconds rather than a 10 ms network round trip. Worse, standard &lt;code&gt;.idx&lt;/code&gt; files record only each object&amp;rsquo;s byte offset and &lt;em&gt;uncompressed&lt;/em&gt; size—not its compressed byte length in the pack—making it impossible to construct an exact HTTP &lt;code&gt;Range: bytes=start-end&lt;/code&gt; request to fetch a single object out of S3 without reading neighboring headers.&lt;/p&gt;
&lt;p&gt;Drawing inspiration from 1990s CD-ROM &lt;code&gt;.bin&lt;/code&gt;/&lt;code&gt;.cue&lt;/code&gt; rip files, Iaso designed a cloud-native packfile format for &lt;code&gt;objgit&lt;/code&gt;: compressed objects are concatenated into &lt;code&gt;.bin&lt;/code&gt; blobs capped at 128 MiB, while a separate binary &amp;ldquo;cue sheet&amp;rdquo; index stores every object&amp;rsquo;s offset alongside &lt;strong&gt;both&lt;/strong&gt; its compressed and uncompressed sizes—effectively turning a Git repository into a columnar store. With the exact compressed byte span in hand, &lt;code&gt;objgit&lt;/code&gt; can fire precise HTTP &lt;code&gt;Range&lt;/code&gt; requests for individual objects at the tail of a packfile while streaming the full packfile in the background until the sequential download catches up, all compressed with &lt;code&gt;zstd&lt;/code&gt;. Reinventing Git&amp;rsquo;s packfile format sounds like violating Chesterton&amp;rsquo;s Fence, Iaso admits, but because Git itself is distributed and content-addressed, if the server&amp;rsquo;s storage format breaks you can simply &lt;code&gt;git push&lt;/code&gt; again from a local clone. The payoff was dramatic: pushing the &lt;code&gt;Xe/x&lt;/code&gt; repository dropped from &lt;strong&gt;3 minutes 29 seconds down to 14.3 seconds&lt;/strong&gt;, and S3 API calls fell from over 9,000 down to 30. (&lt;code&gt;objgit&lt;/code&gt; still lacks authentication and authorization, so don&amp;rsquo;t expose it to the public internet yet.)&lt;/p&gt;
&lt;h2 id="why-cafebabe"&gt;&lt;a href="https://www.artima.com/insidejvm/whyCAFEBABE.html" rel="noopener noreferrer"&gt;Why CAFEBABE?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back in May 1996, while writing his &lt;em&gt;&amp;ldquo;The Class File Lifestyle&amp;rdquo;&lt;/em&gt; column for &lt;em&gt;JavaWorld&lt;/em&gt;, Bill Venners got curious about the famous magic number sitting at the start of every compiled Java &lt;code&gt;.class&lt;/code&gt; file: why must the first four bytes always be &lt;code&gt;0xCAFEBABE&lt;/code&gt;? Venners posted the question to the &lt;code&gt;comp.lang.java&lt;/code&gt; Usenet newsgroup and archived the entire thread on this page. Readers chimed in with clever theories: a 32-bit magic number is fast to check on 32-bit architectures and unlikely to collide with ASCII text; the Java team wanted a coffee-themed hex constant, and since hexadecimal only gives you the letters &lt;code&gt;A&lt;/code&gt; through &lt;code&gt;F&lt;/code&gt; (no &lt;code&gt;J&lt;/code&gt; or &lt;code&gt;V&lt;/code&gt;), combinations using &lt;code&gt;CAFE&lt;/code&gt; beat out alternatives like &lt;code&gt;0xAFABCAFE&lt;/code&gt;, &lt;code&gt;0xCAFEFACE&lt;/code&gt;, or the ominous &lt;code&gt;0xABADCAFE&lt;/code&gt;—while one reader wished they had picked &lt;code&gt;0x00C0FFEE&lt;/code&gt; (reading the leading zeros as the letters &lt;code&gt;&amp;quot;OO&amp;quot;&lt;/code&gt; for &amp;ldquo;Object-Oriented Coffee&amp;rdquo;).&lt;/p&gt;
&lt;p&gt;The Usenet thread also serves as a charming mini-museum of computing folklore around hex magic numbers: the Burroughs B6700 initialized unused memory to &lt;code&gt;0xBADBADBADBAD&lt;/code&gt;; classic IBM systems and AIX RS/6000s filled uninitialized memory with &lt;code&gt;0xDEADBEEF&lt;/code&gt; so pointer bugs jumped right out in a debugger; classic Mac OS placed &lt;code&gt;0x50FFC001&lt;/code&gt; at address &lt;code&gt;0x0&lt;/code&gt; so dereferencing a &lt;code&gt;NULL&lt;/code&gt; code pointer would immediately trap; SGI IRIX started shared arena files with &lt;code&gt;0xDEADBABE&lt;/code&gt;; and debug builds of Solaris overwrote freed heap blocks with &lt;code&gt;0xCAFEFEED&lt;/code&gt;. Another reader pointed out that NeXTSTEP had already used &lt;code&gt;0xCAFEBABE&lt;/code&gt; as the magic number for multi-architecture &amp;ldquo;fat&amp;rdquo; binaries alongside &lt;code&gt;0xFEEDFACE&lt;/code&gt; for Mach-O object files. Finally, Patrick Naughton—one of the original members of Sun&amp;rsquo;s Green Project that created Oak (later renamed Java)—replied with the authoritative answer: he picked &lt;code&gt;0xCAFEBABE&lt;/code&gt; himself years before the name &amp;ldquo;Java&amp;rdquo; even existed! He simply wanted a fun, memorable 32-bit hex constant for the object file format, and &lt;code&gt;0xcafebabe&lt;/code&gt; beat out the runner-up &lt;code&gt;0xdeadbabe&lt;/code&gt;. Any connection to the baristas at Peet&amp;rsquo;s Coffee or the eventual name &amp;ldquo;Java&amp;rdquo; was pure serendipity.&lt;/p&gt;</description></item><item><title>Newsletter #111</title><link>https://miti99.com/en/post/2026/06/11/</link><pubDate>Thu, 11 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #111.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="learnings-from-100k-lines-of-rust-with-ai"&gt;&lt;a href="https://zfhuang99.github.io/rust/claude%20code/codex/contracts/spec-driven%20development/2025/12/01/rust-with-ai.html" rel="noopener noreferrer"&gt;Learnings from 100K Lines of Rust with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cheng Huang recounts using AI agents like Claude Code, Codex CLI, and Copilot to modernize Azure&amp;rsquo;s Replicated State Library (RSL) — a multi-Paxos consensus engine — in Rust. The resulting codebase reached roughly 130k lines of code and over 1,300 tests. To get AI to correctly implement such a complex distributed system, the author relied heavily on &amp;ldquo;code contracts&amp;rdquo;: having the AI write preconditions, postconditions, and invariants for critical functions, enforcing them as runtime &lt;code&gt;assert&lt;/code&gt;s during testing, and using them to drive both targeted unit tests and property-based tests. That approach caught a subtle Paxos safety violation before the code ever reached production.&lt;/p&gt;
&lt;p&gt;The second technique was lightweight spec-driven development: instead of maintaining rigid, heavyweight requirements and design docs, the author used &lt;code&gt;spec-kit&lt;/code&gt;&amp;rsquo;s &lt;code&gt;/specify&lt;/code&gt; command to generate user stories with acceptance criteria, followed by &lt;code&gt;/clarify&lt;/code&gt; so the AI could critique and refine them; each user story then became a right-sized unit of work for an agent. The third technique was AI-driven performance optimization: over roughly three weeks, the AI added latency instrumentation, ran benchmarks, analyzed bottlenecks, and proposed improvements like reducing allocations, zero-copy parsing, and cutting lock contention — pushing throughput from ~23k to 300k operations per second while Rust preserved memory safety. The author closes with the hope that agents will soon execute entire user stories end to end, automate the contract workflow, and optimize performance across even larger codebases, while humans retain architectural oversight.&lt;/p&gt;
&lt;h2 id="always-be-blaming"&gt;&lt;a href="https://matklad.github.io/2026/05/18/always-be-blaming.html" rel="noopener noreferrer"&gt;Always Be Blaming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;matklad proposes reading code across multiple &amp;ldquo;dimensions.&amp;rdquo; 2D reading means forming your own mental sketch of how a solution should look first, then comparing it against the actual code to spot surprises; 3D reading means tracing how the code evolved over time, because most production code is Markovian — its shape today depends on its shape yesterday, not just on the problem it solves. The fourth dimension, and the highest goal, is reconstructing the original author&amp;rsquo;s reasoning and train of thought — applying &amp;ldquo;theory of mind&amp;rdquo; to reading code.&lt;/p&gt;
&lt;p&gt;To do that, matklad treats &lt;code&gt;git&lt;/code&gt; history as a first-class investigative tool. On GitHub, press &lt;code&gt;y&lt;/code&gt; to pin the URL to a specific commit SHA, open the blame view, and repeatedly click &amp;ldquo;blame prior to change,&amp;rdquo; opening relevant commits in new tabs and browsing surrounding files at that exact point in time. Locally, he uses custom keybindings: &lt;code&gt;,b l&lt;/code&gt; to check out the commit that last touched the current line, &lt;code&gt;,b p&lt;/code&gt; to step back to the parent commit, &lt;code&gt;,b u&lt;/code&gt; to jump back to the previous inspection point, and &lt;code&gt;,b w&lt;/code&gt; to copy the GitHub link. This &amp;ldquo;in-place blame&amp;rdquo; workflow keeps the LSP, test runner, and search tools like &lt;code&gt;rg&lt;/code&gt; working normally as you travel through time. He also laments that code review comments — an invaluable source of context — remain locked inside third-party hosting databases rather than living inside the Git repository itself.&lt;/p&gt;
&lt;h2 id="scaling-postgresql-to-power-800-million-chatgpt-users"&gt;&lt;a href="https://openai.com/index/scaling-postgresql/" rel="noopener noreferrer"&gt;Scaling PostgreSQL to power 800 million ChatGPT users&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bohan Zhang shares how OpenAI scaled PostgreSQL to serve ChatGPT and its API across roughly 800 million users. In just one year, PostgreSQL load grew more than 10x, yet the system still relies on a single Azure primary for all writes paired with nearly 50 read replicas spread across multiple regions. The biggest pressure point is write amplification: PostgreSQL&amp;rsquo;s MVCC copies an entire row on every update, amplifying both writes and reads while bloating tables and indexes. To protect the primary, OpenAI offloaded write-heavy, easily partitionable workloads to Azure Cosmos DB, banned adding new tables to the existing PostgreSQL cluster, and held off on sharding because it would require rewriting hundreds of application endpoints.&lt;/p&gt;
&lt;p&gt;Most overload incidents followed the exact same cascade: an upstream trigger — a wave of cache misses, an expensive join, or a write spike from a feature launch — pushed latency up, requests timed out, and client retries amplified the load into a death spiral. To break that chain, OpenAI optimized expensive queries, deployed PgBouncer for connection pooling, added cache locking to prevent cache-miss stampedes, isolated workloads by priority tier, enforced multi-layer rate limiting, capped schema migrations at a 5-second timeout, and throttled backfills. They are also testing cascading replication with Azure to add more read replicas without making the primary ship WAL to all of them directly. As a result, PostgreSQL handles millions of queries per second while keeping client-side p99 latency in the tens of milliseconds and maintaining five-nines availability.&lt;/p&gt;
&lt;h2 id="scaling-managed-agents-decoupling-the-brain-from-the-hands"&gt;&lt;a href="https://www.anthropic.com/engineering/managed-agents" rel="noopener noreferrer"&gt;Scaling Managed Agents: Decoupling the brain from the hands&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic explains the architecture behind Claude Managed Agents, their hosted service for running long-lived AI agents. The starting observation is that agent harnesses often bake in workarounds for whatever current models struggle with, and those assumptions quickly go stale as models improve. Rather than bundling the model, harness, sandbox, and session state inside a single container, Anthropic decoupled them into three components behind stable interfaces — much like an operating system virtualizes hardware: the session is an append-only event log, the harness is the control loop coordinating Claude and tool calls, and the sandbox is the code execution environment. The pieces communicate through clean primitives like &lt;code&gt;execute()&lt;/code&gt;, &lt;code&gt;emitEvent()&lt;/code&gt;, &lt;code&gt;getSession()&lt;/code&gt;, and &lt;code&gt;getEvents()&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;This decoupling turns containers from &amp;ldquo;pets&amp;rdquo; that must be kept alive into disposable &amp;ldquo;cattle&amp;rdquo;: a crashed sandbox is just a failed tool call that can be spun up fresh, while the stateless harness can restart at any time and resume from the session event log. A single harness can also coordinate multiple sandboxes, including reaching into a customer&amp;rsquo;s VPC without requiring network peering. On security, credentials never live inside the sandbox where untrusted code runs; tokens are either bound to resources at provisioning time or held in a vault behind an authenticating proxy, making them much harder for prompt injections to steal. Latency improved dramatically too, because inference starts immediately without waiting for a container to boot — cutting time-to-first-token by roughly 60% at p50 and over 90% at p95.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!fap_!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc111a2c6-71bd-45a7-8938-e8bb4f772cbc_1378x1390.png" alt="How does Claude Code keep long sessions from running out of context?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!VfjL!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F38f19060-e838-440a-971d-bdc1f2d3a167_1280x1546.jpeg" alt="How does a request actually travel through Claude Code?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!cqW0!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F2e0de719-d0ac-497e-8f9c-b9c841422db8_2484x3002.png" alt="Forward Proxy, Reverse Proxy, and API Gateway Explained"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!eLEi!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F52ccd4c2-dc53-4b9a-95b9-d87d6c353f88_2484x3002.png" alt="RAGs vs Agents"&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 #110</title><link>https://miti99.com/en/post/2026/06/07/</link><pubDate>Sun, 07 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #110.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="go-podcast--086-just-use-postgres-man"&gt;&lt;a href="https://share.transistor.fm/s/5159e8a9" rel="noopener noreferrer"&gt;go podcast() | 086: Just use postgres, man&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this podcast episode, Dominic St-Pierre and Morten Vistisen revolve around a familiar question: should you store telemetry data in ClickHouse or just stick with PostgreSQL? Morten wants to try ClickHouse, while Dominic takes the pragmatic stance: below roughly 10 million rows, PostgreSQL performs nearly as well, and scaling rarely happens overnight, leaving plenty of time to migrate when you actually need to. Morten also recounts having to rewrite a component in his DeployQuad project because the LLM-generated code from the initial prototype didn&amp;rsquo;t behave as expected, underscoring the importance of truly understanding the code you ship.&lt;/p&gt;
&lt;p&gt;Dominic introduces StaticBackend v1.7.0, adding multi-account user support and expanded server-side functions powered by Goja (a JavaScript runtime written in Go), while lamenting how tedious releases are when updating multiple NPM packages compared to Go&amp;rsquo;s simple tag-and-push workflow. Toward the end, both hosts express skepticism about over-relying on AI code generation: it disrupts deep flow states while programming, causes skills to atrophy, and may not even deliver a net productivity gain. They remain convinced that core programming skills are as valuable as ever.&lt;/p&gt;
&lt;h2 id="that-one-time-i-used-go-panics-for-flow-control"&gt;&lt;a href="https://noncrab.net/posts/panic-as-flow-control/" rel="noopener noreferrer"&gt;That one time I used Go panics for flow control&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author recounts an overload incident on an in-memory Go data service: when query volume exceeded capacity, requests that normally took 1–2 seconds stretched to a full minute, and upstream retries only piled on more load. The root problem was that Go&amp;rsquo;s standard library sorting functions neither accept a &lt;code&gt;context&lt;/code&gt; nor return an error, so the service kept burning CPU cycles sorting results for queries whose callers had already timed out and walked away. That library design is normally reasonable, since sorting usually happens in batch jobs or over slices small enough that execution time is negligible.&lt;/p&gt;
&lt;p&gt;Rather than rewriting the entire sorting layer, the team used a &lt;code&gt;panic&lt;/code&gt;/&lt;code&gt;recover&lt;/code&gt; pair as an escape hatch: the comparison function checks whether the &lt;code&gt;context&lt;/code&gt; has been canceled and, if so, calls &lt;code&gt;panic&lt;/code&gt; with a dedicated sentinel value. A &lt;code&gt;defer&lt;/code&gt; wrapper around the sort catches that specific sentinel &lt;code&gt;panic&lt;/code&gt; and converts it into a normal error while re-panicking on anything else so real bugs aren&amp;rsquo;t swallowed. That let the system abort useless sorts immediately. The author readily admits this is &amp;ldquo;an ugly solution to an ugly problem,&amp;rdquo; strictly for narrow, tightly controlled situations.&lt;/p&gt;
&lt;h2 id="the-last-six-months-in-llms-in-five-minutes"&gt;&lt;a href="https://simonwillison.net/2026/May/19/5-minute-llms/" rel="noopener noreferrer"&gt;The last six months in LLMs in five minutes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post is the annotated version of Simon Willison&amp;rsquo;s lightning talk at PyCon US 2026, recapping developments in large language models from November 2025 through May 2026. The standout trend is that coding agents crossed a decisive quality threshold: thanks to OpenAI and Anthropic applying reinforcement learning with verifiable rewards throughout 2025, agents went from &amp;ldquo;often works&amp;rdquo; to &amp;ldquo;almost always works&amp;rdquo; and became everyday workhorses. In November alone, the title of &amp;ldquo;best model&amp;rdquo; changed hands five times between Anthropic, OpenAI, and Google, while Willison continued using his signature benchmark of asking models to generate an SVG of a pelican riding a bicycle.&lt;/p&gt;
&lt;p&gt;The second major trend is local open-weight models blowing past expectations, including Google&amp;rsquo;s Gemma 4 family, China&amp;rsquo;s GLM-5.1, and Qwen3.6-35B-A3B, which weighs in at roughly 21GB and runs comfortably on a standard laptop. The talk also highlights OpenClaw, a personal AI assistant project that went so viral that &amp;ldquo;Claws&amp;rdquo; became the generic term for the entire category of personal agents and Mac Minis sold out as people bought them to run Claws at home.&lt;/p&gt;
&lt;h2 id="prompts-are-technical-debt-too"&gt;&lt;a href="https://www.seangoedecke.com/prompts-are-technical-debt-too/" rel="noopener noreferrer"&gt;Prompts are technical debt too&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that prompts — including instruction files like &lt;code&gt;AGENTS.md&lt;/code&gt; and &lt;code&gt;CLAUDE.md&lt;/code&gt; — are a form of technical debt, and in some ways worse than code debt. When code doesn&amp;rsquo;t change, its behavior stays largely the same, and when it breaks it usually fails loudly; prompts, by contrast, silently degrade every time the underlying model is upgraded. A prompt painstakingly tuned to work around an older model&amp;rsquo;s quirks can become useless or actively counterproductive on a newer model without anyone noticing. According to Goedecke, an agent harness with elaborate prompts wrapped around an older model will almost always lose to a minimal harness running a newer model.&lt;/p&gt;
&lt;p&gt;From there, he offers concrete advice: stick to mainstream AI coding tools like Claude Code, Cursor, or Copilot with their default configurations, since their engineering teams continuously re-tune the system prompts for you; avoid installing extra MCP servers or skills unless strictly necessary; if you must write an &lt;code&gt;AGENTS.md&lt;/code&gt;, stick to core factual details about the project rather than trying to micromanage model behavior, and never check in model-generated instructions without reviewing them carefully. Finally, regularly prune custom prompts to keep maintenance overhead low.&lt;/p&gt;
&lt;h2 id="we-see-something-that-works-and-then-we-understand-it"&gt;&lt;a href="https://lemire.me/blog/2025/12/04/we-see-something-that-works-and-then-we-understand-it/" rel="noopener noreferrer"&gt;We see something that works, and then we understand it&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire pushes back against the &amp;ldquo;linear model of innovation&amp;rdquo; — the belief that theoretical understanding must come first and practical progress follows afterward. Borrowing Kevin Kelly&amp;rsquo;s term &amp;ldquo;thinkism,&amp;rdquo; he critiques the illusion that thinking hard enough in the abstract can solve any problem. That mindset dominates schools and bureaucracies, where rules are fixed in advance: students learn a concept first and then solve textbook problems designed to require only that exact concept. History usually works the other way around: pendulum clocks were keeping time in 1656, well before Newton and Hooke formulated the laws of force and motion that explained why they worked.&lt;/p&gt;
&lt;p&gt;In Lemire&amp;rsquo;s view, real R&amp;amp;D always happens with incomplete understanding; people entering industry often learn more in a single year on the job than across their entire university degree because real-world engineering demands continuous experimentation and observation. He draws two lessons: breakthroughs require prioritizing hands-on experimentation over abstract theorizing, and we shouldn&amp;rsquo;t expect AI to solve every complex problem purely from existing knowledge, because the physical world is always richer and messier than what we already know.&lt;/p&gt;
&lt;h2 id="how-vercel-cut-build-wait-times-from-90-seconds-to-5"&gt;&lt;a href="https://blog.bytebytego.com/p/how-vercel-cut-build-wait-times-from" rel="noopener noreferrer"&gt;How Vercel Cut Build Wait Times From 90 Seconds To 5&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article examines how Vercel cut build environment provisioning wait times from 90 seconds down to 5 seconds — an 18x speedup — using an internal platform called Hive. The core challenge is that Vercel runs untrusted build code from thousands of customers on shared hardware, meaning every build must be treated as potentially hostile. Standard containers aren&amp;rsquo;t isolated enough because they share the host Linux kernel, where a single kernel vulnerability could expose another customer&amp;rsquo;s workload. Instead of Kubernetes, Vercel built Hive on AWS Firecracker microVMs: each build runs inside a &amp;ldquo;cell&amp;rdquo; — a tiny virtual machine with its own dedicated kernel that boots in roughly 125 milliseconds. The architecture spans regional clusters where physical &amp;ldquo;boxes&amp;rdquo; host multiple cells, coordinated by a control plane.&lt;/p&gt;
&lt;p&gt;The speedup comes from three compounding optimizations: container image caching and disk snapshots cut cold starts from ~50 seconds down to 5 seconds; a warm pool of pre-booted cells waiting for work means most builds experience near-zero queue wait; and Firecracker&amp;rsquo;s millisecond boot times make maintaining and replenishing that warm pool economical. The trade-off is that keeping warm cells idle consumes resources and every cell must be destroyed after a single build for security, but owning the underlying infrastructure has unlocked new product capabilities for Vercel.&lt;/p&gt;
&lt;h2 id="the-anatomy-of-an-ai-native-org"&gt;&lt;a href="https://ajeygore.in/content/the-anatomy-of-an-ai-native-org" rel="noopener noreferrer"&gt;The Anatomy of an AI-Native Org&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ajey Gore argues that AI is reshaping organizational structure by eliminating the &amp;ldquo;translation layer.&amp;rdquo; For thirty years, software companies have operated across three tiers: leadership decides the &amp;ldquo;Why,&amp;rdquo; product defines the &amp;ldquo;What,&amp;rdquo; and engineering translates those decisions into code — the &amp;ldquo;How.&amp;rdquo; Much of the day-to-day work in that model consists of translating between well-defined inputs and outputs. According to Gore, AI doesn&amp;rsquo;t target a specific job title so much as that entire category of translation work — turning requirements into code or specs into UI components — making it orders of magnitude cheaper, while the strategic work at both ends remains just as hard as ever.&lt;/p&gt;
&lt;p&gt;The shape of an &amp;ldquo;AI-Native&amp;rdquo; organization shifts accordingly: the &amp;ldquo;Why&amp;rdquo; layer stays small; the &amp;ldquo;What&amp;rdquo; layer expands because judgment and taste become critical when directing AI; the human &amp;ldquo;How&amp;rdquo; layer shrinks sharply in headcount but rises in difficulty, focusing on architecture, security, and verification mechanisms that make AI output trustworthy; and AI agents handle routine translation under human supervision. Managers can no longer just coordinate — they must contribute directly — while engineers should move toward problem definition rather than competing with AI on raw code translation.&lt;/p&gt;
&lt;h2 id="how-to-stay-resilient-in-a-difficult-job"&gt;&lt;a href="https://andiroberts.com/executive-coaching/how-to-stay-resilient-in-a-difficult-job" rel="noopener noreferrer"&gt;How to Stay Resilient in a Difficult Job&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article outlines 7 practical, science-backed strategies for maintaining mental resilience when stuck in a difficult job — whether dealing with a poor manager, irregular shifts, or chronic stress. The author stresses that resilience here doesn&amp;rsquo;t mean forcing toxic positivity or pretending the job is fun; it means conserving energy, keeping an objective perspective, and maintaining a sense of agency so you can do good work, protect your health, and stay positioned for future moves.&lt;/p&gt;
&lt;p&gt;The strategies include: grounding yourself mentally at the start of the day and stabilizing your physiology with sunlight, hydration, and movement before work; focusing strictly on what lies within your control and upholding your own professional standards even when surrounding systems are messy; setting emotional boundaries so you don&amp;rsquo;t carry work stress home; finding at least one trusted colleague to confide in; and consistently taking small steps toward landing a better role.&lt;/p&gt;
&lt;h2 id="what"&gt;&lt;a href="https://brooker.co.za/blog/2026/05/18/whats-easy-whats-hard.html" rel="noopener noreferrer"&gt;What&amp;rsquo;s Easy Now? What&amp;rsquo;s Hard Now?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker proposes the &amp;ldquo;feedback loop hypothesis&amp;rdquo;: over the long run, AI coding agents will find tasks with clear, measurable feedback loops &amp;ldquo;easy,&amp;rdquo; while tasks lacking effective automated feedback will remain &amp;ldquo;hard&amp;rdquo; — and this divide will be the primary determinant of agent capability. Opening with an analogy from electrical engineering, he notes that strong negative feedback can turn simple, nonlinear, even flawed components into remarkably accurate amplifiers.&lt;/p&gt;
&lt;p&gt;From that premise, he flips the conventional wisdom that web development is easy and systems programming is hard. A database storage engine like RocksDB has a relatively compact specification — an API plus safety and liveness properties — that can be verified automatically. Web development, by contrast, lacks an equivalent automated oracle and relies on slow, inconsistent human judgment. Current practice already reflects this: agents excel at performance optimization when given a solid benchmark suite, struggle with subjective architectural trade-offs, and get guided toward correct code in languages like Rust thanks to strict compiler errors. Consequently, formal specification languages, compile-time checks, and rigorous testing frameworks will only grow in importance.&lt;/p&gt;
&lt;h2 id="making-user-sequence-data-more-cost-efficient-faster-and-easier-to-use"&gt;&lt;a href="https://medium.com/pinterest-engineering/making-user-sequence-data-more-cost-efficient-faster-and-easier-to-use-2a56a928cae1" rel="noopener noreferrer"&gt;Making User-Sequence Data More Cost-Efficient, Faster, and Easier to Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pinterest&amp;rsquo;s engineering team shares how they redesigned their user-sequence data platform — the ordered history of a user&amp;rsquo;s recent actions enriched with signals like embeddings, device context, and country. This data powers ML ranking, retrieval, and recommendation models across the Home feed, Related Pins, and search results, serving training pipelines, offline analytics, and real-time inference alike. Because it must be simultaneously fresh, complete, consistent between training and serving, and schema-stable, it is often one of the most expensive and brittle parts of a data stack.&lt;/p&gt;
&lt;p&gt;The core principle of the redesign is &amp;ldquo;One definition, multiple runtimes&amp;rdquo;: each signal is defined once and shared across real-time indexing, batch backfills for historical data, and online serving via a unified execution engine supporting both streaming and batch modes. That eliminates training-serving skew by construction. Combined with a Lambda architecture to balance freshness and completeness, plus columnar storage and time-based partitioning, Pinterest significantly cut storage costs and network bandwidth while turning the addition of new event types or signals into a mostly configuration-driven change.&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 #79</title><link>https://miti99.com/en/post/2026/02/02/</link><pubDate>Mon, 02 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #79.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="ascii-characters-are-not-pixels-a-deep-dive-into-ascii-rendering"&gt;&lt;a href="https://alexharri.com/blog/ascii-rendering" rel="noopener noreferrer"&gt;ASCII characters are not pixels: a deep dive into ASCII rendering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Harri shares how he built an image-to-ASCII renderer that produces crisp, sharp edges. The conventional approach divides an image into a grid, computes the average brightness of each cell, and picks a character by density; even with supersampling inside each cell for anti-aliasing, the result looks blurry because every character is treated as a uniform pixel and its internal geometry is ignored. Harri&amp;rsquo;s solution is a &amp;ldquo;shape vector&amp;rdquo;: placing sampling circles inside each character cell, measuring how much of each glyph overlaps each circle, and using those values as a vector describing the character&amp;rsquo;s shape. With six staggered sampling circles, a 6-dimensional vector cleanly distinguishes &lt;code&gt;p&lt;/code&gt; from &lt;code&gt;q&lt;/code&gt;, or &lt;code&gt;^&lt;/code&gt;, &lt;code&gt;-&lt;/code&gt;, and &lt;code&gt;_&lt;/code&gt;; at render time, the engine samples each image cell the exact same way and picks the character with the nearest normalized vector by Euclidean distance.&lt;/p&gt;
&lt;p&gt;To make boundaries between regions of different brightness pop even more, he adds two contrast-enhancement passes: global contrast enhancement (normalizing the sample vector and raising its components to an exponent to push darker regions down) and directional contrast enhancement (using external sampling circles reaching just outside the cell), eliminating staircase artifacts along edges. The appendices cover performance: k-d trees to accelerate nearest-neighbor lookups, caching with bit-packed quantized keys, and offloading sampling to a GPU shader for smooth real-time rendering on mobile. As he notes, using multi-dimensional vectors to represent geometric shape applies to many other domains, much like word embeddings in NLP.&lt;/p&gt;
&lt;h2 id="from-bare-metal-to-containers-a-developer"&gt;&lt;a href="https://buildsoftwaresystems.com/post/guide-to-execution-environments/" rel="noopener noreferrer"&gt;From Bare Metal to Containers: A Developer&amp;rsquo;s Guide to Execution Environments&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide explains why &amp;ldquo;it works on my machine&amp;rdquo; bugs usually stem from differences in execution environments, walking from the heaviest isolation layers down to the lightest. Bare metal gives you direct hardware control and zero virtualization overhead, at the cost of managing hardware and resource isolation yourself. Virtual machines use a hypervisor to carve a physical server into independent machines, each running its own guest OS kernel—providing strong isolation at a higher resource cost. Containers package an application with its userland dependencies while sharing the host OS kernel via Linux namespaces and cgroups, starting quickly with lighter isolation. Process sandboxes (&lt;code&gt;chroot&lt;/code&gt;, Linux capabilities, &lt;code&gt;seccomp&lt;/code&gt;, &lt;code&gt;bubblewrap&lt;/code&gt;) restrict what a single process is allowed to do to shrink its blast radius. Finally, language virtual environments like Python&amp;rsquo;s &lt;code&gt;venv&lt;/code&gt; isolate only language-level packages, with ecosystems increasingly converging on unified toolchains like &lt;code&gt;uv&lt;/code&gt;, Conda, or &lt;code&gt;rustup&lt;/code&gt; with Cargo.&lt;/p&gt;
&lt;p&gt;The central takeaway is that every tool draws its own isolation boundary, and every layer below that boundary must already be compatible: a container cannot fix a kernel mismatch, and a language virtual environment cannot compensate for a missing system C library. In practice these layers are stacked—for example, a cloud VM running Docker, with a language virtual environment inside the container. The post also touches on serverless platforms and WebAssembly as newer isolation boundaries, leaving readers with a guiding question for picking the right tool: what is the lowest layer that needs to be identical for your code to run?&lt;/p&gt;
&lt;h2 id="run-your-project-in-a-dev-container-in-zed"&gt;&lt;a href="https://zed.dev/blog/dev-containers" rel="noopener noreferrer"&gt;Run Your Project in a Dev Container, in Zed&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Starting in v0.218, Zed supports working inside Dev Containers, an open specification for defining Docker-based development environments. Instead of relying on tribal knowledge or an easily outdated README for tool versions, databases, and environment variables, teams describe their setup as code in &lt;code&gt;.devcontainer/devcontainer.json&lt;/code&gt;. When you open a project containing this file, Zed prompts you to reopen it inside the Dev Container; you can also trigger &lt;code&gt;project: open remote&lt;/code&gt;, and Zed automatically reconnects to your last active container on relaunch.&lt;/p&gt;
&lt;p&gt;Under the hood, Zed reuses the remote development architecture it originally built for SSH: a headless Zed Remote Server runs inside the container to handle file operations, language servers, and syntax analysis, while the local Zed client renders the UI; because the two communicate over standard input/output, supporting containers only required adding a transport layer over &lt;code&gt;docker exec&lt;/code&gt;. Container provisioning is delegated to the official &lt;code&gt;devcontainer&lt;/code&gt; CLI (&lt;code&gt;devcontainer up&lt;/code&gt;), which allowed the feature to ship quickly, though &lt;code&gt;forwardPorts&lt;/code&gt; and Zed-specific extension declarations aren&amp;rsquo;t supported yet in this initial release. Upcoming work includes templates for authoring Dev Container specs directly inside Zed, declaring Zed extensions in &lt;code&gt;devcontainer.json&lt;/code&gt;, and supporting &lt;code&gt;forwardPorts&lt;/code&gt; once Zed moves to a native built-in implementation.&lt;/p&gt;
&lt;h2 id="i-was-a-top-001-cursor-user-here"&gt;&lt;a href="https://blog.silennai.com/claude-code" rel="noopener noreferrer"&gt;I was a top 0.01% Cursor user. Here&amp;rsquo;s why I switched to Claude Code 2.0&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author—who has coded with AI since 2021, contributed early on to AutoGPT, and was ranked in the top 0.01% of Cursor users—explains why he switched to Claude Code: in his view, Claude Opus 4.5 elevated programming to a higher level of abstraction where you verify behavior rather than reading every line of code. Claude Code fits an asynchronous, terminal-native workflow, is purpose-tuned for Claude models, is cost-effective, and is easy to customize; Cursor still has its place for pixel-perfect UI tweaks, learning a new codebase, or making small targeted edits.&lt;/p&gt;
&lt;p&gt;The core of the post revolves around five pillars: context management (spawning subagents for parallel tasks, using &lt;code&gt;/compact&lt;/code&gt;, starting fresh sessions before quality degrades, and sticking to one task per session); planning (using plan mode, sprint-style task lists, or doing a dry run and reverting to refine the plan); closing the loop by automating every repetitive check; verifiability via automated UI testing; and systematic debugging using the &amp;ldquo;rule of three&amp;rdquo;—if you&amp;rsquo;ve explained a bug three times and Claude still doesn&amp;rsquo;t get it, change your approach. He packages his workflow into two slash commands—&lt;code&gt;/setup-claude-code&lt;/code&gt; (run once per machine) and &lt;code&gt;/setup-repo&lt;/code&gt; (run once per project)—and shares how he runs 12 terminal sessions in parallel using hooks, skills, MCP servers, and headless mode.&lt;/p&gt;
&lt;h2 id="llm-predictions-for-2026-shared-with-oxide-and-friends"&gt;&lt;a href="https://simonwillison.net/2026/Jan/8/llm-predictions-for-2026/" rel="noopener noreferrer"&gt;LLM predictions for 2026, shared with Oxide and Friends&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison rounds up the 1-, 3-, and 6-year technology predictions he shared on the &lt;em&gt;Oxide and Friends&lt;/em&gt; podcast. Within one year: the quality of LLM-written code will become undeniable, as his own hand-typed code has already dropped below 10% since the release of Claude Opus 4.5 and GPT-5.2; the sandboxing problem will largely be solved, with containers and WebAssembly as the two most promising contenders; we will see a &amp;ldquo;Challenger disaster&amp;rdquo; for coding agent security because so many developers casually run agents in YOLO mode with near-root privileges—for instance, a prompt-injection worm spreading through Python or npm packages; and, on a lighter note, New Zealand&amp;rsquo;s endangered Kākāpō parrot will enjoy a bumper breeding season.&lt;/p&gt;
&lt;p&gt;Within three years, the Jevons paradox debate for coding agents will be settled one way or the other: software engineering skills will either depreciate or become even more valuable as demand for custom software multiplies; and someone building a working web browser mostly with AI will no longer raise eyebrows, thanks to comprehensive conformance test suites. Within six years, typing code by hand will go the way of punch cards, yet software engineering will remain a major profession because building reliable software still demands deep skill, judgment, and experience.&lt;/p&gt;
&lt;h2 id="how-we-made-notion-available-offline"&gt;&lt;a href="https://www.notion.com/blog/how-we-made-notion-available-offline" rel="noopener noreferrer"&gt;How we made Notion available offline&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Notion shares the engineering behind Offline Mode, their most requested feature for years. Previously, the app used local SQLite caching on a best-effort basis with no completeness guarantees; true offline mode required guaranteeing that an entire page is usable without a network connection, elevating the local cache into a persistent storage layer that tracks which pages are available offline, stores every record needed to render them, and records &lt;em&gt;why&lt;/em&gt; each page is kept. A flat set of offline page IDs fell apart once automatic downloads (like recent and favorite pages) and &amp;ldquo;offline inheritance&amp;rdquo; from parent pages entered the picture: a single page can have multiple independent reasons to stay offline and should only be evicted when the very last reason goes away. Notion solved this by modeling a forest of offline page trees across two SQLite tables, &lt;code&gt;offline_page&lt;/code&gt; and &lt;code&gt;offline_action&lt;/code&gt;, where each row in &lt;code&gt;offline_action&lt;/code&gt; represents a distinct retention reason.&lt;/p&gt;
&lt;p&gt;To keep offline pages fresh without polling the server—which wouldn&amp;rsquo;t scale—the server publishes invalidation events on per-page channels whenever a page changes, and clients subscribe to channels for their offline pages to fetch deltas. Upon reconnecting after being offline, the client compares &lt;code&gt;lastDownloadedTimestamp&lt;/code&gt; against the server&amp;rsquo;s &lt;code&gt;lastUpdatedTime&lt;/code&gt; so it only re-downloads pages that actually changed. And when pages move or database rows are added or removed, a forest reconciliation pass diffs the new tree snapshot against &lt;code&gt;offline_action&lt;/code&gt; and applies the minimal set of edits, keeping the local forest eventually consistent with the workspace without rebuilding from scratch.&lt;/p&gt;
&lt;h2 id="how-browsers-work"&gt;&lt;a href="https://howbrowserswork.com/" rel="noopener noreferrer"&gt;How Browsers Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;How Browsers Work&lt;/em&gt; is an open-source interactive guide by Caleb Hearth for engineers and everyday web users who want a concrete mental model of what happens inside a browser; it uses bite-sized interactive simulations and intentionally omits rabbit holes like HTTP version differences or TLS handshakes. The journey starts at the address bar: an arbitrary string like &lt;code&gt;&amp;quot;pizza&amp;quot;&lt;/code&gt; is turned into a search engine query URL, while &lt;code&gt;&amp;quot;example.com&amp;quot;&lt;/code&gt; is normalized into &lt;code&gt;https://example.com&lt;/code&gt;. That URL is then formatted into an HTTP request with headers like &lt;code&gt;Host&lt;/code&gt;; the browser queries DNS to resolve the domain name to an IP address and, in the illustrated HTTP-over-TCP model, establishes a connection via the three-way handshake (&lt;code&gt;SYN&lt;/code&gt;, &lt;code&gt;SYN-ACK&lt;/code&gt;, &lt;code&gt;ACK&lt;/code&gt;), using sequence numbers to ensure bytes arrive in order and lost packets are retransmitted.&lt;/p&gt;
&lt;p&gt;When the HTTP response streams back, the browser splits the headers from the body and feeds the HTML into a streaming, error-tolerant parser to construct the DOM tree—the in-memory document model that acts as the shared contract between the HTML parser, CSS selectors, and JavaScript. Finally comes the rendering pipeline: Layout computes box sizes and positions, Paint fills in pixels, and Composite layers them together on the GPU. Not every change triggers the full pipeline: changing a color usually only requires repainting, whereas changing element dimensions forces a layout recalculation—which is why layout-heavy pages feel noticeably slower.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verdict&lt;/strong&gt;: &lt;em&gt;I&amp;rsquo;m not sure why, but I feel like this issue turned out pretty well^^ Probably because I updated &lt;code&gt;AGENTS.md&lt;/code&gt; yesterday—let&amp;rsquo;s keep the momentum going :)))&lt;/em&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 #31</title><link>https://miti99.com/en/post/2025/05/18/</link><pubDate>Sun, 18 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/18/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #31.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="optimizing-our-e2e-pipeline"&gt;&lt;a href="https://slack.engineering/speedup-e2e-testing/" rel="noopener noreferrer"&gt;Optimizing Our E2E Pipeline&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack&amp;rsquo;s DevXP team shares how they optimized the end-to-end (E2E) test pipeline for the company&amp;rsquo;s largest monorepo. Previously, each run took about 10 minutes, with nearly half of that spent building the frontend—even when a change didn&amp;rsquo;t touch frontend code at all. With hundreds of pull requests merged daily, that produced thousands of builds per week, each taking nearly 1 GB on AWS S3 and adding up to terabytes of duplicate artifacts.&lt;/p&gt;
&lt;p&gt;Their solution used tools they already had: run &lt;code&gt;git diff&lt;/code&gt; with three-dot syntax to compare the current branch against its merge-base with &lt;code&gt;main&lt;/code&gt;; if no frontend files changed, skip the build step and reuse a recent production build served through an internal CDN. Even in a repository with over 100,000 files, detecting changes and locating a matching build takes under 3 seconds. As a result, total builds dropped by 60%, saving hundreds of compute hours per month and several terabytes of storage, while average build time fell from about 5 minutes to 2 minutes (and combined with an earlier Webpack upgrade, from 10 minutes down to 2 minutes overall). As an unexpected bonus, tests also became more stable and less flaky. The takeaway: regularly question which pipeline steps are actually necessary, even in systems that aren&amp;rsquo;t visibly broken.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="doordash"&gt;&lt;a href="https://careersatdoordash.com/blog/doordash-fast-travel-estimates/" rel="noopener noreferrer"&gt;DoorDash&amp;rsquo;s Fast Travel Estimates&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DoorDash engineers explain how they estimate travel distance and duration in milliseconds—a core input for finding nearby stores, predicting delivery ETAs, calculating fees, and matching dashers. Calling a routing engine like OSRM directly typically takes over 100 ms, which is too slow for latency-sensitive paths like homepage refreshes or search ranking, while straight-line (haversine) distance is fast but inaccurate because it ignores real road networks.&lt;/p&gt;
&lt;p&gt;Their answer is Geo-Grid-Cache: partition the entire service area into hexagonal cells using the H3 spatial index, then precompute travel times between cell centers with OSRM under average traffic conditions. Each pair is stored across three resolution tiers—fine for trips under a mile, medium, and coarse for distances up to 100 miles—balancing cache hit rate, storage cost, and accuracy. At request time, the system looks up the pair in a Redis cluster and picks the highest resolution available. The hardest part was generating offline data for roughly 6 billion cell pairs; the team ran Spark on Databricks and installed OSRM directly on the cluster nodes to replace network calls with local HTTP calls, speeding up generation by 10x. The result is ultra-low latency, accuracy close to the internal routing engine, and major compute savings.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="tech-hiring-is-this-an-inflection-point"&gt;&lt;a href="https://blog.pragmaticengineer.com/tech-hiring-is-this-an-inflection-point/" rel="noopener noreferrer"&gt;Tech Hiring: Is This an Inflection Point?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz (The Pragmatic Engineer) highlights a paradox: even though fewer companies are hiring and more candidates are competing for roles, many engineering managers say 2025 is the hardest hiring market they have ever seen. A telling case is maestro.dev, a fully remote startup: every LinkedIn job posting draws hundreds of mostly unqualified applications, cover letters are almost universally AI-generated, and many candidates read answers straight from AI tools during live coding interviews. When the team switched to a take-home assignment, the head of engineering embedded a hidden prompt instruction aimed at AI assistants inside the spec—all four submissions followed the hidden instruction, even though three of the candidates insisted they hadn&amp;rsquo;t used AI. The most reliable signal came instead from candidates who reached out directly to explain why they wanted to join.&lt;/p&gt;
&lt;p&gt;Another remote company had to fire a senior data engineer after just two weeks upon discovering the person had fabricated their experience and used multiple AI tools simultaneously to pass the interview loop. That company is now considering adding a final in-person interview round despite the $1,500–$2,000 cost per candidate, while leaning harder on referrals since 4 of its last 5 hires came through internal recommendations. The post also covers LinkedIn Recruiter costs of $5,000–$20,000 per seat per month, the rise of paid &amp;ldquo;work trial&amp;rdquo; weeks, and the need to redesign remote hiring from the ground up in the AI era.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="underusing-snapshot-testing"&gt;&lt;a href="https://matklad.github.io/2025/04/15/underusing-snapshot-testing.html" rel="noopener noreferrer"&gt;Underusing Snapshot Testing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Aleksey Kladov (matklad), creator of rust-analyzer, explains why he thinks he still underuses snapshot testing. The idea is straightforward: serialize a test&amp;rsquo;s output into text, compare it against an expected string literal embedded right in the source file, and use a tool to automatically update that literal from the actual output. The obvious benefit is easy maintenance when requirements change: the tool rewrites the expected output so the author can review the diff instead of editing strings by hand.&lt;/p&gt;
&lt;p&gt;What surprised him came from implementing permutation encoding in Zig—a problem whose requirements never change. With traditional assertion-based tests, execution stops at the first failure and the output is buried in a terminal window far from the code. Switching to inline snapshots surfaced every wrong result right inside the source file, letting him see the full picture at once and quickly spot two off-by-one bugs. In his view, snapshot tests keep data close to the programmer, tighten the feedback loop, and act like a repeatable REPL, speeding up development even when requirements are fixed. The end of the post also explains why a handful of concrete examples remain valuable alongside exhaustive testing over all permutations.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="principles-for-coding-securely-with-llms"&gt;&lt;a href="https://www.seangoedecke.com/ai-security/" rel="noopener noreferrer"&gt;Principles for coding securely with LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that LLM security shouldn&amp;rsquo;t be treated as a long checklist of disconnected threats, but derived from a single principle: LLMs sometimes act maliciously, so treat their output like untrusted user input. Prompt injection is fundamentally unavoidable—the moment you bring third-party content (web pages, docs, Cursor rules files) into the context window, you give its author a chance to steer the model, and no model is immune to jailbreaks.&lt;/p&gt;
&lt;p&gt;From that principle, every tool an LLM is allowed to call should be scoped and authorized like a public user-facing API: for example, expose &lt;code&gt;fetch_messages()&lt;/code&gt; rather than &lt;code&gt;fetch_messages(user_id)&lt;/code&gt; so the model cannot read another user&amp;rsquo;s messages, and require explicit human confirmation for high-impact actions like sending messages or transferring money. MCP servers are effectively remote libraries, meaning you are trusting the server&amp;rsquo;s owner, not just its interface. Even without an attacker, LLMs can hallucinate or take reckless actions, so human approval gates must be enforced in tool code rather than requested in the prompt. Goedecke also notes risks from fine-tuned or self-trained models (goal misalignment or leaking sensitive training data) and denial-of-service (DoS) attacks, since LLM calls are slow and GPU-heavy—cap concurrent sessions, token budgets, and tool access accordingly.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-i-don"&gt;&lt;a href="https://www.gleech.org/llms" rel="noopener noreferrer"&gt;How I don&amp;rsquo;t use LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gavin Leech, an AI PhD, candidly explains why he rarely uses LLMs for intellectual work despite knowing firsthand how capable they are. Every time a new frontier model comes out, he tries it, and every time it confidently makes a serious error within the first few minutes. His reasons include loving writing enough that editing weak prose takes more effort than drafting from scratch, already having solid foundational knowledge across many fields, needing high accuracy and reliability when learning, disliking the model&amp;rsquo;s voice and habit of bluffing, worrying about skill atrophy, and not writing much code at the time.&lt;/p&gt;
&lt;p&gt;Even so, he still uses LLMs in specific situations: as a search replacement (only when citations are provided), for tip-of-the-tongue term recall, finding entry-point keywords in an unfamiliar field, semantic search over document collections, validating and converting JSON to CSV, getting past blank-page syndrome, and especially writing Matplotlib code or untangling Docker, WSL, and Cloudflare issues. To bypass model sycophancy, he frames his own ideas as if they came from someone else. The post strikes a balanced, self-critical tone: Leech admits part of the problem may be his own impatience, while warning that LLMs can quietly plant a few plausible falsehoods in your head every day.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-senior-software-engineers-can-learn-from-junior-engineers"&gt;&lt;a href="https://www.infoq.com/news/2025/04/software-engineers-learning/" rel="noopener noreferrer"&gt;How Senior Software Engineers Can Learn from Junior Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This InfoQ piece summarizes Beth Anderson&amp;rsquo;s QCon London talk on what senior engineers can learn from junior teammates. She notes that steep power distances on a team make junior engineers hesitant to speak up even when they spot a problem with serious consequences, stifling innovation and collaboration. Rather than treating mentorship as a one-way street, senior engineers should recognize that junior colleagues often bring high energy, fresh perspectives, and up-to-date skills.&lt;/p&gt;
&lt;p&gt;To build an inclusive culture, Anderson recommends active listening, amplifying others&amp;rsquo; voices, crediting contributions, and creating the psychological safety needed for juniors to ask questions freely. One concrete practice is &amp;ldquo;reverse feedback&amp;rdquo;: asking junior engineers to critique how seniors communicate with them, asking how they prefer to learn, and inviting them to review senior engineers&amp;rsquo; code and pull requests as a learning exercise. She also urges juniors not to repeat the dismissive behaviors that once frustrated them when they become seniors themselves, because seniority is not about authority—it is an opportunity to create positive change. Every engineer, at every level, has a perspective worth learning from if we are willing to listen.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="as-an-engineer-i"&gt;&lt;a href="https://shiftmag.dev/asking-questions-engineering-career-advice-4895/" rel="noopener noreferrer"&gt;As an engineer, I&amp;rsquo;d rather be called stupid than stay silent&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marko Antanaskovic recounts overcoming imposter syndrome while working as a Customer Support Engineer at Infobip. Opening with a fictional incident call packed with impenetrable jargon, he captures a familiar feeling: not understanding what the developers are saying, yet staying quiet out of fear of looking stupid while the customer waits for an update. Realizing nobody could know everything across such a massive platform—and that no textbook covered it—he decided to tap the knowledge of his colleagues by asking &amp;ldquo;stupid&amp;rdquo; questions like &amp;ldquo;What does that actually mean?&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Antanaskovic points out the real cost of silence: prolonged outages because nobody connects the technical symptom to customer impact, poor work caused by misunderstood requirements, and meetings that sink into awkward silence. To build a questioning culture, he suggests being the first to ask, shifting from blame to education in the spirit of a blameless culture, and trusting the people around you. That willingness to look &amp;ldquo;stupid&amp;rdquo; helped him build enough deep system knowledge to transition into a Reliability Operations Engineer role. His closing takeaway: no sincere question is stupid, and it is far better to risk looking foolish than to stay silent and make preventable mistakes.&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 #30</title><link>https://miti99.com/en/post/2025/05/17/</link><pubDate>Sat, 17 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/17/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #30 - Today&amp;rsquo;s tech news roundup.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-i"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2025/04/what-id-do-as-college-freshman.html" rel="noopener noreferrer"&gt;What I&amp;rsquo;d do as a College Freshman in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Computer science professor Murat Demirbas asks what he would do if he were starting college over as a freshman in 2025, and his first answer is still to study Computer Science. Against the claim that &amp;ldquo;nobody needs to learn programming anymore,&amp;rdquo; he argues that AI tools cannot replace real mastery: debugging skills, abstract thinking, and fast adaptability have to be forged firsthand. He advises building a strong foundation in both computer science and AI, then pairing AI with a deep domain such as systems, databases, or programming languages—aiming to become &amp;ldquo;π-shaped,&amp;rdquo; with depth in two areas and broad literacy across many others.&lt;/p&gt;
&lt;p&gt;Beyond technical depth, soft skills are indispensable: clear communication powers remote work, learning in public, and even working with LLMs, while management starts with managing yourself. Demirbas still views the US as the best launchpad for a tech career and university as the best place to meet talented peers and build projects together. Borrowing a friend&amp;rsquo;s metaphor, he says you should either be an all-terrain Jeep with an entrepreneurial mindset, or a specialized, high-speed Ferrari when a paved track exists—just don&amp;rsquo;t be an easily replaceable Corolla, because in the AI era that is what gets automated away. Finally, play the long game, compounding skills and relationships rather than chasing trends.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="llms-are-weird-computers"&gt;&lt;a href="https://www.phillipcarter.dev/posts/llms-computers" rel="noopener noreferrer"&gt;LLMs Are Weird Computers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phillip Carter proposes a useful mental model for large language models (LLMs): treat them as a &amp;ldquo;weird&amp;rdquo; or &amp;ldquo;inverted&amp;rdquo; kind of computer alongside the &amp;ldquo;normal&amp;rdquo; computers we already know. Traditional computers execute with exact precision but struggle with ambiguity, whereas LLMs do the opposite: they excel at handling ambiguity but struggle when absolute precision is required.&lt;/p&gt;
&lt;p&gt;Viewing LLMs as a new class of computer with its own distinct properties helps developers better understand their strengths and limits, making it clearer which tasks to hand to an LLM and when traditional computation is still the right tool.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="every-caching-strategy-explained-in-5-minutes"&gt;&lt;a href="https://www.swequiz.com/blog/every-caching-strategy-explained-in-5-minutes" rel="noopener noreferrer"&gt;Every Caching Strategy Explained in 5 Minutes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This SWE Quiz post gives a quick tour of common caching strategies, a foundational topic for optimizing application performance. With Cache-Aside (also called lazy loading), the application manages the cache directly: it checks the cache first and queries the database only on a miss, which fits read-heavy systems that can tolerate briefly stale data. Read-Through instead has the application talk only to the cache while the cache itself loads missing data from the database, keeping application code cleaner.&lt;/p&gt;
&lt;p&gt;On the write side, Write-Through writes synchronously to both the cache and the database, guaranteeing consistency at the cost of slower writes. Write-Behind (Write-Back) writes only to the cache and flushes to the database asynchronously later, speeding up writes but risking data loss if the cache fails before syncing. Write-Around bypasses the cache on writes and uses it only for reads, which suits data that is rarely re-read immediately after being written. Choosing the right strategy depends on an application&amp;rsquo;s specific trade-offs across performance, consistency, and fault tolerance.&lt;/p&gt;
&lt;h2 id="some-features-that-every-javascript-developer-should-know-in-2025"&gt;&lt;a href="https://waspdev.com/articles/2025-04-06/features-that-every-js-developer-must-know-in-2025" rel="noopener noreferrer"&gt;Some features that every JavaScript developer should know in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This WaspDev article rounds up modern JavaScript features every developer should know to write cleaner, more efficient code. Standouts include iterator helper methods like &lt;code&gt;drop()&lt;/code&gt;, &lt;code&gt;take()&lt;/code&gt;, and &lt;code&gt;filter()&lt;/code&gt;, which process large datasets lazily one element at a time without allocating memory-hungry intermediate arrays. The &lt;code&gt;at()&lt;/code&gt; method supports negative indexing on arrays, such as &lt;code&gt;arr.at(-1)&lt;/code&gt; to grab the last element, while &lt;code&gt;Promise.withResolvers()&lt;/code&gt; cleanly exposes &lt;code&gt;resolve&lt;/code&gt; and &lt;code&gt;reject&lt;/code&gt; alongside a newly created Promise.&lt;/p&gt;
&lt;p&gt;The post also highlights underused techniques: passing a callback function to &lt;code&gt;replace()&lt;/code&gt; and &lt;code&gt;replaceAll()&lt;/code&gt; for complex string substitutions, swapping two variables via &lt;code&gt;[a, b] = [b, a]&lt;/code&gt; instead of a temporary variable, and deep-cloning objects with &lt;code&gt;structuredClone()&lt;/code&gt; rather than &lt;code&gt;JSON.parse(JSON.stringify())&lt;/code&gt;. Rounding out the list are tagged templates for flexible template-literal processing, &lt;code&gt;WeakMap&lt;/code&gt;/&lt;code&gt;WeakSet&lt;/code&gt; for attaching metadata to objects without preventing garbage collection, and new &lt;code&gt;Set&lt;/code&gt; operations like &lt;code&gt;union()&lt;/code&gt;, &lt;code&gt;intersection()&lt;/code&gt;, and &lt;code&gt;difference()&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="what-makes-a-great-developer-experience"&gt;&lt;a href="https://www.codesimplicity.com/post/what-makes-a-great-developer-experience/" rel="noopener noreferrer"&gt;What Makes a Great Developer Experience?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Kanat-Alexander, who has spent over 20 years working on developer experience (DX) and helped design key parts of DX at Google and LinkedIn, distills the field&amp;rsquo;s core principles. In his view, a great DX optimizes three things: cycle time, the elapsed time from when a developer forms an intent to when that intent is fulfilled; focus, the ability to work in uninterrupted flow; and cognitive load, the amount of knowledge required and the number of decisions a developer must make to get something done.&lt;/p&gt;
&lt;p&gt;Most of the post focuses on the practical challenges of improving DX: understanding the real problem through data and developer feedback, managing change through gradual rollouts and driving adoption, building high-leverage tools that save human time rather than just machine resources, saying &amp;ldquo;no&amp;rdquo; or &amp;ldquo;not yet&amp;rdquo; kindly to requests that don&amp;rsquo;t fit, and placing the burden on the party actually causing the problem. The overarching lesson is that the hardest part of DX is usually human rather than technical.&lt;/p&gt;
&lt;h2 id="when-life-gives-you-java"&gt;&lt;a href="https://oblac.rs/when-life-gives-you-java/" rel="noopener noreferrer"&gt;When Life Gives You Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Igor Spasić shares how he writes Java when he has to use the language but still wants clean code, borrowing ideas from more expressive functional languages. He makes classes package-private by default and exposes them publicly only when strictly necessary, treating each package as a module. Roughly 95% of references are marked &lt;code&gt;final&lt;/code&gt; to embrace immutability, which makes &lt;code&gt;null&lt;/code&gt; nearly disappear outside very narrow boundaries. He no longer uses inheritance in his own code, favoring object composition instead, while still accepting inheritance where external libraries require it.&lt;/p&gt;
&lt;p&gt;Spasić thinks in terms of &amp;ldquo;input, process, output&amp;rdquo; functions: because Java lacks true first-class functions, each class typically wraps a single function or a small group of closely related ones. Algebraic data types (ADTs) are modeled as &lt;code&gt;record&lt;/code&gt;s implementing a &lt;code&gt;sealed interface&lt;/code&gt;, and domain errors are returned as part of the result via dedicated ADTs, reserving exceptions for genuine runtime failures like out-of-memory errors, I/O failures, or lost database connections. That produces more small classes, which he considers a worthwhile trade-off for more modular code with fewer surprises.&lt;/p&gt;
&lt;h2 id="just-throw-it-into-postgres"&gt;&lt;a href="https://simonsafar.com/2025/throw_it_into_postgres/" rel="noopener noreferrer"&gt;Just Throw It Into Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Safar argues that between the two extremes of forcing all data into a strictly normalized relational schema and dumping raw data into countless files in a directory tree, there is a practical middle ground: just throw the data straight into PostgreSQL without overthinking upfront organization. Thanks to &lt;code&gt;JSONB&lt;/code&gt;, PostgreSQL can query fields inside JSON documents directly, while indexes and dedicated columns can be added later once the data is already there.&lt;/p&gt;
&lt;p&gt;He illustrates this with three examples. First, he built a custom Java code-navigation tool for Emacs: it parsed compiled class files to record relationships like &amp;ldquo;function A calls function B,&amp;rdquo; then loaded hundreds of thousands of records into PostgreSQL via &lt;code&gt;COPY&lt;/code&gt; in a few dozen seconds—fast enough to invoke &lt;code&gt;psql&lt;/code&gt; multiple times per second for autocomplete. Second, he loaded tens of thousands of Chinese character SVGs from the Make Me a Hanzi project into a table with a &lt;code&gt;JSONB&lt;/code&gt; column and joined it against a dictionary table for fast lookups. Third, he stored temperature sensor readings arriving over MQTT so Grafana could chart them. The takeaway: get the data stored first and organize it later, rather than trying to design the perfect schema on day one.&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 #15</title><link>https://miti99.com/en/post/2025/05/02/</link><pubDate>Fri, 02 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/02/</guid><description>&lt;p&gt;&lt;em&gt;Normally I follow a one-post-per-day format, but lately I&amp;rsquo;ve been too lazy to write and have accumulated way too many interesting articles. So for the near future I&amp;rsquo;ll pull a little trick by backdating posts and writing more to catch up on my backlog. For example, today is May 10th, but I&amp;rsquo;m writing this for May 2nd—just check the git history and you&amp;rsquo;ll see, hehe. Enjoy Newsletter #15.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="heres-how-i-use-llms-to-help-me-write-code"&gt;&lt;a href="https://simonwillison.net/2025/Mar/11/using-llms-for-code/" rel="noopener noreferrer"&gt;Here’s how I use LLMs to help me write code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison reflects on more than two years of using large language models (LLMs) to assist with coding and argues that using LLMs effectively is a skill that takes practice, not something that comes naturally. According to him, you should treat an LLM as an advanced autocomplete tool: it fills in knowledge gaps but can still make unpredictable mistakes, so the human must always stay in control. He also notes the training data cutoff limitation: for libraries that have changed significantly since the cutoff date, you need to include fresh examples directly in your prompt. Conversation context is everything, so proactively provide existing source code, sample examples, or use tools that can load your entire project.&lt;/p&gt;
&lt;p&gt;In practice, he uses LLMs to explore library options and implementation approaches early on; when writing actual code, he gives detailed instructions such as function signatures and clear requirements, then iteratively asks for edits and refactoring across multiple turns rather than throwing away the first result. Running and testing the code yourself is non-negotiable. The article shares an example of building a commit history aggregation page with Claude Code in about 17 minutes at a cost of $0.61, though he still had to configure GitHub Actions by hand. The biggest benefit is speed: LLMs make projects feasible that previously weren&amp;rsquo;t worth the effort, while amplifying a developer&amp;rsquo;s existing expertise.&lt;/p&gt;
&lt;h2 id="i-use-cursor-daily---here"&gt;&lt;del&gt;&lt;a href="https://www.nickcraux.com/blog/cursor-tips" rel="noopener noreferrer"&gt;I use Cursor daily - here&amp;rsquo;s how I avoid the garbage parts&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This post shares practical tips from daily use of Cursor, a code editor built on VS Code with deep integration of large language models like GPT-4. The author covers essential keyboard shortcuts, how to write prompts for more accurate AI responses, how to leverage codebase-wide chat, and strategies for optimizing workflows and configuring Cursor to fit individual developers and projects.&lt;/p&gt;
&lt;p&gt;Notably, the author emphasizes harmonious collaboration between humans and AI rather than blindly leaving everything to the tool, resulting in higher-quality code in less time. It is a useful reference for both newcomers and experienced Cursor users looking to get more out of the editor.&lt;/p&gt;
&lt;h2 id="why-java-endures-the-foundation-of-modern-enterprise-development"&gt;&lt;a href="https://github.blog/developer-skills/why-java-endures-the-foundation-of-modern-enterprise-development/" rel="noopener noreferrer"&gt;Why Java endures: The foundation of modern enterprise development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This GitHub Blog article explains why Java, created in 1995 at Sun Microsystems, remains the foundation of enterprise software development nearly 30 years later. At the root of Java&amp;rsquo;s strength is the &amp;ldquo;write once, run anywhere&amp;rdquo; principle: code written once can run across multiple operating systems without recompilation. The language continues to modernize—for instance, Java 23 (September 2024) simplifies syntax for beginners, while pattern matching and record classes help keep code concise and maintainable.&lt;/p&gt;
&lt;p&gt;Furthermore, Java&amp;rsquo;s ecosystem is massive, spanning the standard library and frameworks like Spring Boot and Hibernate so developers don&amp;rsquo;t have to reinvent common solutions; Minecraft, Netflix, and LinkedIn are prime examples. In AI, while Python dominates research, Java excels at large-scale deployment—such as Uber&amp;rsquo;s Michelangelo platform—and libraries like Deeplearning4j and LangChain4j make it straightforward to add AI capabilities to existing Java systems. The article concludes that Java remains a highly sought-after skill on the job market and will retain its position thanks to its commitment to durable, scalable, and maintainable code.&lt;/p&gt;
&lt;h2 id="part-5-implementing-a-web-ui-using-vaadin-and-github-copilot-agent-mode"&gt;&lt;a href="https://itnext.io/part-5-implementing-a-web-ui-using-vaadin-and-github-copilot-agent-mode-563e74f131aa" rel="noopener noreferrer"&gt;Part 5: Implementing a Web UI using Vaadin and GitHub Copilot Agent Mode&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the fifth installment in Saeed Zarinfam&amp;rsquo;s series on using AI-powered IDEs for Java development. Here, the author uses VS Code with GitHub Copilot Agent Mode and Claude 3.5 Sonnet to build a web UI with Vaadin Flow—a niche framework for writing web interfaces entirely in Java—for a sample Employee Assistance Chatbot project built with Spring AI. He documents the exact steps and prompts used to see Copilot Agent Mode in action, while comparing it against Windsurf&amp;rsquo;s Cascade agent, which he had previously used smoothly to build a cached REST service with Spring Boot.&lt;/p&gt;
&lt;p&gt;The key difference this time is that the author is not very familiar with Vaadin Flow, making the post a test of whether LLMs truly help when working with a less popular framework. As the article&amp;rsquo;s subtitle hints, the answer is fairly cautious: LLMs are not yet well suited to niche programming languages and frameworks, so developers cannot rely entirely on AI when stepping into unfamiliar technology.&lt;/p&gt;
&lt;h2 id="microservices-vs-monoliths-how-to-choose-the-right-architecture-for-your-project"&gt;&lt;a href="https://dev.to/jhonifaber/microservices-vs-monoliths-how-to-choose-the-right-architecture-for-your-project-2bep" rel="noopener noreferrer"&gt;Microservices vs. Monoliths: How to Choose the Right Architecture for Your Project&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article compares two common architectures—monoliths and microservices—to help engineering teams choose the right approach. In a monolith, the UI, business logic, and database operations live together in a single deployment unit, making it easy to build, test, debug, and operate. In exchange, scaling requires replicating the entire system rather than just the bottlenecked parts, large teams frequently run into merge conflicts, the tech stack is locked in across the whole application, and every small change forces a full redeployment, increasing risk.&lt;/p&gt;
&lt;p&gt;Microservices split an application into independent services, each owning a specific business capability and communicating over APIs. This allows selective scaling, autonomous teams, and per-service technology choices. Service isolation can help contain failures, though it does not guarantee that a failure in one service won&amp;rsquo;t cascade to dependent ones. The trade-off is high complexity: you need orchestration, monitoring, and service discovery tools while dealing with network latency and data consistency. The article introduces the SAGA pattern—a sequence of local transactions with compensating actions—and its two implementation styles: choreography (event-driven, decentralized) and orchestration (centrally coordinated). Choosing the right architecture depends on your application&amp;rsquo;s needs, team size, and long-term goals.&lt;/p&gt;
&lt;h2 id="designing-a-scalable-architecture---with-some-spring-boot-examples"&gt;&lt;a href="https://dev.to/jhonifaber/designing-a-scalable-architecture-with-some-spring-boot-examples-340o" rel="noopener noreferrer"&gt;Designing a Scalable Architecture - with Some Spring Boot Examples&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post outlines core principles for designing scalable systems, complete with Spring Boot examples. The author distinguishes vertical scaling (adding power to a single machine) from horizontal scaling (adding more instances), then walks through key building blocks: breaking applications into microservices for independent scaling, managing configuration with Spring Cloud Config and packaging with Docker, and designing stateless services—such as using JWT authentication so servers don&amp;rsquo;t need to store and look up session state.&lt;/p&gt;
&lt;p&gt;At the data layer, the article covers sharding, read replicas to offload the primary database, and NoSQL options like MongoDB with their trade-offs between consistency and availability. For asynchronous processing, it introduces message brokers like Kafka and RabbitMQ alongside Spring Boot&amp;rsquo;s &lt;code&gt;@Async&lt;/code&gt; annotation to run methods on separate threads. It also discusses caching with &lt;code&gt;@Cacheable&lt;/code&gt; and &lt;code&gt;@CacheEvict&lt;/code&gt;, plus an API Gateway handling routing, authentication, rate limiting, and circuit breaking. Finally, the author reminds readers that logging, security, monitoring, and error handling are essential to keeping a system resilient as it grows.&lt;/p&gt;
&lt;h2 id="java-is-very-fast-if-you-dont-create-many-objects"&gt;&lt;a href="https://blog.vanillajava.blog/2022/09/java-is-very-fast-if-you-dont-create.html" rel="noopener noreferrer"&gt;Java is Very Fast, If You Don’t Create Many Objects&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;High-performance Java specialist Peter Lawrey demonstrates that object allocation heavily impacts Java performance in high-throughput systems, even when garbage collection (GC) itself is cheap. In a Chronicle Wire benchmark on a Ryzen 5950X CPU, with zero object allocations, the system processed around 60–68 million events per second at a latency of 467–528 nanoseconds; allocating just a single 44-byte object per event dropped throughput to roughly 37–50 million events per second—about a 25% reduction—and added roughly 166 nanoseconds of latency.&lt;/p&gt;
&lt;p&gt;Interestingly, GC took only about 170 milliseconds per minute (0.3% of runtime), showing that the bottleneck lies not in cleanup, but in pressure on the CPU&amp;rsquo;s L1/L2/L3 caches when multiple cores allocate memory simultaneously. In multi-threaded tests, the allocation rate plateaued around 220 million objects per second, and latency spiked sharply beyond eight threads. Chronicle Wire solves this by reusing the same object per event type by default during deserialization, eliminating allocations while keeping the code simple. The takeaway: for latency-sensitive systems like finance, reducing object allocation yields far bigger gains than tuning GC.&lt;/p&gt;
&lt;h2 id="microbenchmarks-java-locks-vs-atomic"&gt;&lt;del&gt;&lt;a href="https://blog.tombert.com/posts/2025-03-04-lock-benchmark/" rel="noopener noreferrer"&gt;Microbenchmarks: Java Locks vs Atomic&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This article presents a detailed analysis of the performance of various synchronization mechanisms in multithreaded programming. The author benchmarked different lock types—including mutexes, spin locks, read-write locks, and lock-free solutions—evaluating them under varying load scenarios.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The benchmark results show significant differences across lock types, with several interesting findings:&lt;/del&gt;
&lt;del&gt;1. Spin locks are generally more efficient than mutexes for short tasks with low contention&lt;/del&gt;
&lt;del&gt;2. Read-write locks offer major benefits in read-heavy, write-light workloads&lt;/del&gt;
&lt;del&gt;3. Lock-free solutions can deliver superior performance in certain cases, but are significantly more complex to implement and maintain&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The article also discusses factors affecting lock performance such as latency, throughput, thread scalability, and the impact of cache coherence. The author provides practical guidelines for choosing the right synchronization mechanism based on application characteristics and data access patterns.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;This is a valuable reference for developers working on high-performance multithreaded systems, helping them make informed decisions when selecting synchronization mechanisms for their specific project requirements.&lt;/del&gt;&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/ad16adef-3082-42bd-ac99-9a569ad2e33b_2250x2624.png" alt="API Protocols 101"&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 #7</title><link>https://miti99.com/en/post/2025/03/16/</link><pubDate>Sun, 16 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #7.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-llm-curve-of-impact-on-software-engineers"&gt;&lt;a href="https://serce.me/posts/2025-02-07-the-llm-curve-of-impact-on-software-engineers" rel="noopener noreferrer"&gt;The LLM Curve of Impact on Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov proposes a hypothesis to explain the sharp divide over how useful LLMs really are: their day-to-day value depends heavily on an engineer&amp;rsquo;s seniority, tracing out a distinct curve. For Junior engineers who are still building their mental models of code, LLMs are a lifesaver when deciphering errors, implementing small features, or upgrading libraries. Yet this is also a danger zone: if they just copy and paste code back and forth without understanding why it works, their fundamental skills can stagnate. Mid-level engineers still write code and pick up new frameworks faster with LLMs, but increasingly run into tasks LLMs can&amp;rsquo;t handle—such as figuring out what a customer actually wants from a vague request, hunting down race conditions in a debugger, or handling a 2 a.m. production outage.&lt;/p&gt;
&lt;p&gt;Under this hypothesis, Senior engineers are the most skeptical group. They already hold the system&amp;rsquo;s architecture in their heads, spend a smaller fraction of their day typing boilerplate, and focus on work—roadmapping, debugging gnarly non-reproducible issues, writing design docs—that depends on deep organizational and system context the LLM doesn&amp;rsquo;t have; the more specialized the domain, the sharper the disillusionment. At the Staff+ level, however, the curve bends back up: their job often involves prototyping to blaze trails for other teams, and LLMs drastically speed up building proofs of concept, while their deep expertise lets them immediately spot and untangle whatever corners the model paints itself into. Understanding this curve, the author suggests, builds empathy: the skeptics and the enthusiasts are simply doing very different jobs.&lt;/p&gt;
&lt;h2 id="you-are-using-cursor-ai-incorrectly"&gt;&lt;a href="https://ghuntley.com/stdlib/" rel="noopener noreferrer"&gt;You are using Cursor AI incorrectly&amp;hellip;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Geoffrey Huntley argues that most engineers—from juniors to principals—are using Cursor the wrong way: treating it as a Google replacement, writing bare-bones prompts like &amp;ldquo;implement XYZ,&amp;rdquo; using it as a text editor rather than an autonomous agent, and failing to realize that you can &amp;ldquo;program&amp;rdquo; the probability distribution of an LLM&amp;rsquo;s output. His solution is to build a personal &amp;ldquo;stdlib&amp;rdquo; (standard library) of thousands of rules stored in &lt;code&gt;.cursor/rules/&lt;/code&gt;, where each rule is a structured &lt;code&gt;.mdc&lt;/code&gt; file defining filters and actions, named with a consistent convention, and composed together like Unix pipes.&lt;/p&gt;
&lt;p&gt;With these rules in place, you can shape Cursor&amp;rsquo;s behavior permanently: when Cursor kept suggesting Bazel commands even though the author wanted Nix exclusively, he wrote a &lt;code&gt;no_bazel&lt;/code&gt; rule to banish Bazel suggestions altogether. Rules also automate development workflows, such as automatically inserting license headers into new files or committing changes once a task is complete. By the author&amp;rsquo;s estimate, current LLMs are only about 45% accurate out of the box and need constant steering, so continuously curating and refining your rule library is the key to getting real leverage out of Cursor.&lt;/p&gt;
&lt;h2 id="how-do-you-spend-your-time"&gt;&lt;a href="https://brooker.co.za/blog/2024/02/06/time.html" rel="noopener noreferrer"&gt;How Do You Spend Your Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker writes for engineers who feel constantly busy and get plenty done, yet worry they aren&amp;rsquo;t spending their time on the highest-value work for their team and projects. His approach is to set an explicit &amp;ldquo;time budget&amp;rdquo;: pick five or six broad categories of work along with a target percentage of time for each, stay flexible week to week while holding the line over the long run, and review the breakdown periodically with your manager. The act of writing the budget down is the most valuable part, because it forces you to think hard about what success actually looks like in your role. His own buckets include individual technical work (writing, reading, and reviewing code, debugging, design docs), mentoring and teaching, long-term strategy, day-to-day operational rhythm, learning (reading papers, prototyping algorithms), and talking with customers. The exact split matters less than doing the exercise deliberately.&lt;/p&gt;
&lt;p&gt;Sticking to a time budget requires learning to say &amp;ldquo;no.&amp;rdquo; Brooker warns against several traps: chasing high-visibility shiny objects or hype, getting sucked into urgent but low-importance chores, and letting your calendar run away from you—like a senior engineer sitting in 20 hours of meetings a week where nobody sees him contributing much, simply because everyone assumes someone else invited him for a good reason. He applies this same lens at the organizational level and borrows the economics concept of &amp;ldquo;revealed preference&amp;rdquo;: how we actually spend our hours reveals our true priorities, just like claiming you love salad while ordering a burger every day.&lt;/p&gt;
&lt;h2 id="we-are-destroying-software"&gt;&lt;a href="https://antirez.com/news/145" rel="noopener noreferrer"&gt;We are destroying software&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a short, manifesto-style post, Redis creator Salvatore Sanfilippo (antirez) lists the ways we are collectively &amp;ldquo;destroying&amp;rdquo; software: piling on features and premature optimizations without weighing their complexity cost; adopting convoluted build systems; assembling absurd dependency chains that leave everything bloated and fragile; telling junior programmers &amp;ldquo;don&amp;rsquo;t reinvent the wheel&amp;rdquo; when reinventing the wheel is precisely how you learn how wheels work—and the first step toward inventing better ones; abandoning API backward compatibility; pushing rewrites of battle-tested code that already works; and chasing every new language, paradigm, and framework fad.&lt;/p&gt;
&lt;p&gt;He also criticizes the habit of underestimating the cost of wrestling with sprawling third-party libraries compared to writing a focused solution yourself, assuming generic industry standards are always better than custom-fit designs, dismissing code comments as useless, and treating software as a purely mechanical engineering discipline. We build systems that cannot &amp;ldquo;scale down&amp;rdquo;—where simple things ought to remain simple—and optimize for coding velocity over design quality. The end result, he warns, is a field stripped of the joy of hacking.&lt;/p&gt;
&lt;h2 id="nontraditional-red-teams"&gt;&lt;a href="https://zachholman.com/posts/red-teams" rel="noopener noreferrer"&gt;Nontraditional Red Teams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Former GitHub engineer Zach Holman expands the concept of a &amp;ldquo;red team&amp;rdquo; (adversarial testers who probe a system for weaknesses) beyond cybersecurity to three everyday roles every product team should have. First is the person who checks whether a new graphic or logo accidentally looks like genital or NSFW imagery: GitHub once came dangerously close to printing its very first highway billboard with an illustration that looked uncannily like the infamous &amp;ldquo;goatse&amp;rdquo; shock image, even after dozens of employees had signed off on it. After that near miss, major design launches at GitHub included a dedicated review step asking how a visual might be misread, mocked, or abused out of context. Second is the ad-blocker user, who speaks up whenever a site breaks navigation simply because a tracking script or HTML snippet got blocked—one of the most frustrating experiences on the modern web.&lt;/p&gt;
&lt;p&gt;Third is the password-manager user. Holman vents about how many teams botch even the most basic login forms with custom inputs that prevent 1Password and similar tools from autofilling credentials. None of these are fatal showstoppers since determined users will eventually work around them, he notes, but they are completely avoidable self-inflicted wounds. When a team is heads-down shipping new features, it&amp;rsquo;s easy to miss these rough edges—which is why having an adversarial &amp;ldquo;red team&amp;rdquo; look at the product with fresh, skeptical eyes pays off.&lt;/p&gt;
&lt;h2 id="ai-or-die"&gt;&lt;a href="https://www.rkg.blog/ai-or-die.php" rel="noopener noreferrer"&gt;AI or Die&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ravi Gupta (RKG) opens with Anthropic CEO Dario Amodei&amp;rsquo;s prediction that as early as 2026 we could see AI models smarter than a Nobel Prize winner across most disciplines, capable of autonomously executing multi-day tasks and running millions of instances in parallel at 10x to 100x human speed—&amp;ldquo;a country of geniuses in a datacenter.&amp;rdquo; Gupta asks: is your company ready to harness that capability, or compete against companies that do? Even today&amp;rsquo;s models can already perform a substantial share of economically valuable work, yet most people barely scratch the surface because they lack ambition, lack the patience to supply rich context, and lack clear thinking and communication.&lt;/p&gt;
&lt;p&gt;To prepare, RKG recommends dedicating a full week to studying what AI can do today and where it is heading; tasking a tiny group to build an &amp;ldquo;AI-native&amp;rdquo; version of your product with a team 10x to 100x smaller; accepting that customers will soon demand dramatically better products at a fraction of the price; going &amp;ldquo;AI-first&amp;rdquo; with the same urgency Facebook once brought to mobile; and auditing every role in the organization to understand who will be supercharged by AI and which functions will be replaced. This isn&amp;rsquo;t an incremental tweak, he argues, but a full-scale &amp;ldquo;refounding&amp;rdquo; of the company—harder the larger and more successful you already are, yet essential to meet a future where, as Sam Altman put it, &amp;ldquo;maybe everyone on earth will be able to accomplish more than the most impactful person can today.&amp;rdquo;&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 #6</title><link>https://miti99.com/en/post/2025/03/08/</link><pubDate>Sat, 08 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/08/</guid><description>&lt;i&gt;
Happy International Women's Day (March 8)! Wishing all the ladies a wonderful day, and may you always stay joyful and happy!
Girls are meant to be loved :&gt;
Welcome to Newsletter #6.
&lt;/i&gt;
&lt;h2 id="how-i-use-llms-as-a-staff-engineer"&gt;&lt;a href="https://www.seangoedecke.com/how-i-use-llms/" rel="noopener noreferrer"&gt;How I use LLMs as a staff engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke, a staff engineer at GitHub, shares how he actually uses large language models (LLMs) in his day-to-day work. For production code, he uses Copilot primarily as a supercharged autocomplete for repetitive boilerplate like function arguments or type definitions; in his core stack (Ruby on Rails), he is still faster and better writing the logic himself. When making small changes in unfamiliar territory—such as a Go service or a C library—he leans on LLMs much more, asking questions like &amp;ldquo;is this idiomatic for this language?&amp;rdquo;, while always having a domain expert review the result. For throwaway code, like one-off research scripts running on his laptop, he lets the LLM write nearly everything and estimates it makes him 2–4x faster.&lt;/p&gt;
&lt;p&gt;In his view, the biggest value comes from using LLMs as an on-demand tutor when learning a new domain: asking follow-up questions, summarizing what he just learned in his own words, and asking the model to point out any misconceptions. He also uses LLMs as a last-resort rubber duck for debugging (asking once and moving on if it doesn&amp;rsquo;t help) and for proofreading long design documents for typos and logical gaps. Conversely, he never lets an LLM write an entire pull request in a codebase he knows well, never lets it draft ADRs or high-stakes technical strategy docs, and hasn&amp;rsquo;t found it useful yet for navigating massive codebases.&lt;/p&gt;
&lt;h2 id="software-development-topics-i"&gt;&lt;a href="https://chriskiehl.com/article/thoughts-after-10-years" rel="noopener noreferrer"&gt;Software development topics I&amp;rsquo;ve changed my mind on after 10 years in the industry&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Kiehl, a software engineer at Amazon, looks back on ten years in the industry through three short lists, following up on a similar post he wrote four years earlier. Things he has changed his mind on include: simplicity doesn&amp;rsquo;t happen by accident—it requires constant cultivation; there is no badge of honor in being able to juggle complexity; static typing is essential on teams with mixed skill levels; Java is great precisely because it is boring; most of the real work of programming should happen before writing the first line of code; &amp;ldquo;elegance&amp;rdquo; is a mirage; a great manager is worth their weight in gold; and DynamoDB is genuinely great when your access patterns match what it is built for.&lt;/p&gt;
&lt;p&gt;He also adds several new convictions: software engineering is mostly communication; thinking a problem is easy usually means you don&amp;rsquo;t understand it yet; junior engineers need room to try things and fail; you should avoid ORMs and write SQL directly; you will eventually regret building a system on Serverless Functions; distributed locking remains bafflingly hard; and test code can never have too many comments. Views he still holds: code coverage says nothing about test quality, monoliths are fine, microservices must be justified rather than chosen by default, and almost nobody needs &amp;ldquo;scale&amp;rdquo; the way they think they do.&lt;/p&gt;
&lt;h2 id="looking-under-the-lamppost-on-problem-solving"&gt;&lt;a href="https://edbatista.com/2025/01/looking-under-the-lamppost-on-problem-solving.html" rel="noopener noreferrer"&gt;Looking Under the Lamppost (On Problem-Solving)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ed Batista opens with the classic joke about a man searching for his lost keys under a streetlamp even though he dropped them in the dark yard, simply because &amp;ldquo;the light is better here.&amp;rdquo; That, Batista argues, is how we routinely approach problem-solving: instead of tackling the problem we &lt;em&gt;need&lt;/em&gt; to solve, we pick the problem we &lt;em&gt;want&lt;/em&gt; to solve. The reasons are all too human: the real problem lies outside our expertise; it takes too long when we crave the quick dopamine hit of crossing small tasks off a list; or it might not have an answer at all, exposing us to failure and embarrassment.&lt;/p&gt;
&lt;p&gt;The author doesn&amp;rsquo;t suggest beating yourself up over this tendency, but warns that if we only ever pick small, tractable problems we&amp;rsquo;re guaranteed to solve, we never grow—our comfort zone only expands when we step outside it. He draws a distinction between confidence (a calculation of your odds of success) and courage (recognizing that the cost of not trying outweighs the cost of failing). When we reframe failure as learning—or &amp;ldquo;eliminating possibilities,&amp;rdquo; as Peter Attia puts it—we realize that staying under the streetlamp is the real risk, because the answers to the problems that actually matter are out there in the dark.&lt;/p&gt;
&lt;h2 id="sliding-window-log-rate-limiter-redis--java"&gt;&lt;a href="https://foojay.io/today/sliding-window-log-rate-limiter-redis-java/" rel="noopener noreferrer"&gt;Sliding Window Log Rate Limiter (Redis &amp;amp; Java)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raphael De Lio walks through building a Sliding Window Log rate limiter using Redis and Java. Unlike the Fixed Window Counter, which slices time into rigid intervals, this algorithm logs the timestamp of every request and counts only those falling within a rolling window (such as the last second or minute), enforcing a smooth limit without sudden resets at window boundaries. Starting in Redis 7.4, the &lt;code&gt;HEXPIRE&lt;/code&gt; command allows setting a TTL on individual fields within a hash, which makes the implementation remarkably clean: each client gets its own hash, every allowed request is stored as a field that expires automatically after the window duration, and &lt;code&gt;HLEN&lt;/code&gt; returns the current count of active requests; if the count has reached the threshold, the new request is rejected.&lt;/p&gt;
&lt;p&gt;The Java implementation uses Jedis, wrapping &lt;code&gt;HSET&lt;/code&gt; and &lt;code&gt;HEXPIRE&lt;/code&gt; inside a transaction so they execute together and save network round-trips—though because the &lt;code&gt;HLEN&lt;/code&gt; read and threshold check happen outside the transaction, concurrent requests can still race past the check; each field key uses a random UUID so multiple requests arriving in the same millisecond don&amp;rsquo;t overwrite one another. Finally, the author writes a test suite using Redis TestContainers, JUnit 5, and AssertJ covering requests within the limit, exceeding the limit, window expiration roll-off, and concurrent access from multiple clients.&lt;/p&gt;
&lt;h2 id="project-loom-structured-concurrency--java"&gt;&lt;a href="https://foojay.io/today/project-loom-structured-concurrency-java/" rel="noopener noreferrer"&gt;Project Loom: Structured Concurrency – Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mahendra Rao B introduces Structured Concurrency, a Project Loom feature that debuted as an incubator API in Java 19 (JEP 428) and advanced to preview in Java 21 (JEP 453) and Java 23 (JEP 480). The core idea is that when a task splits into concurrent subtasks, they all return to the same lexical scope—the parent task waits until its child subtasks complete, preserving a clear parent-child hierarchy and eliminating common bugs around cancellation, thread leaks, and shutdown. Before diving into the API, the post reviews foundational concepts including processes, threads, synchronization, deadlocks, and semaphores.&lt;/p&gt;
&lt;p&gt;At the center of the API is &lt;code&gt;StructuredTaskScope&lt;/code&gt; in &lt;code&gt;java.util.concurrent&lt;/code&gt;: you open a scope in a &lt;code&gt;try-with-resources&lt;/code&gt; block, spawn subtasks with &lt;code&gt;fork&lt;/code&gt;, wait for completion with &lt;code&gt;join&lt;/code&gt;, and handle the results. Two built-in policies are provided as subclasses: &lt;code&gt;ShutdownOnSuccess&lt;/code&gt; (cancels remaining subtasks as soon as one succeeds, ideal when you only need the first result) and &lt;code&gt;ShutdownOnFailure&lt;/code&gt; (cancels all subtasks if any one fails); you can also subclass &lt;code&gt;StructuredTaskScope&lt;/code&gt; to define custom completion policies. For debugging, running &lt;code&gt;jcmd &amp;lt;PID&amp;gt; Thread.dump_to_file -format=json &amp;lt;file&amp;gt;&lt;/code&gt; exports a structured JSON thread dump showing the task hierarchy. The main benefits are simpler lifecycle management, consistent error handling, automatic resource cleanup, and no orphaned background threads.&lt;/p&gt;
&lt;h2 id="taking-out-the-trash-in-java"&gt;&lt;a href="https://medium.com/@benweidig/taking-out-the-trash-in-java-19bcc0c7bd0c" rel="noopener noreferrer"&gt;Taking Out the Trash in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Weidig provides an overview of garbage collection (GC) on the JVM: rather than requiring manual memory allocation and deallocation like C or C++, the JVM automatically tracks down unreachable objects and reclaims their memory—though that convenience isn&amp;rsquo;t free and directly impacts application performance. The article explains how the heap stores objects and is organized around the weak generational hypothesis into the Young Generation (Eden plus two Survivor spaces) and the Old Generation, alongside Metaspace (which replaced PermGen in Java 8), while each thread has its own stack for method call frames. Minor GCs are fast and barely noticeable, whereas major GCs can trigger significant &amp;ldquo;stop-the-world&amp;rdquo; pauses.&lt;/p&gt;
&lt;p&gt;Next, the author compares the available JVM collectors: Serial for single-threaded or resource-constrained environments, Parallel for maximum throughput, G1 (the default in modern JDKs) which divides the heap into regions, ZGC and Shenandoah for ultra-low pause times at the cost of higher CPU usage, and Epsilon—a no-op collector used primarily for benchmarking and allocation testing. The closing section offers practical guidance: cut down on unnecessary object allocations, pick appropriate data structures, use &lt;code&gt;try-with-resources&lt;/code&gt;, enable GC logging, and profile with tools like VisualVM or JDK Mission Control before tweaking heap sizes and JVM flags.&lt;/p&gt;
&lt;h2 id="how-precision-time-protocol-handles-leap-seconds"&gt;&lt;a href="https://engineering.fb.com/2025/02/03/production-engineering/how-precision-time-protocol-ptp-handles-leap-seconds/" rel="noopener noreferrer"&gt;How Precision Time Protocol handles leap seconds&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Meta explains how they handle leap seconds as Precision Time Protocol (PTP) increasingly replaces NTP for time synchronization across their data centers. With NTP, which synchronizes clocks at the millisecond level, Meta historically used &amp;ldquo;leap smearing&amp;rdquo;—gradually slowing down or speeding up the clock over a window using a linear or quadratic curve to absorb the extra second. However, PTP synchronizes clocks down to the nanosecond level, where even linear smearing introduces unacceptable drift between servers.&lt;/p&gt;
&lt;p&gt;Meta&amp;rsquo;s solution is to perform leap smearing inside their client-side &lt;code&gt;fbclock&lt;/code&gt; library: whenever called during a smearing window, the library shifts the returned timestamp using a stateless, reproducible algorithm, keeping the underlying time service on monotonic TAI internally while still exposing smeared UTC to client applications. Even so, this approach introduces noticeable divergence—drifting by more than 100 microseconds relative to quadratic-smeared NTP sources and shifting a 60-second periodic timer by nearly 1 millisecond during the smear window. Because of these trade-offs, Meta recommends using TAI instead of UTC wherever possible (even though conversion to UTC is still unavoidable at system boundaries) and backs the international proposal to retire leap seconds after 2035 so the industry can rely on continuous UTC and simplify timekeeping infrastructure.&lt;/p&gt;
&lt;h2 id="developer-philosophy"&gt;&lt;a href="https://qntm.org/devphilo" rel="noopener noreferrer"&gt;Developer philosophy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;qntm, a science fiction author and software engineer, writes down the software development philosophy he shared in a talk for junior developers. His number-one rule is to never let a project deteriorate to the point where a rewrite from scratch looks tempting—because by the time you reach that point, the real mistakes happened long ago; watch out for early warning signs like mounting technical debt, simple changes taking longer and longer, painful onboarding for new teammates, and mysterious bugs nobody understands. He also advises aiming to finish 90% of the work in 50% of the allotted time, since getting the happy path working is only half the battle—the rest goes to polish, edge cases, testing, and performance tuning.&lt;/p&gt;
&lt;p&gt;Other core principles include: automating good habits through tests, linters, and auto-formatters instead of relying on manual nagging; always thinking about &amp;ldquo;pathological data&amp;rdquo; like requests that hang forever, billion-row tables, or empty strings, because handling edge cases is the essence of the job; using leftover time to make code simpler; writing testable code with clean interfaces and minimal side effects; and finding the right balance between microservices and a monolith, splitting services only when there is a clear payoff. Finally, code shouldn&amp;rsquo;t just be theoretically correct—it should be &lt;em&gt;obviously&lt;/em&gt; correct, so that modifying surrounding code months later doesn&amp;rsquo;t turn into a minefield.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="bonus-1-interesting-videos-from-bytebytego"&gt;Bonus 1: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=QEzbZKtLi-g" rel="noopener noreferrer"&gt;System Design: Why Is Docker Important?&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus 2: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fc4c9cac-3046-4b45-9dd8-7dccc79b4e2c_1280x1608.gif" alt="JWT 101: Key to Stateless Authentication"&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 #2</title><link>https://miti99.com/en/post/2025/02/16/</link><pubDate>Sun, 16 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/16/</guid><description>&lt;i&gt;
Hello everyone, right on schedule, here is my Newsletter #2. I went on a weekend trip to Xuyên Mộc and just got back today, which is why this issue is going up a bit late.
&lt;p&gt;Without further ado, let&amp;rsquo;s jump straight into MiTi&amp;rsquo;s Newsletter #2.
&lt;/i&gt;&lt;/p&gt;
&lt;h2 id="some-things-to-expect-in-2025"&gt;&lt;a href="https://lwn.net/Articles/1003780/" rel="noopener noreferrer"&gt;Some things to expect in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In keeping with his New Year tradition, LWN.net&amp;rsquo;s Jonathan Corbet shares a set of predictions for the Linux and free software communities in 2025. Sched-ext—the mechanism for loading CPU schedulers from user space as BPF programs—will ship in more distributions, sparking a wave of new scheduling ideas tested rapidly on real production systems. More Rust code will land in the Linux kernel, this time in components that everyday users will actually run without realizing it. The author also expects another XZ-style backdoor attempt to come to light, and predicts that single-maintainer projects will increasingly be viewed as a risk, both for security and maintainer burnout.&lt;/p&gt;
&lt;p&gt;A major project may discover it has merged a substantial amount of AI-generated code that the contributor didn&amp;rsquo;t actually understand, forcing a revert; alongside that, efforts to build truly free generative AI systems will continue. Free software foundations will keep facing funding struggles, though a dedicated fund to support maintainers may emerge. More cloud-dependent consumer devices will turn into &amp;ldquo;bricks&amp;rdquo; when their manufacturers go under, creating opportunities for open solutions like Home Assistant; open hardware like the OpenWrt One will gain traction, and alternative mobile Linux distributions will see renewed interest. Finally, the author worries that global geopolitical tensions will spill over into the community and urges everyone to hold fast to the spirit of building systems for all and welcoming contributions from anyone.&lt;/p&gt;
&lt;h2 id="why-you-should-use-compact-table-columns"&gt;&lt;a href="https://vladmihalcea.com/compact-table-columns/" rel="noopener noreferrer"&gt;Why you should use compact table columns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vlad Mihalcea explains why choosing compact column types matters when designing database schemas. Relational database management systems cache disk pages in a Buffer Pool (such as PostgreSQL&amp;rsquo;s shared buffers); because RAM is orders of magnitude faster than SSDs, narrower columns pack more rows and index entries into each page, allowing more queries to be served directly from memory. StackOverflow is a prime example: they serve roughly 11,000 queries per second from a single active SQL Server node thanks to 1.5 TB of RAM fronting a 2.8 TB database and a Frugal Schema—avoiding 16-byte UUIDs for primary and foreign keys, using 4-byte &lt;code&gt;int&lt;/code&gt; or 1-byte &lt;code&gt;tinyint&lt;/code&gt; instead of &lt;code&gt;bigint&lt;/code&gt; for most primary keys, keeping enums to 1 byte, and bounding &lt;code&gt;VARCHAR&lt;/code&gt; column lengths.&lt;/p&gt;
&lt;p&gt;The author backs this up with concrete measurements. On MySQL, in a five-million-row &lt;code&gt;customer&lt;/code&gt; table, using &lt;code&gt;tinyint&lt;/code&gt; instead of &lt;code&gt;smallint&lt;/code&gt; for a single indexed foreign key saves about 71.59 MB; across ten such columns on a 100-million-row table, that adds up to roughly 14.3 GB. PostgreSQL lacks a 1-byte integer type and enforces column data alignment, so columns should be ordered using &amp;ldquo;Column Tetris&amp;rdquo; to avoid wasted padding bytes; even so, using &lt;code&gt;smallint&lt;/code&gt; instead of &lt;code&gt;int&lt;/code&gt; shrinks the &lt;code&gt;customer&lt;/code&gt; table by 38 MB. The takeaway: right-sizing column types is a proven performance optimization strategy that has served StackOverflow well for over 15 years.&lt;/p&gt;
&lt;h2 id="rate-limiting-with-redis-an-essential-guide"&gt;&lt;a href="https://foojay.io/today/rate-limiting-with-redis-an-essential-guide/" rel="noopener noreferrer"&gt;Rate limiting with Redis: An essential guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raphael De Lio opens with familiar encounters with rate limiting, such as &amp;ldquo;429 Too Many Requests&amp;rdquo; errors or tiered API quotas. Rate limiting prevents abuse, ensures fair access, smooths traffic spikes, controls costs, and protects service availability: Figma famously stopped a mass-invite spam attack using a Redis-backed rate limiter, while Stripe relies on rate limiting to keep misconfigured scripts or bad actors from monopolizing resources. Redis is a popular choice thanks to its speed, reliability, atomic operations, persistence options, and Lua scripting; GitHub also migrated to a Redis-based rate-limiting setup with client-side sharding.&lt;/p&gt;
&lt;p&gt;The article compares five common algorithms. Leaky Bucket processes requests at a steady rate, ideal for smooth traffic flows but unforgiving of bursts; Token Bucket allows short bursts as long as tokens remain; Fixed Window Counter is simple to implement but vulnerable to boundary spikes across adjacent time windows; Sliding Window Log is the most accurate but consumes significant memory and CPU at scale; and Sliding Window Counter balances accuracy with resource efficiency. Choosing the right algorithm depends on traffic patterns, required precision, resource constraints, and user experience. As the author notes, rate limiting isn&amp;rsquo;t just about setting caps—it&amp;rsquo;s about designing efficient, fair, and user-friendly systems; follow-up posts implementing each algorithm in Java and Redis will roll out weekly.&lt;/p&gt;
&lt;h2 id="why-does-cloudflare-pages-have-such-a-generous-free-tier"&gt;&lt;a href="https://mattsayar.com/why-does-cloudflare-pages-have-such-a-generous-free-tier/" rel="noopener noreferrer"&gt;Why does Cloudflare Pages have such a generous Free tier?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matt Sayar, who hosts his personal site on Cloudflare Pages, wonders why there are so many high-quality free hosting tiers available today. The biggest concern with free hosting is bandwidth, since a surprise viral post can stick you with a massive bill or knock your site offline. Comparing providers, GitHub Pages has a soft limit of 100 GB per month, Netlify and AWS S3 offer around 100 GB, GitLab Pages throttles by requests per minute, whereas Cloudflare Pages offers completely unlimited bandwidth.&lt;/p&gt;
&lt;p&gt;The author outlines three practical reasons behind this generosity. First, static sites are tiny—his own site is only about 2.2 MB—so with Cloudflare&amp;rsquo;s massive edge network, aggressive caching, and optimization techniques, the marginal cost of serving them is negligible. Second, Cloudflare benefits from a fast, secure internet: the more people and businesses come online, the more enterprises need commercial security products—which is exactly what Cloudflare sells, in the same spirit as its free 1.1.1.1 DNS resolver and unmetered DDoS protection. Third is the classic freemium flywheel: developers try the free tier, have a great experience, and later champion Cloudflare&amp;rsquo;s paid plans at work. Although the author initially couldn&amp;rsquo;t find an official statement explaining the bandwidth policy, the Hacker News community pointed him to a Cloudflare post affirming their commitment to the free tier; even so, he keeps a mirror on GitHub just in case policies change.&lt;/p&gt;
&lt;h2 id="how-i-program-with-llms"&gt;&lt;a href="https://crawshaw.io/blog/programming-with-llms" rel="noopener noreferrer"&gt;How I program with LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Crawshaw reflects on a year of actively programming with large language models (LLMs) and concludes that they deliver a clear productivity boost. He uses LLMs in three ways: code autocomplete, search engine replacement, and chat-driven programming—the hardest mode to master, but also the most valuable. Chat is especially helpful when you know what needs to be written but lack the energy to set up a new file and look up library APIs: the LLM produces a first draft with good structure, the right imports, and a few bugs, and fixing bugs is much easier than staring at a blank page. His advice is to frame prompts like exam questions: specific goals, self-contained context, and verifiable outputs—and always compile and run tests before reading the generated code closely.&lt;/p&gt;
&lt;p&gt;As a concrete example, he walks through writing a reservoir sampler in Go to estimate quartiles. The LLM generated a well-structured package with clean interfaces, though the initial code failed to compile due to an unused variable and included fabricated expected values in the unit test. When prompted, it wrote a naive reference implementation for comparison and a fuzz test that initially passed the wrong argument types, which it fixed as soon as the compiler error was pasted back; in the author&amp;rsquo;s experience, over 80% of tool-reported errors can be resolved by the LLM on its own. He argues that LLMs shift traditional software engineering trade-offs: favoring smaller packages, more thorough tests, and a looser adherence to DRY—such as generating a 200-line custom wrapper for the exact subset of an API you need rather than pulling in a bloated official SDK. He is currently automating these workflows at sketch.dev.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;p&gt;This week comes with quite a few bonuses from various sources.&lt;/p&gt;
&lt;h3 id="bonus-1-a-couple-of-ebooks-i-found"&gt;Bonus #1: A couple of ebooks I found&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href="https://info.microsoft.com/rs/157-GQE-382/images/EN-CNTNT-eBook-DesigningDistributedSystems.pdf" rel="noopener noreferrer"&gt;Designing Distributed Systems&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://drive.google.com/file/d/1U7EchvgzCjTtF5JzGVVCFgjXC-qw7lIG/view" rel="noopener noreferrer"&gt;Quastor Summaries&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus #2: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/11b53f30-8dba-4520-9b1a-425b54b9b84a_1280x1585.gif" alt="Cookies Vs Sessions Vs JWT Vs PASETO"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fdbcc119-8f5d-4d27-9a4b-2c8bde82b537_4026x8030.jpeg" alt="Algorithms you should know before taking System Design Interviews"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/12dffcce-f231-48cc-915f-d53c0f8bce0c_3735x3573.jpeg" alt="Top 6 Load Balancing Algorithms"&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></channel></rss>