<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Rate Limiting on miti99</title><link>https://miti99.com/en/tags/rate-limiting/</link><description>Recent content in Rate Limiting 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/rate-limiting/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #89</title><link>https://miti99.com/en/post/2026/03/14/</link><pubDate>Sat, 14 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #89.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="hybrid-quota-linear-rate-limiter"&gt;&lt;a href="https://dotat.at/@/2026-01-12-hqlr.html" rel="noopener noreferrer"&gt;Hybrid Quota-Linear Rate Limiter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tony Finch points out an underappreciated quirk of linear rate limiters like the leaky bucket or GCRA: they are slow to clamp down on clients that exceed the limit only modestly. Given a quota of &lt;code&gt;q&lt;/code&gt; requests per time window &lt;code&gt;w&lt;/code&gt;, a client sending requests at &lt;code&gt;a&lt;/code&gt; times the allowed rate can still get roughly &lt;code&gt;q*a/(a-1)&lt;/code&gt; requests through before being blocked—double the quota when &lt;code&gt;a=2&lt;/code&gt;. The reason is that the bucket starts full of tokens and continuously refills another quota&amp;rsquo;s worth over the first window. Fixed-window quota-reset limiters enforce a stricter cap, but they use more memory and encourage clients to dump traffic in bursts at window boundaries.&lt;/p&gt;
&lt;p&gt;The author proposes a hybrid algorithm with two modes: a bursty mode for low-volume clients, which allows bursts but refills at most one quota per window; and a smooth mode for heavy clients, which starts with an empty bucket (plus a negative penalty) and forces requests to be paced evenly. The limiter switches to smooth mode when a client drains its last token, and returns to bursty mode once the bucket recovers a full quota. The behavior matches running a quota-reset limiter and a linear limiter side by side, while using less memory. Even so, the author advises against actually using it: a linear rate limiter only looks &amp;ldquo;too generous&amp;rdquo; if you ignore the fact that the client was idle during the previous window. It is better to reframe the requirement and stick with a simple linear limiter like GCRA, which naturally rewards steady traffic.&lt;/p&gt;
&lt;h2 id="go-is-the-best-language-for-ai-agents"&gt;&lt;a href="https://getbruin.com/blog/go-is-the-best-language-for-agents/" rel="noopener noreferrer"&gt;Go is the Best Language for AI Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Burak Karakan, who has worked professionally with Go for eight years and is building Bruin—an open-source ETL tool written in Go—argues that Go is the best language for coding with AI agents. First, Go is compiled: agents generate lots of plausible-looking code, and a fast compiler with static types lets the agent iterate in a tight loop until entire classes of type and argument errors are eliminated. Compared with Rust, Go has simpler syntax and concepts, compiles faster for a tighter feedback loop, and has a larger corpus of existing code. That simplicity also makes it easy for humans to review diffs and spot when an agent is heading down a strange design path.&lt;/p&gt;
&lt;p&gt;Go is also strongly opinionated: there is one standard way to run tests, format code, and build binaries, so an agent can just invoke &lt;code&gt;gofmt&lt;/code&gt; instead of wrestling with the toolchain sprawl common in JavaScript. Easy cross-compilation lets agents verify builds across operating systems after every change (even if running the tests still requires the target environment or an emulator)—a major advantage when running background agents inside sandboxes whose environment you don&amp;rsquo;t fully control. In the author&amp;rsquo;s experience, agents write working Go on the first try roughly 95% of the time—not because there is more training data than for Python, but because Go usually has one obvious way to do things. He acknowledges this is anecdotal and may matter less as models improve.&lt;/p&gt;
&lt;h2 id="your-agent-needs-a-harness-not-a-framework"&gt;&lt;a href="https://x.com/djfarrelly/status/2028556984396452250" rel="noopener noreferrer"&gt;Your Agent Needs a Harness, Not a Framework&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Farrelly from Inngest argues that AI agents need a &amp;ldquo;harness,&amp;rdquo; not a framework. Across engineering disciplines, a harness connects, protects, and coordinates components without doing their job for them—like a wiring harness linking an engine to sensors, or a climbing harness catching you when you fall. For an agent, the LLM is the engine, tools are peripherals, and memory is storage; what you need around them is something that handles an LLM timing out on loop iteration five or two user messages colliding. Agent frameworks keep reinventing retries, state persistence, queues, and event routing from scratch, when durable event-driven infrastructure already solves those problems: every LLM or tool call becomes an independently retryable &amp;ldquo;step,&amp;rdquo; so if a process crashes on iteration five, the first four iterations are already checkpointed.&lt;/p&gt;
&lt;p&gt;To prove the point, the team built Utah (Universally Triggered Agent Harness)—a conversational agent over Telegram or Slack with tools, memory, sub-agent delegation via &lt;code&gt;step.invoke()&lt;/code&gt;, and fault tolerance, written in compact TypeScript with no agent framework, just Inngest functions, steps, and events wrapped around a think → act → observe loop. Their biggest lesson: context management is the real challenge, because bloated tool outputs disorient the model and send it into endless tool-calling loops. They solved this with two-tier pruning of old tool outputs, session history compaction, warnings as the step budget runs low, and automatic re-compaction on context-window overflow errors.&lt;/p&gt;
&lt;h2 id="an-interactive-intro-to-quadtrees"&gt;&lt;a href="https://growingswe.com/blog/quadtrees" rel="noopener noreferrer"&gt;An Interactive Intro to Quadtrees&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide explains quadtrees—a spatial data structure for fast two-dimensional queries, inspired by seeing Uber use spatial indexing in system design write-ups. In a mapping app with millions of places, the naive approach to finding nearby points is computing the distance from the user to every single location, costing millions of operations per query. A quadtree reorganizes space itself: it splits a rectangular region into four quadrants, and whenever a quadrant exceeds its point capacity, it subdivides again. Dense areas get finely divided while sparse areas stay coarse, so looking up a point simply walks down the tree, eliminating three-quarters of the remaining space at each level—roughly 10 steps for a million points.&lt;/p&gt;
&lt;p&gt;The capacity parameter shapes the tree: a low capacity builds a deeper tree that prunes more aggressively but uses more memory; a high capacity builds a shallower tree where leaf nodes scan more points linearly, with 4 to 16 being a good starting range. Range queries only descend into nodes whose bounding boxes intersect the search region, pruning entire subtrees at once; nearest-neighbor search tracks the best distance found so far to prune increasingly aggressively. Beyond geospatial search, quadtrees power broad-phase collision detection in games—avoiding pairwise checks between distant objects—and region-based image compression, where uniform areas are stored as large blocks and detailed regions are subdivided.&lt;/p&gt;
&lt;h2 id="agentic-engineering-patterns"&gt;&lt;a href="https://simonwillison.net/guides/agentic-engineering-patterns/" rel="noopener noreferrer"&gt;Agentic Engineering Patterns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison has launched a guide to patterns for getting the most out of coding agents like Claude Code and OpenAI Codex. He draws a sharp line between &amp;ldquo;agentic engineering&amp;rdquo; and &amp;ldquo;vibe coding&amp;rdquo;: vibe coding means letting an LLM write code without paying attention to the code itself, whereas agentic engineering is professional engineers using agents to amplify their existing expertise rather than replace it. The guide is organized into sections covering core principles, working with coding agents (how they work, using Git, sub-agents), testing and quality assurance, understanding codebases through linear walkthroughs and interactive explanations, annotated prompts, and an appendix of prompts he uses regularly.&lt;/p&gt;
&lt;p&gt;A few standout patterns: &amp;ldquo;Writing code is cheap now&amp;rdquo;—the cost of generating code has dropped to near zero, but &lt;em&gt;good&lt;/em&gt; code with tests, documentation, and proper error handling still takes discipline, requiring new habits; &amp;ldquo;Hoard things you know how to do&amp;rdquo;—maintain a collection of working examples you can recombine and feed to agents as reference input; and &amp;ldquo;Red/green TDD&amp;rdquo;—have the agent write a failing test first and verify it fails before implementing the fix, along with running the test suite right at the start of every session. The guide also calls out anti-patterns to avoid—most notably filing unreviewed agent-generated pull requests for teammates to review—and continues to grow with new chapters.&lt;/p&gt;
&lt;h2 id="things-i-miss-about-spring-boot-after-switching-to-go"&gt;&lt;del&gt;&lt;a href="https://sushantdhiman.dev/things-i-miss-about-spring-boot-after-switching-to-go/" rel="noopener noreferrer"&gt;Things I Miss About Spring Boot After Switching to Go&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;After spending a year and a half building production Java and Spring Boot systems at a startup and then switching to Go, Sushant Dhiman reflects on what he misses from the Spring ecosystem. First is the &amp;ldquo;batteries included&amp;rdquo; philosophy: Spring Boot ships with nearly everything needed for production out of the box, whereas Go favors minimalism and a collection of small libraries over a monolithic framework. Specifically, he misses declarative dependency injection via annotations like &lt;code&gt;@Service&lt;/code&gt; and &lt;code&gt;@Autowired&lt;/code&gt;; in Go you wire dependencies manually through constructors—explicit, but startup code balloons once a service has hundreds of dependencies. Similarly, declarative validation with &lt;code&gt;@NotNull&lt;/code&gt; or &lt;code&gt;@Email&lt;/code&gt; avoids chains of manual &lt;code&gt;if/else&lt;/code&gt; checks and regexes.&lt;/p&gt;
&lt;p&gt;Spring&amp;rsquo;s mature ecosystem is another big loss: Spring Security handles JWT, OAuth, and form logins out of the box; Spring Data derives queries directly from method names like &lt;code&gt;findByEmail&lt;/code&gt;; Spring Boot Actuator exposes health checks and metrics with a few lines of configuration; and Spring Cloud provides a full toolkit for microservices. Still, the author is fair to Go: it gives you complete control and transparency over SQL queries, which is much easier to debug than complex multi-table ORM joins. Go also wins on operational simplicity—compiling to a single static binary with no JVM or garbage-collector tuning, near-instant startup, and first-class concurrency built right into the language.&lt;/p&gt;
&lt;h2 id="design-first-collaboration-with-ai"&gt;&lt;a href="https://martinfowler.com/articles/reduce-friction-ai/design-first-collaboration.html" rel="noopener noreferrer"&gt;Design-First Collaboration with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing on martinfowler.com, Rahul Garg diagnoses the &amp;ldquo;Implementation Trap&amp;rdquo; when working with AI coding assistants: AI generates code so fast that the natural pause between design thinking and coding disappears. The AI still makes design decisions about scope, component boundaries, data flow, and error handling, but buries them quietly inside the implementation. Reviewers have to evaluate too many concerns at once and easily miss flaws, even though fixing a misunderstanding at the design stage is far cheaper than after code is written. Worse, AI assistants routinely slip in unrequested features—what the author calls &amp;ldquo;technical debt injection.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;His solution is to recreate the whiteboard design session across five progressive levels of abstraction: Capabilities (core requirements), Components (building blocks), Interactions (data flow and communication), Contracts (function signatures, types, interfaces), and finally Implementation. The golden rule is no production code until Level 5 is approved. In a notification-service example, reviewing at the Components level let the author scrap an unnecessary &lt;code&gt;RetryQueue&lt;/code&gt; class because BullMQ already handles retries; and once Contracts are agreed upon, the AI can write tests before writing the implementation. Not every task needs all five levels: a simple utility can start at Level 4, while a multi-component feature starts at Level 1. The process takes more upfront time and isn&amp;rsquo;t worth it for throwaway tasks, but pays off handsomely for complex, long-lived features.&lt;/p&gt;
&lt;h2 id="the-two-kinds-of-error"&gt;&lt;a href="https://evanhahn.com/the-two-kinds-of-error/" rel="noopener noreferrer"&gt;The Two Kinds of Error&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Evan Hahn divides software errors into two categories. &lt;em&gt;Expected&lt;/em&gt; errors happen during normal operation and aren&amp;rsquo;t bugs in the program: invalid user input, flaky networks, missing file permissions. These are recoverable—you shouldn&amp;rsquo;t &lt;code&gt;throw&lt;/code&gt;, &lt;code&gt;raise&lt;/code&gt;, or &lt;code&gt;panic&lt;/code&gt;, but instead return an explicit error value (like a &lt;code&gt;Result&lt;/code&gt; type) that forces the caller to handle it, logging at &lt;code&gt;WARN&lt;/code&gt; or &lt;code&gt;INFO&lt;/code&gt; at most. &lt;em&gt;Unexpected&lt;/em&gt; errors should never happen—failed assertions, logic bugs, corrupt data from a database you control—and indicate a bug in the code. Rather than limping along, the program should crash immediately and log at &lt;code&gt;ERROR&lt;/code&gt; or &lt;code&gt;FATAL&lt;/code&gt;; crashing is annoying in the moment, the author argues, but makes software far more reliable over time.&lt;/p&gt;
&lt;p&gt;Where the boundary falls depends on context: in a quick prototype or one-off script, almost every error can be treated as unexpected; in flight software for a 50-year deep-space probe, almost every error—including hardware faults—must be treated as expected. Making software more reliable generally means moving more errors from the unexpected column into the expected one. He also notes that languages like Rust and Zig nudge developers to treat many errors as expected, whereas JavaScript and Python do the opposite, and he prefers stricter compiler enforcement for production systems.&lt;/p&gt;
&lt;h2 id="secure-go-error-handling-best-practices"&gt;&lt;a href="https://blog.jetbrains.com/go/2026/03/02/secure-go-error-handling-best-practices/" rel="noopener noreferrer"&gt;Secure Go Error Handling Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on the JetBrains GoLand blog focuses on the security side of error handling in Go. Because Go errors are plain values rather than exceptions, letting them bubble up and return directly to clients can easily leak file paths, SQL queries, credentials, or stack traces. The first rule is a strict separation between what the system sees and what the user sees: define a custom error type carrying both an internal cause and a public message, where &lt;code&gt;Error()&lt;/code&gt; returns only the safe message while technical details go exclusively to internal logs. Next, instead of logging entire request structs that might contain passwords, use a builder or helper that whitelists safe metadata fields; and when you don&amp;rsquo;t want callers inspecting the underlying cause via &lt;code&gt;errors.Is&lt;/code&gt; or &lt;code&gt;errors.As&lt;/code&gt;, wrap errors opaquely rather than using &lt;code&gt;fmt.Errorf&lt;/code&gt; with &lt;code&gt;%w&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;As errors cross architectural boundaries, control them at three levels: between internal layers, translate raw database errors into domain errors; between microservices, map them to standard status codes like gRPC codes or a uniform JSON error schema; and at the user-facing edge, return only predefined static strings or error codes paired with a request ID—never dynamically concatenated error text. For logging, use structured loggers like &lt;code&gt;log/slog&lt;/code&gt;, zap, or zerolog, project only the fields needed for debugging, and implement a &lt;code&gt;Redactor&lt;/code&gt; interface to mask sensitive fields whenever a full request payload must be logged.&lt;/p&gt;
&lt;h2 id="ai-coding-tools-java--compounding-engineering"&gt;&lt;a href="https://www.the-main-thread.com/p/ai-coding-tools-java-compounding-engineering" rel="noopener noreferrer"&gt;AI Coding Tools, Java &amp;amp; Compounding Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Markus Eisele distills Aleksander Stensby&amp;rsquo;s talk from NDC Manchester 2025 around a central thesis: if AI is generating bad code for you, it&amp;rsquo;s usually a workflow problem, not a model problem. Stensby calls the fix &lt;em&gt;Compounding Engineering&lt;/em&gt;—investing in your tools over time the way you mentor a junior developer. Context is both precious and scarce: too little and the model hallucinates, too much and it loses focus, so clear the chat frequently and persist architectural decisions, constraints, and rejected alternatives in markdown files so you can reload only what matters. Rule files like &lt;code&gt;CLAUDE.md&lt;/code&gt; serve as a living knowledge base: every time you fix a subtle bug, update the rules so the agent never makes that mistake again.&lt;/p&gt;
&lt;p&gt;Other habits include always planning before coding to catch bad ideas early, breaking work into small single-responsibility tasks, picking models deliberately (fast models for routine edits, deep reasoning models for architecture), automating repetitive flows with slash commands and sub-agents, using MCP so the AI can inspect real systems, and keeping a Git safety net of frequent checkpoints. Background agents still require thorough human review before merging. An engineer&amp;rsquo;s enduring value lies in taste and judgment—spotting that something is wrong even when all the tests pass—which AI still lacks. Invest in your workflow and the gains compound; skip that investment and you just get &amp;ldquo;faster mediocrity.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="yaml-that"&gt;&lt;a href="https://lab174.com/blog/202601-yaml-norway/" rel="noopener noreferrer"&gt;YAML? That&amp;rsquo;s Norway Problem&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This piece digs into YAML&amp;rsquo;s infamous &amp;ldquo;Norway problem&amp;rdquo;: the two-letter country code &lt;code&gt;NO&lt;/code&gt; getting parsed by popular libraries like PyYAML as the boolean &lt;code&gt;false&lt;/code&gt; instead of a string. The root cause is implicit typing for unquoted scalars: the final draft of YAML 1.0 (2004) and YAML 1.1 (2005) treated words like &lt;code&gt;yes/no&lt;/code&gt; and &lt;code&gt;on/off&lt;/code&gt; as booleans. YAML 1.2 (2009) dropped that behavior, yet PyYAML and LibYAML—the two &amp;ldquo;official&amp;rdquo; libraries, with open issues requesting v1.2 support dating back to 2016–2017—still implement v1.1. Because LibYAML sits deep inside the dependency tree of countless tools, changing it is slow and risky.&lt;/p&gt;
&lt;p&gt;Most articles stop at &amp;ldquo;just quote &lt;code&gt;&amp;quot;NO&amp;quot;&lt;/code&gt;,&amp;rdquo; but the author shows the ecosystem reality is messier. In Go, the most downloaded library (&lt;code&gt;gopkg.in/yaml.v3&lt;/code&gt;) is unmaintained and mixes v1.1 and v1.2 behaviors, whereas the most popular actively maintained library defaults to v1.2; the &lt;code&gt;yq&lt;/code&gt; CLI also defaults to v1.2, and in 2025 Kubernetes introduced KYAML, a safer, less ambiguous subset of YAML. Online documentation routinely confuses spec versions while users argue over whether the bug is &amp;ldquo;already fixed.&amp;rdquo; The takeaway: the YAML ecosystem is fragmented but gradually migrating toward stricter specs; new projects will likely pick newer v1.2-compliant libraries free of the Norway problem, while older, more widely deployed libraries remain stuck on v1.1.&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 #87</title><link>https://miti99.com/en/post/2026/03/02/</link><pubDate>Mon, 02 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #87.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="on-cognitive-debt"&gt;&lt;a href="https://www.natemeyvis.com/on-cognitive-debt/" rel="noopener noreferrer"&gt;On cognitive debt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;There has been plenty of talk lately about &amp;ldquo;cognitive debt&amp;rdquo;: when AI-generated code grows so fast that nobody understands how it works anymore, making it hard to extend, observe, and debug. Nate Meyvis agrees the phenomenon is real, but argues the panic is overblown. Compared at the same project size, cognitive debt in pre-AI codebases was often even worse; AI simply lets us move several times faster, so we hit that complexity wall much sooner. We miss this because much of what we treat as &amp;ldquo;normal engineering&amp;rdquo;—like a handful of senior engineers carrying all the implicit constraints in their heads—is actually the tax of cognitive debt. When a local change breaks a distant part of the system and tests don&amp;rsquo;t catch it, that usually means encapsulation had already failed.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, skilled AI users already know how to keep cognitive debt in check and will keep getting better at it. He shares several practices: emphasizing encapsulation in project-level AI instructions, clearly documenting subsystems, their interfaces, and data structures, leaning into large-scale refactoring with AI (which is much less painful now), and adding tests wherever cognitive debt starts to show. The takeaway: cognitive debt is real, but we fix it by using AI better rather than blaming AI for our own engineering habits.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://davidoks.blog/p/why-im-not-worried-about-ai-job-loss" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m not worried about AI job loss&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Oks responds to Matt Shumer&amp;rsquo;s viral essay &amp;ldquo;Something Big Is Happening,&amp;rdquo; which compared the present moment to February 2020 right before COVID hit and warned of mass unemployment. Oks believes AI will be as consequential as electricity or the steam engine, but argues its real-world impact on jobs will be much slower and more uneven. First, labor substitution is governed by comparative advantage, not absolute advantage: even if AI outperforms humans at every task, pairing humans with AI remains worthwhile whenever combined output is higher—which is visibly true in software engineering today. Second, the world is full of human-made bottlenecks: regulation, corporate culture, politics, habit, and above all resistance to change. That is why, even with capable models available for years, outsourced customer support still hasn&amp;rsquo;t been replaced wholesale.&lt;/p&gt;
&lt;p&gt;Third, demand for many goods and services is more elastic than we assume, so efficiency gains are often absorbed by rising demand, just as Jevons paradox predicts; every past leap in programming productivity ended up increasing demand for software engineers. Over the long run, humans will keep inventing new kinds of work that blur the line between labor and leisure. The author concludes that ordinary workers will be fine; the real danger is a populist backlash fueled by doomerism, which could lead to bans on data center construction and choke off the benefits AI can bring.&lt;/p&gt;
&lt;h2 id="why-i-don"&gt;&lt;a href="https://honnibal.dev/blog/ai-bubble" rel="noopener noreferrer"&gt;Why I don&amp;rsquo;t think AI is a bubble&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthew Honnibal, creator of the spaCy NLP library, sets aside the financial side of the &amp;ldquo;AI bubble&amp;rdquo; debate to answer the technical question: is AI progress about to plateau? The common argument is that recent gains came from brute-force scaling, returns are diminishing, and we are about to hit a wall. He admits he thought the same back in the GPT-1 and GPT-2 days, but underestimated reinforcement learning (RL). Reasoning models like Claude Opus or GPT-5 combine generative pre-training on massive text corpora with AlphaZero-style RL: the model generates intermediate steps, and chains of steps that lead to verifiable correct answers get reinforced. &amp;ldquo;Logic is work&amp;rdquo;: even in a purely symbolic system, deduction requires computation, so generating intermediate steps is essential rather than a parlor trick.&lt;/p&gt;
&lt;p&gt;The scaling-wall argument only applies to next-token pre-training. Reasoning opens up two new levers: letting models run longer at inference time to think through harder problems, and scaling up reinforcement learning; combined with the ability to backtrack from dead ends, models can search the solution space much like exploring moves in chess. Nor does RL face an obvious data wall, because verifying a successful chain of reasoning is far easier than generating one from scratch. While he doesn&amp;rsquo;t trust OpenAI as a company, he sees no technical reason to think progress is about to stop, and expects the new data centers to be put to productive use.&lt;/p&gt;
&lt;h2 id="i-guess-i-kinda-get-why-people-hate-ai"&gt;&lt;a href="https://anthony.noided.media/blog/ai/programming/2026/02/14/i-guess-i-kinda-get-why-people-hate-ai.html" rel="noopener noreferrer"&gt;I guess I kinda get why people hate AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing from a hotel balcony in Hawaii nine days before starting a new job, the author wonders whether this will be the last job he ever has. Once, that question meant wondering whether he&amp;rsquo;d ever &lt;em&gt;need&lt;/em&gt; to work again; now it means wondering whether AI will make him unemployable. He doesn&amp;rsquo;t hate AI, but he understands why so many people do. The most obvious reason: AI industry leaders actively market their products by boasting that they will wipe out jobs—something unprecedented in the history of technology. If they genuinely believed that, he argues, they would be lobbying right now for trigger laws, such as automatic tax hikes to fund retraining or universal basic income if unemployment rises while GDP grows. That nobody is proposing this suggests they either don&amp;rsquo;t believe their own hype or don&amp;rsquo;t care about the fallout.&lt;/p&gt;
&lt;p&gt;Meanwhile, everyday encounters with AI for ordinary people are mostly negative: students pasting homework into ChatGPT, deepfake Elon Musk videos fooling his dad, AI slop flooding TikTok, cURL shutting down its bug bounty program under a wave of fabricated vulnerability reports, and RAM prices spiking. AI &lt;em&gt;sometimes&lt;/em&gt; helps people do high-quality work, but it &lt;em&gt;always&lt;/em&gt; makes generating slop nearly free. He proposes concrete mitigations: watermarking AI-generated content, stricter YouTube enforcement against AI misinformation, and letting major open-source projects opt out of automated AI vulnerability scanning. What worries him most is that the AI labs barely seem to be trying.&lt;/p&gt;
&lt;h2 id="uber"&gt;&lt;a href="https://www.uber.com/en-IN/blog/ubers-rate-limiting-system/" rel="noopener noreferrer"&gt;Uber&amp;rsquo;s Rate Limiting System&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber handles hundreds of millions of RPCs per second across thousands of microservices. Historically, teams built their own rate limiters—typically backed by Redis counters—leading to inconsistent configuration, added latency, and operational toil. Because centralized counters cannot scale to hundreds of thousands of instances across regions, Uber built GRL (Global Rate Limiter) directly into its service mesh, allowing rate limits per caller or procedure without code changes. GRL has three tiers: in-mesh clients make local per-request decisions, zone-level aggregators roll up usage metrics, and a regional controller computes global utilization and pushes drop directives back down. An initial token-bucket design distributed quota unfairly across callers, so the team switched to probabilistic dropping: when aggregate load exceeds the limit, every client drops a fraction of requests equal to &lt;code&gt;(actual − limit) / actual&lt;/code&gt;, updated every second. The trade-off is a 2–3 second reaction delay.&lt;/p&gt;
&lt;p&gt;Eliminating Redis cut median latency by ~1ms, P90 by tens of milliseconds, and improved P99.5 by up to 90%; the system has absorbed 15x traffic spikes and mitigated DDoS incidents. GRL now processes roughly 80 million requests per second across more than 1,100 services. To keep limits from going stale, Uber also built RLC (Rate Limit Configurator), which periodically analyzes recent weeks of traffic, computes safe limits from historical peaks plus headroom, and automatically rolls out updated configurations with a dry-run shadow mode before enforcement.&lt;/p&gt;
&lt;h2 id="agents-feb-2026"&gt;&lt;a href="https://calv.info/agents-feb-2026" rel="noopener noreferrer"&gt;Agents (Feb 2026)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Calvin French-Owen, who helped launch Codex Web at OpenAI, shares how he uses coding agents as of February 2026. His own time is now the scarce resource: he picks tools based on how much time he has and how much autonomy he wants to grant. The core mental model is understanding context: an agent is just predicting the next token, and everything must fit inside the context window. From that follow several rules: break work into small chunks, remember that context compaction always loses information, persist state to the filesystem (such as numbered plan files with checkboxes), and stay inside the &amp;ldquo;smart half&amp;rdquo; of the context window. Opus in Claude Code works across multiple context windows remarkably well, eagerly spawns parallel sub-agents, uses tools effectively, and explains itself clearly. Codex (GPT-5.3) writes noticeably less buggy code, but runs slower because it doesn&amp;rsquo;t yet fan work out across multiple context windows. So he plans with Claude Code and implements with Codex.&lt;/p&gt;
&lt;p&gt;His setup uses a &lt;code&gt;plans/&lt;/code&gt; directory of numbered plans, parallel git worktrees, preview deployments per branch, a plan–implement–review loop, and automated review bots to catch bugs. Skills chain and automate recurring workflows with minimal token overhead; he only creates a skill after repeating a task several times, gradually building up &lt;code&gt;/commit&lt;/code&gt;, &lt;code&gt;/worktree&lt;/code&gt;, &lt;code&gt;/implement&lt;/code&gt;, &lt;code&gt;/address-bugs&lt;/code&gt;, and &lt;code&gt;/pr-pass&lt;/code&gt;. The main barriers to continuously running agents are context management and prompt-injection defense; increasingly, ideas, architecture, and project sequencing are the real bottlenecks.&lt;/p&gt;
&lt;h2 id="the-software-industrial-revolution"&gt;&lt;a href="https://cannoneyed.com/essays/software-industrial-revolution" rel="noopener noreferrer"&gt;The Software Industrial Revolution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to the author, late 2025 was the moment AI coding agents truly clicked, kicking off the &amp;ldquo;Software Industrial Revolution.&amp;rdquo; Just as the Spinning Jenny in 1764 turned single-threaded hand spinning into a parallel process and drove cotton cloth prices down by more than 90% over half a century, AI is automating software production—until now an extraordinarily labor-intensive craft. Software has eaten the world: the tech sector accounts for roughly 35% of the S&amp;amp;P 500, and nearly 50% when communication services are included. Yet because building software was so expensive, business models were pushed toward VC-fueled growth-at-all-costs to capture a market and then extract monopoly rents, leading to the &amp;ldquo;enshittification&amp;rdquo; Cory Doctorow describes. A textbook example is Epic, which holds 42% of the US acute-care hospital market with margins above 30%, where the sheer cost of building complex enterprise software chokes off competition.&lt;/p&gt;
&lt;p&gt;When software becomes orders of magnitude cheaper to produce, we will get vastly more of it, demand for engineers may actually rise, the old VC playbook will fade, and more sustainable business models will emerge. Anyone—from a cancer researcher to a small-business owner—will be able to have AI build the exact tools they need, sparking an explosion of bespoke software across every industry. While hand-typing code is losing its premium, core engineering skills like domain modeling, managing complexity, and understanding how software interacts with the real world will matter more than ever.&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 #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>