Since my personal finances haven’t been great lately, I decided to cancel my Claude subscription and am no longer using Claude Code. Right now I’m using Roo Code with the Z.AI: GLM 4.5 Air model via OpenRouter. Hopefully the post is still high enough quality for you all. Enjoy Newsletter #54.

Controlling the Rollout of Large-Scale Monorepo Changes

At Uber, source code is organized into a few massive monorepos—one per major programming language—and most microservices deploy to production automatically via continuous deployment. This raises a thorny question: when a single commit can touch thousands of services—say, upgrading an RPC library used by nearly every Go service—how do you contain the blast radius if that change introduces a bug? An analysis of 500,000 commits in Uber’s Go monorepo showed that 1.4% of commits affected more than 100 services and 0.3% affected more than 1,000 services, meaning several changes every week touch a huge slice of production. Even when individual services detect failures and roll back automatically, a bug can still slip into production on services whose checks didn’t catch it.

Uber’s solution is cross-service rollout orchestration. The team added a new rollout gate to the commit promotion pipeline: an asynchronous worker maintains a state machine for each large-scale commit, grouping affected services by criticality from tier 5 down to tier 0, and unlocking a more critical tier only after a required percentage of services in the preceding tier have deployed successfully. If the failure rate exceeds a threshold, the commit is flagged as unhealthy, the author is notified immediately, and further rollouts are blocked until a fix lands. Because the initial parameters were too conservative—blocking tier 1 services for up to 40 hours—the team built a simulator backed by historical deployment data to tune the thresholds, hitting their target of unlocking all tiers within 24 hours, with real-world results matching the simulation. The same mechanism is now also used to progressively roll out hundreds of machine learning model-serving services that differ only by configuration.

String Length

Henri Sivonen pushes back against the popular meme mocking JavaScript because "🤦🏼‍♂️".length evaluates to 7. That emoji actually consists of five Unicode scalar values (a base character, a skin-tone modifier, a zero-width joiner, the male sign, and a variation selector), meaning the exact same string has at least four valid “lengths”: 17 UTF-8 code units (Rust), 7 UTF-16 code units (JavaScript, Java), 5 scalar values (Python 3), and 1 extended grapheme cluster (Swift). The first three numbers are fixed for any valid string and can be computed without lookup tables, whereas the grapheme cluster count depends on which version of the Unicode database the runtime bundles—so two programs can legitimately count different lengths for the same string.

The author argues that reporting length in the string’s native storage code units makes complete sense, because that is the exact number needed for memory allocation and fast string concatenation, whereas higher-level counts should only be computed on demand. In his view, UTF-8 is the best internal representation, O(1) random access by scalar value is rarely needed in practice, Swift’s approach isn’t necessarily right for every language, and Python 3’s representation gives the worst trade-off. The closing section examines why applications measure string length in the first place: estimating display width (where terminals rely on East Asian Width, giving CJK characters two cells) and enforcing fair character limits across languages, illustrated through length statistics from translations of the Universal Declaration of Human Rights and Twitter’s rule counting each CJK character or emoji as two units.

An Illustrated Guide to OAuth

Aditya Bhargava explains OAuth with clear illustrations, starting from its origin story: in 2007, Twitter needed a way for third-party apps to post tweets on a user’s behalf without the user handing over their password. The core building block of OAuth is the access token, which acts like a user-specific, scoped API key. Using the example of the budgeting app YNAB connecting to Chase Bank, the article walks through the two-step flow: the user logs in at Chase and approves the requested permissions (scopes), after which Chase redirects back to YNAB with a short-lived authorization code rather than the access token itself, since URLs can leak via browser history or server logs. YNAB’s backend then exchanges that code for an access token over an authenticated HTTPS POST request that includes its client_secret.

The guide introduces the standard terminology (resource owner, OAuth client, authorization server, resource server, scope) alongside the developer’s perspective: registering the app to obtain a client ID and client secret, and whitelisting a redirect_uri so the authorization server refuses to redirect users to malicious domains. The author contrasts the front-channel (passing through the user’s browser via URL parameters visible to anyone along the path) with the back-channel (direct server-to-server calls via POST bodies), and explains why single-page and mobile apps—which cannot keep a client_secret confidential—use PKCE instead, a mechanism now recommended even for backend web apps. The post wraps up with a quick tour of the legacy implicit flow, refresh tokens, and OpenID Connect, the identity layer built on top of OAuth that powers “Sign in with Google.” As the author sums up, OAuth feels complex because every step was added to close a specific attack vector.

Professional Development Is a Choice

Alex Chesser, a developer with over 20 years of experience, argues that intentional professional development is very different from the passive growth that happens through day-to-day work: it requires a conscious choice. Looking back on his own career—maintaining Perl scripts at Nortel, getting laid off in the dot-com crash, spending five years teaching, and eventually returning to software engineering—he admits that for most of his career he learned reactively, picking up only what was needed for the task right in front of him. He also points out why top-down corporate career-development frameworks usually fail: the power imbalance between managers and direct reports makes it risky for employees to be completely honest about what they actually want.

He proposes a four-step personal framework. First, put a recurring one-hour “career retrospective” on your calendar every week. Second, work through structured reflection questions—what you’re good at, what you enjoy, what the market pays you for, where you need to improve, and where you want to be in 1–3, 3–5, and 5–10 years—and turn the answers into SMART goals, making sure to include health, family, and non-work passions so you don’t burn out. Third, protect focused execution blocks using deep work or Pomodoro techniques, and fourth, revisit the loop weekly to adjust your targets. The author stresses that choosing not to invest extra time in career growth is also a completely valid choice—as long as you make it consciously.

Replacing a cache service with a database

Avi asks a provocative question: can a database completely replace a dedicated caching service? Caches solve a vital problem—serving precomputed data at sub-millisecond latency—typically using the cache-aside pattern, where the application talks to both the cache and the database and takes responsibility for keeping them in sync. To simplify the architecture, you might try using a read replica as a cache: databases already keep hot pages in memory via their buffer pool, and if the application can tolerate replication lag, an asynchronous read replica can serve reads using the exact same SQL queries while eliminating custom cache-invalidation code. Embedded read replicas go further by avoiding network round-trips altogether, though synchronization still requires dedicated tooling (Litestream, for example, continuously streams SQLite backups to object storage rather than maintaining a live queryable replica out of the box).

Still, dedicated caches hold major advantages: spinning them up or tearing them down is cheap, developers control exactly which keys are stored, caches can hold precomputed results of expensive multi-table joins, they natively support per-key TTLs and eviction policies, they don’t require replicating terabytes of cold data just to serve a few gigabytes of hot keys, and they effortlessly handle hundreds of thousands of concurrent connections whereas database connections are resource-heavy. To close the gap, the author argues databases would need partial read replicas, support for massive numbers of lightweight replicas, and built-in Incremental View Maintenance (IVM) to keep query results precomputed the way Noria (now ReadySet) does. His conclusion: we aren’t there yet.

Bonus: Cool diagrams from ByteByteGo

A Detailed Guide to Content Delivery Networks CI/CD Pipeline Explained What are some of the most popular versioning strategies? The Testing Pyramid

Overall, I think this experiment went pretty well. The summaries are still a bit wordy and there were a few minor phrasing hiccups in Vietnamese, though for the price of free, it’s more than good enough :))) See you in upcoming posts!


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.