<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Microservices on miti99</title><link>https://miti99.com/en/tags/microservices/</link><description>Recent content in Microservices 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/microservices/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #75</title><link>https://miti99.com/en/post/2025/12/28/</link><pubDate>Sun, 28 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/28/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #75.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="front-end-vs-back-end-vs-system-design--what"&gt;&lt;a href="https://designgurus.substack.com/p/front-end-vs-back-end-vs-system-design" rel="noopener noreferrer"&gt;Front-End vs. Back-End vs. System Design – What&amp;rsquo;s the Difference in Interviews?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Front-end, back-end, and system design interviews evaluate very different skill sets, so each requires its own preparation strategy. Front-end interviews revolve around the client side: HTML, CSS, JavaScript, and usually a framework like React. They place less emphasis on complex algorithms and lean more toward domain knowledge like responsive design, CSS specificity, browser rendering pipelines, asynchronous JavaScript, and load-time optimization. Back-end interviews are more traditional: LeetCode-style data structures and algorithms with complexity analysis, paired with practical knowledge of APIs, databases (SQL and NoSQL, indexing, schema design), caching, and message queues. System design interviews zoom out to the big picture, testing your ability to architect a real-world system from scratch that is scalable, reliable, and maintainable.&lt;/p&gt;
&lt;p&gt;The author uses a house-building analogy: front-end is like interior design (how the rooms look and feel), back-end is like the structure and foundation (whether the house stands firm and utilities work properly), and system design is like the urban architect planning the entire neighborhood, deciding where houses, roads, and utilities go. To prepare for front-end interviews, build a few small projects and brush up on browser fundamentals and HTTP. For back-end, practicing algorithms and mastering database fundamentals remain the core focus.&lt;/p&gt;
&lt;h2 id="why-starting-with-microservices-can-be-your-biggest-architectural-mistake"&gt;&lt;a href="https://designgurus.substack.com/p/why-starting-with-microservices-can" rel="noopener noreferrer"&gt;Why Starting with Microservices Can Be Your Biggest Architectural Mistake&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Microservices are often treated as the industry default, but starting a brand-new project with microservices is a common and costly mistake: what works for a 5,000-engineer organization is usually poison for a five-person team. The core advice is &amp;ldquo;Monolith First.&amp;rdquo; A monolith&amp;rsquo;s superpower is simplicity: all code lives in one place, deploys as a single unit, and function calls happen instantaneously in the same memory space. Microservices introduce three nightmares. First, networks are unreliable, turning simple function calls into distributed systems problems with retries and timeouts. Second, each service owns its own database, so you can no longer &lt;code&gt;JOIN&lt;/code&gt; tables and must stitch data together in application code. Third, 10 services mean 10 build pipelines, 10 servers to monitor, and 10 places to dig through logs.&lt;/p&gt;
&lt;p&gt;At the start of a project, you also don&amp;rsquo;t yet know where the domain boundaries should be. Refactoring a monolith is just moving files between folders, whereas refactoring microservices requires changing API contracts, migrating databases, and coordinating multi-service deployments. A pragmatic middle ground is the Modular Monolith: a single codebase cleanly organized into modules like &lt;code&gt;/src/users&lt;/code&gt; and &lt;code&gt;/src/orders&lt;/code&gt; that still run inside a single runtime. This gives you the organizational clarity of microservices without the operational tax. Only move to microservices when the team outgrows the monolith (around 100 engineers), when individual features have vastly different scaling needs, or when you genuinely need polyglot technology stacks. Don&amp;rsquo;t optimize prematurely; wait until the pain is real.&lt;/p&gt;
&lt;h2 id="the-linux-kernel-is-just-a-program"&gt;&lt;a href="https://serversfor.dev/linux-inside-out/the-linux-kernel-is-just-a-program/" rel="noopener noreferrer"&gt;The Linux kernel is just a program&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article demystifies the Linux kernel—often treated as an impenetrable &amp;ldquo;black box&amp;rdquo;—through hands-on experiments. At its core, the kernel provides an abstraction layer for using hardware conveniently and safely: a unified API for interacting with hardware, managing how programs share CPU, memory, and resources, and enforcing access control. The closest analogy is that the kernel is simply a &amp;ldquo;runtime&amp;rdquo; for your computer. On most distributions, the kernel is just a compressed file of a few megabytes named &lt;code&gt;vmlinuz-…&lt;/code&gt; sitting in &lt;code&gt;/boot&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The author copies that file out and boots it directly with QEMU; the kernel starts up in about two seconds and then panics because it cannot find a root filesystem to hand off execution to an &lt;code&gt;init&lt;/code&gt; program—which is the exact expected behavior. Next, the author writes a tiny &lt;code&gt;init&lt;/code&gt; program in Go, packs it into a minimal &lt;code&gt;initramfs&lt;/code&gt;, and boots again. This time, the kernel runs the Go binary as PID 1. From this experiment, several core concepts click into place: a Linux distribution is just the kernel plus userland programs and configuration files; a process is a running program; a PID is a process identifier; &lt;code&gt;init&lt;/code&gt; is the very first process, responsible for starting other programs; and &lt;code&gt;init&lt;/code&gt; is the first program running in user space, where the kernel hands over control after initialization. This practical approach builds a clear mental model of how Linux actually works.&lt;/p&gt;
&lt;h2 id="why-your-load-balancer-is-the-bottleneck-and-how-to-fix-it"&gt;&lt;a href="https://designgurus.substack.com/p/dont-let-your-load-balancer-crash" rel="noopener noreferrer"&gt;Why Your Load Balancer is the Bottleneck (and How to Fix It)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Distributed systems have an ironic paradox: you add a load balancer to distribute traffic evenly across application servers, but when your product takes off, the load balancer itself becomes the bottleneck. Your application servers are healthy and your database is barely breaking a sweat, yet users complain that the site is slow or unreachable. According to the author, this is what separates junior developers from senior architects: plenty of people know how to put a load balancer in front of a service, but far fewer know what to do when the load balancer itself is the problem. The post explains why this happens and introduces five scaling strategies used by major tech companies.&lt;/p&gt;
&lt;p&gt;Strategies covered include DNS Round Robin to split traffic right at the DNS layer, choosing between Layer 4 and Layer 7 routing to reduce processing overhead, and Direct Server Return (DSR), which lets backend servers send responses straight back to the client without passing back through the load balancer. Each approach comes with trade-offs: DNS Round Robin is simple but slow to propagate changes, Layer 4 is faster than Layer 7 but offers fewer routing features, and DSR saves massive egress bandwidth at the cost of complex network configuration. Mastering these techniques lets your load-balancing tier scale horizontally alongside your application servers instead of becoming a single point of congestion.&lt;/p&gt;
&lt;h2 id="the-high-availability-blueprint-designing-systems-that-never-sleep"&gt;&lt;a href="https://designgurus.substack.com/p/the-high-availability-blueprint-designing" rel="noopener noreferrer"&gt;The High Availability Blueprint: Designing Systems That Never Sleep&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;High Availability (HA) is the art of building systems that &amp;ldquo;never sleep&amp;rdquo; on top of hardware that is guaranteed to fail. HA isn&amp;rsquo;t just about preventing failures—it&amp;rsquo;s about masking them so users never notice. Availability is measured in &amp;ldquo;nines&amp;rdquo;: 99% equates to about 3.65 days of downtime per year, 99.9% is about 8.76 hours, and 99.999% (&amp;ldquo;five nines&amp;rdquo;) is just over 5 minutes; every additional nine is exponentially harder and more expensive to achieve. The core philosophy is &amp;ldquo;assume everything will fail and plan for it.&amp;rdquo; The biggest enemy is a Single Point of Failure (SPOF)—any component whose failure brings down the entire system—and the antidote is redundancy: duplicating critical components.&lt;/p&gt;
&lt;p&gt;Key techniques include load balancers paired with health checks to automatically remove unhealthy servers from rotation; Leader-Follower database replication where a Follower is promoted to Leader upon failure; and failover strategies in two flavors. Active-Passive is simple but wasteful since standby servers sit idle most of the time. Active-Active utilizes all hardware continuously but is more complex, and in a two-node setup each node must be provisioned to handle 100% of the traffic if its peer goes down. Additionally, rate limiting (returning HTTP 429 when thresholds are exceeded) prevents cascading failures during traffic spikes. Achieving five nines requires geographic distribution across multiple regions to survive regional disasters. The guiding mantra: &amp;ldquo;Two is one, and one is none&amp;rdquo;—always have a backup plan.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="images"&gt;Images&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!ETm5!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F2112a03d-cc48-4db5-9740-94adc1a7efbf_2360x2920.png" alt="Common Network Protocols Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!5bFA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F722913d5-a10f-44c2-98ed-edc27a92a137_1444x1882.jpeg" alt="8 Popular Network Protocols"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!pen8!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F22fdf2d2-5ce5-4c2b-90f9-3bcfcecb5fc1_1370x1536.jpeg" alt="9 best practices for developing microservices"&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 #22</title><link>https://miti99.com/en/post/2025/05/09/</link><pubDate>Fri, 09 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #22.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="identity-tokens-best-practices"&gt;&lt;a href="https://www.permit.io/blog/identity-tokens-best-practices" rel="noopener noreferrer"&gt;Identity Tokens Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gabriel L. Manor (Permit.io) explains that an identity token is a signed package of claims issued by an identity provider to represent a user or service, typically built on OAuth 2.0, OpenID Connect, and the JWT format consisting of a header, a payload containing claims like &lt;code&gt;iss&lt;/code&gt;, &lt;code&gt;exp&lt;/code&gt;, and &lt;code&gt;sub&lt;/code&gt;, and a digital signature. The article distinguishes common token types: JWTs, OpenID Connect ID tokens, opaque tokens (random strings whose underlying data is stored server-side), and API keys for service-to-service communication. The biggest advantage is delegated authentication: applications don&amp;rsquo;t have to handle passwords directly and only need to validate the token (signature, issuer, audience, and expiration), making single sign-on (SSO) and scaling microservices straightforward.&lt;/p&gt;
&lt;p&gt;The most valuable section covers common anti-patterns: treating identity tokens as the source of truth for all authorization decisions, stuffing way too much data (permission lists, URLs, entire user objects) into token claims, setting expiration times too short or too long, and maintaining completely separate authentication flows for human users versus machines. The core recommendation is decoupling authentication (who you are) from authorization (what you are allowed to do right now) so policies can change without reissuing tokens. Beyond that, keep tokens small, stick to open standards, balance token lifetimes, plan for token revocation, always transmit tokens over HTTPS, keep them out of logs and URLs, and always verify JWT signatures. Note that since this is the blog of an authorization vendor, it includes a brief product pitch alongside the technical advice.&lt;/p&gt;
&lt;h2 id="tactical-work-in-the-age-of-layoffs"&gt;&lt;a href="https://www.seangoedecke.com/tactical-work-in-the-age-of-layoffs" rel="noopener noreferrer"&gt;Tactical Work in the Age of Layoffs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke observes that the golden era of 2010s tech—when companies actively protected work-life balance—is over; today&amp;rsquo;s leadership demands faster delivery and higher output against a backdrop of layoff anxiety. The naive response is keeping your existing work habits and simply working longer hours: that works in the short term, but leads to burnout, mistakes, and unsustainability. Instead, Goedecke advises deploying your time more tactically, because companies don&amp;rsquo;t care how many hours you work—they care about the volume of visible output you deliver.&lt;/p&gt;
&lt;p&gt;Specifically, when under pressure, you can scale back work that is genuinely useful for the codebase but goes unrewarded as &amp;ldquo;free labor&amp;rdquo;: writing comprehensive tests, refactoring legacy code, proactively helping other teams unasked, exploring new technologies, or improving internal processes. The litmus test is simple: would you be willing to do that work for free? Goedecke isn&amp;rsquo;t advocating abandoning all craft—he still voluntarily writes a few integration tests for critical flows. His second piece of advice is to go all-in when your project has executive visibility (clues: your manager&amp;rsquo;s manager attends the kickoff, or the project gets mentioned in company-wide all-hands), and then coast to recover during quieter stretches, because nobody can sprint forever without burning out.&lt;/p&gt;
&lt;h2 id="tracing-thoughts-in-language-model"&gt;&lt;a href="https://www.anthropic.com/research/tracing-thoughts-language-model" rel="noopener noreferrer"&gt;Tracing Thoughts in Language Model&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic introduces its latest mechanistic interpretability research, likening the effort to building an &amp;ldquo;AI microscope&amp;rdquo; to peer inside a language model&amp;rsquo;s internals. Because language models are not programmed directly by humans—instead learning problem-solving strategies during training—even their creators don&amp;rsquo;t fully understand how they arrive at answers. Two companion papers extend Anthropic&amp;rsquo;s earlier work from identifying individual internal concepts (&amp;ldquo;features&amp;rdquo;) to linking them together into computational &amp;ldquo;circuits,&amp;rdquo; applying the method to study Claude 3.5 Haiku across ten representative behaviors.&lt;/p&gt;
&lt;p&gt;The findings are full of surprises. Claude appears to think in a shared conceptual space across languages, and this language-agnostic representation grows larger with model scale. When writing rhyming poetry, the model selects the rhyming word at the end of a line in advance and then composes the line to land on it, even though it was trained purely to predict one token at a time. When doing mental arithmetic like 36+59, it runs two parallel pathways—one computing a rough magnitude estimate and another computing the exact ones digit—yet when asked to explain how it got the answer, it recites the standard textbook carrying algorithm instead. Researchers also caught the model fabricating plausible-sounding post-hoc reasoning to agree with a user&amp;rsquo;s incorrect hint, and found that by default Claude is wired to abstain from guessing unless a specific circuit suppresses that reluctance when it recognizes a known entity. The team notes that their current method still captures only a small fraction of the model&amp;rsquo;s total computation.&lt;/p&gt;
&lt;h2 id="why-duplicating-environments-for-microservices-backfires"&gt;&lt;a href="https://www.signadot.com/blog/why-duplicating-environments-for-microservices-backfires" rel="noopener noreferrer"&gt;Why Duplicating Environments for Microservices Backfires&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arjun Iyer (Signadot) argues that in microservices development, the time it takes to test a code change in a production-like environment determines engineering velocity—and the common approach of spinning up full duplicate environments on demand for each developer or team (via VMs, Kubernetes namespaces, or dedicated clusters) breaks down as systems grow. Every environment requires the full set of services, load balancers, API gateways, databases, and message queues, making it painful to manage; teams resort to mocks that drift from reality, test data falls out of sync, environments quickly lag behind &lt;code&gt;main&lt;/code&gt;, and provisioning gets slower and slower. The cloud bill is steep too: running a 50-microservice environment on an EC2 &lt;code&gt;m6a.8xlarge&lt;/code&gt; instance costs roughly $11,232 per year, which multiplied across 50 copies exceeds $560,000 in compute alone.&lt;/p&gt;
&lt;p&gt;The alternative Iyer proposes is sharing a single baseline environment with request-level isolation via lightweight &amp;ldquo;sandboxes,&amp;rdquo; similar to Uber&amp;rsquo;s end-to-end testing architecture: only the modified services are deployed into a sandbox, while requests are dynamically routed based on headers. This saves compute, produces consistent results, simplifies maintenance, spins up sandboxes nearly instantly, and stays much closer to production. Implementing it requires three pieces: context propagation across service boundaries (using OpenTelemetry &lt;code&gt;baggage&lt;/code&gt; and &lt;code&gt;tracecontext&lt;/code&gt; standards), data isolation so tests cannot mutate shared baseline records they didn&amp;rsquo;t create, and message-queue routing so sandboxes don&amp;rsquo;t compete for the same events.&lt;/p&gt;
&lt;h2 id="logging-practices-i-follow"&gt;&lt;del&gt;&lt;a href="https://www.16elt.com/2023/01/06/logging-practices-I-follow" rel="noopener noreferrer"&gt;Logging Practices I Follow&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Eliran Turgeman shares the logging principles he follows, starting from the observation that logs are the most fundamental observability tool and that their primary audience is developers themselves. Before adding a log statement, ask yourself: is this log truly necessary, or does it duplicate information already logged elsewhere in the same flow; could the logged object blow up in size in production—and if so, can you log just a count or a few key fields instead; and does this message actually help someone debug or understand the execution path? Next, keep log formatting consistent across the entire system—for example, always prefixing messages with &lt;code&gt;[serviceName](functionName)&lt;/code&gt; so engineers can locate the exact call site without even opening the codebase.&lt;/p&gt;
&lt;p&gt;For log levels, Turgeman sticks mainly to four: &lt;code&gt;ERROR&lt;/code&gt; when part of a flow fails and needs to page someone on call, &lt;code&gt;WARNING&lt;/code&gt; for abnormal behavior worth investigating, &lt;code&gt;INFO&lt;/code&gt; for major milestones in a request flow, and &lt;code&gt;DEBUG&lt;/code&gt; for fine-grained inspection of objects and data structures; the most common mistakes are logging way too much detail at &lt;code&gt;INFO&lt;/code&gt; or never using &lt;code&gt;DEBUG&lt;/code&gt; at all. Finally, be mindful of cost: dumping a massive JSON payload into logs is both unreadable and expensive—at roughly $0.50 per GB in AWS CloudWatch, a single noisy log line can easily cost thousands of dollars a month. Making every log message unique across the codebase, aided by the service and function prefix, makes troubleshooting much faster.&lt;/p&gt;
&lt;h2 id="sync-and-async"&gt;&lt;a href="https://blogs.newardassociates.com/blog/2025/sync-and-async.html" rel="noopener noreferrer"&gt;Sync and Async&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ted Neward argues that the &amp;ldquo;work from home (WFH) versus return to office (RTO)&amp;rdquo; debate focuses on the wrong question: the real issue isn&amp;rsquo;t &lt;em&gt;where&lt;/em&gt; work happens, but &lt;em&gt;how&lt;/em&gt; work happens—specifically, synchronous versus asynchronous work. After recapping the pandemic shift to remote work and the subsequent wave of hybrid policies and RTO mandates, Neward lays out his premises: we still have no objective metric for developer &amp;ldquo;productivity,&amp;rdquo; remote teams can be led effectively by skilled managers, talent is distributed everywhere, yet human relationships deepen faster face-to-face—and commuting into an office just to sit on Zoom calls with headphones on makes no sense.&lt;/p&gt;
&lt;p&gt;He defines &amp;ldquo;synchronous&amp;rdquo; work as tasks that require back-and-forth interaction with others to make progress, and &amp;ldquo;asynchronous&amp;rdquo; work as tasks where you can move forward independently without waiting on new input. Writing code and debugging are largely asynchronous (even if rubber-ducking a bug with a colleague helps); pair programming and requirements gathering with stakeholders are synchronous; code reviews and architecture brainstorming alternate between both. Rather than a binary, sync and async form a spectrum, which Neward maps across two axes: degree of synchronicity and communication fidelity (bandwidth). Activities high on both axes—like pair programming or design brainstorming—benefit most from being in the same room, while activities low on both—like heads-down coding—can be done from anywhere.&lt;/p&gt;
&lt;h2 id="making-uber"&gt;&lt;a href="https://www.uber.com/en-IN/blog/making-ubers-experiment-evaluation-engine-100x-faster/" rel="noopener noreferrer"&gt;Making Uber&amp;rsquo;s Experiment Evaluation Engine 100x Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber&amp;rsquo;s engineering team recounts how they cut A/B experiment evaluation latency for Go backend microservices by 100x, dropping p99 latency from roughly 10 ms to 100 µs. Previously, every active experiment was evaluated via remote RPC calls to a centralized Parameter Service. That approach was too slow for Uber&amp;rsquo;s real-time paths, turned the central service into a single point of failure, and forced developers to rely on batch prefetching—requiring them to know upfront which parameters a request would need, with any omission causing bugs. Their solution was moving to local evaluation: distributing experiment metadata to every host over Uber&amp;rsquo;s existing Flipr configuration distribution channel and running the evaluation logic inside an in-process &lt;code&gt;ExperimentPlugin&lt;/code&gt; within the client library.&lt;/p&gt;
&lt;p&gt;To guarantee correctness during the migration, the team ran shadow testing across a sample of roughly 20 million evaluations per second, comparing legacy and local results, fixing 13 edge-case bugs, and achieving over 99.999% parity. Because faster evaluations also meant impression logs were pushed to Kafka at a much higher rate, they added monitoring, alerting, and an in-memory LRU cache that deduplicated roughly 80% of redundant exposure logs, along with internal kill-switch parameters to disable features instantly without redeployment. Today, more than 100 services representing nearly 70% of experiment traffic have migrated, cutting UberEats search autocomplete indexing latency by 20%. Their takeaway: start with a simple centralized architecture, and only decentralize once your platform is mature enough to handle it.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #17</title><link>https://miti99.com/en/post/2025/05/04/</link><pubDate>Sun, 04 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #17.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="to-fork-or-not-to-fork"&gt;&lt;a href="https://www.augmentcode.com/blog/to-fork-or-not-to-fork" rel="noopener noreferrer"&gt;To fork or not to fork?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Scott Dietzen, CEO of Augment Code (and former CEO of Pure Storage), discusses a key architectural decision facing AI coding assistants: running as a plugin inside standard IDEs versus forking VS Code outright. GitHub Copilot and Augment chose the former, operating as plugins in VS Code, JetBrains, or Vim. Cursor and Windsurf (by Codeium) chose the latter, modifying the VS Code source directly for deeper AI integration.&lt;/p&gt;
&lt;p&gt;According to Dietzen, forking yields short-term advantages, but users pay the price: they are forced out of their familiar IDEs (especially painful for JetBrains users), lose official Microsoft support, run into issues with official plugins like Python, C++, Docker, or Jupyter, lose access to the official VS Code extension marketplace, and have to wait for the fork maintainers to port upstream features. For the long-term benefit of customers, Augment chose the plugin route and focused on its core strength of supporting large, complex codebases. Dietzen also notes that Cursor is the third most popular IDE among users trialing Augment, showing that the two products can complement each other.&lt;/p&gt;
&lt;h2 id="why-i"&gt;&lt;a href="https://blog.container-solutions.com/why-im-no-longer-talking-to-architects-about-microservices" rel="noopener noreferrer"&gt;Why I&amp;rsquo;m No Longer Talking to Architects About Microservices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ian Miell explains why he no longer wants to debate microservices with software architects. The first problem is that nobody agrees on what &amp;ldquo;microservices&amp;rdquo; actually means: some measure it by lines of code, others tie it to team structure, and others equate it with container deployments. Like DevOps or Agile, the term has lost much of its original meaning through overuse.&lt;/p&gt;
&lt;p&gt;The second problem is that discussions are typically abstract and disconnected from business goals: promises of scalability, agility, or reduced cognitive load rarely go tested. The third problem is that microservices only pay off when the organization changes alongside them—requiring cross-functional teams, decentralized decision-making, and a mature DevOps culture—and changing organizational structure is far harder than changing software architecture. Even Sam Newman advises that most organizations shouldn&amp;rsquo;t adopt microservices without a compelling reason. Miell suggests starting from concrete problems like shortening release cycles, improving reliability, or removing bottlenecks, and only then asking whether microservices are the right solution.&lt;/p&gt;
&lt;h2 id="not-all-ai-assisted-programming-is-vibe-coding-but-vibe-coding-rocks"&gt;&lt;a href="https://simonwillison.net/2025/Mar/19/vibe-coding/" rel="noopener noreferrer"&gt;Not all AI-assisted programming is vibe coding (but vibe coding rocks)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison argues that the term &amp;ldquo;vibe coding,&amp;rdquo; coined by Andrej Karpathy in February 2025, is being misused as a catch-all for any AI-assisted programming. By Karpathy&amp;rsquo;s original definition, vibe coding means &amp;ldquo;forgetting that the code even exists&amp;rdquo;: accepting every change generated by an LLM without reading it. Responsible AI-assisted programming, by contrast, still involves reviewing, testing, and understanding every implementation detail. Willison&amp;rsquo;s golden rule: never commit code to a repository if you couldn&amp;rsquo;t explain exactly what it does to someone else.&lt;/p&gt;
&lt;p&gt;Even so, Willison is a fan of vibe coding. It lowers the barrier for beginners, helps them build useful tools on their own, and is a great way for experienced developers to build intuition for what LLMs can and cannot do. The key is restricting it to low-stakes, disposable projects—ideally inside a sandbox like Claude Artifacts—and avoiding anything involving security, privacy, or financial risk. He also hopes to see safer tools emerge so newcomers can experiment without causing harm.&lt;/p&gt;
&lt;h2 id="career-advice-in-2025"&gt;&lt;a href="https://lethain.com/career-advice-2025" rel="noopener noreferrer"&gt;Career advice in 2025.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Larson surveys the 2025 tech job market and identifies four major shifts. First, managers who advanced between 2010 and 2020 through strong hiring and team morale now face new expectations: getting into the details, driving faster execution, and leading the transition to AI. Second, the wave of foundation models has invalidated many old playbooks; products now need to be designed around progressive validation with human-in-the-loop verification for critical data, while staying prepared for models either making massive leaps forward or plateauing right where they are.&lt;/p&gt;
&lt;p&gt;Third, non-AI companies are struggling to raise funding, leading to fewer promotions and raises, while equity at AI startups is far from a guaranteed payout. Fourth, companies are pushing existing teams harder to find growth, turning once-comfortable roles into high-pressure ones. Today it is rare to find great colleagues, prestige, and learning opportunities all in the same job. Larson&amp;rsquo;s advice: don&amp;rsquo;t sit on the sidelines waiting for the market to recover—make your current work count, and remember that these headwinds are industry-wide, not a reflection of your personal ability.&lt;/p&gt;
&lt;h2 id="tips-for-better-interactions"&gt;&lt;a href="https://staysaasy.com/saas/2025/03/17/interactions.html" rel="noopener noreferrer"&gt;Tips For Better Interactions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stay SaaSy shares six practical tips for more effective workplace meetings and interactions. When someone says you seem &amp;ldquo;frustrated,&amp;rdquo; don&amp;rsquo;t accept that framing—restate calmly that you are escalating an issue or need more information so you aren&amp;rsquo;t dismissed as acting out of emotion. Volunteer to take notes in meetings: it signals humility, lets you help steer the discussion, gives you a natural pause to stay composed, and shows people their points are being heard. Avoid pushing back with extreme slippery-slope hypotheticals like &amp;ldquo;if we let everyone choose their own project, it&amp;rsquo;ll be chaos,&amp;rdquo; which implicitly insults the proposer&amp;rsquo;s judgment and wastes time.&lt;/p&gt;
&lt;p&gt;Don&amp;rsquo;t interrupt someone mid-thought just to correct an immaterial detail; follow up privately afterward if needed. Schedule important meetings thoughtfully—avoid Mondays, Fridays, lunch hours, and the end of the day—and keep a consistent weekly slot for 1:1s. Finally, order meeting agendas by priority: thoroughly resolving two important topics is far better than rushing through five without reaching a conclusion.&lt;/p&gt;
&lt;h2 id="code-is-the-new-no-code"&gt;&lt;a href="https://lumberjack.so/code-is-the-new-no-code/" rel="noopener noreferrer"&gt;Code is the new no-code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Szabo-Stuban and Evan Boyle (CEO of GenSX) argue that the promise of the no-code movement is finally being realized in an unexpected way: through code itself. Visual programming tools are easy at first, but complexity balloons rapidly—a marketing automation workflow in n8n can easily sprawl into a spiderweb of 47 interconnected nodes. Abstractions inevitably leak, forcing users to learn technical concepts anyway, and power users usually end up migrating back to code.&lt;/p&gt;
&lt;p&gt;According to the authors, AI coding assistants like Claude, ChatGPT, and GitHub Copilot have flipped the script: users describe their goal in plain language, the AI generates working code and explains each piece, and learning happens gradually instead of hitting a wall. Combined with familiar component models like React, code becomes even more intuitive than node-based visual editors. The post illustrates this with GenSX, where a workflow that fetches CRM data, filters it, and generates a report is written as readable JavaScript components, arguing that because most workflows are sequential, the tree structure of code is naturally easier to follow than a graph.&lt;/p&gt;
&lt;h2 id="how-to-improve-jvm-based-application-startup-time"&gt;&lt;a href="https://softwaremill.com/how-to-improve-jvm-based-application-startup-time/" rel="noopener noreferrer"&gt;How to Improve JVM-Based Application Startup Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michał Zyga (SoftwareMill) compares five approaches to shortening JVM application startup time, a critical metric for serverless and microservices. The JVM starts slowly because it has to load, verify, and initialize a large number of classes. Class Data Sharing (CDS) pre-packages core JDK classes and has been enabled by default since JDK 12; Application Class Data Sharing (AppCDS) extends this to application classes and became easier to use in JDK 19. GraalVM compiles ahead-of-time (AOT) into a native binary, CRaC snapshots a running JVM process using CRIU (Linux-only) for fast restore, and Project Leyden is a newer JDK effort that caches additional optimization data.&lt;/p&gt;
&lt;p&gt;Benchmarks on a sample Netty application across two machines (a personal Intel i5 laptop and a Google Cloud Xeon instance, 50 runs per configuration) show that AppCDS more than doubles startup speed over the default, CRaC and GraalVM are the fastest overall, and Project Leyden sits in the middle while still under active development. Zyga recommends choosing based on context: AppCDS is an easy win with moderate gains, CRaC suits long-running services since it retains full runtime JIT optimizations, and GraalVM fits short-lived workloads that need near-instant startup.&lt;/p&gt;
&lt;h2 id="domain-driven-design"&gt;&lt;a href="https://dev.to/lovestaco/domain-driven-design-3i2j" rel="noopener noreferrer"&gt;Domain Driven Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Athreya (Maneshwar) introduces Domain-Driven Design (DDD), an approach to software design that puts the business domain at the center rather than focusing purely on technical concerns. The article walks through core DDD building blocks: domains and subdomains; Bounded Contexts that draw clear boundaries so models stay independent; Entities with distinct identities versus immutable Value Objects defined by their attributes; Aggregates that group related objects under an Aggregate Root; Domain Events that decouple system components; Repositories, Services, and Factories for persistence, domain operations, and object creation; and Ubiquitous Language, a shared vocabulary between developers and domain experts.&lt;/p&gt;
&lt;p&gt;These concepts are illustrated through an e-commerce platform where order management is separated from the product catalog, accompanied by TypeScript examples of an &lt;code&gt;Order&lt;/code&gt; class managing state and an &lt;code&gt;OrderRepository&lt;/code&gt; handling persistence. The author notes that DDD shines in complex, long-lived projects requiring close collaboration between engineering and business teams, but can easily lead to over-engineering for simple CRUD apps; applying it well requires a solid grasp of design patterns and object-oriented principles.&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/66d12ddc-2abe-4a98-82d5-ee177e80487c_1470x1600.png" alt="Monolith vs Microservices vs Modular Monoliths"&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 #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 #8</title><link>https://miti99.com/en/post/2025/03/24/</link><pubDate>Mon, 24 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #8.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="let"&gt;&lt;a href="https://info.michael-simons.eu/2025/02/05/lets-deadlock-all-the-things/" rel="noopener noreferrer"&gt;Let&amp;rsquo;s deadlock all the things&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael J. Simons recounts a &amp;ldquo;rookie mistake&amp;rdquo; he made while migrating code from legacy &lt;code&gt;HttpURLConnection&lt;/code&gt; to Java&amp;rsquo;s modern &lt;code&gt;HttpClient&lt;/code&gt;. Because &lt;code&gt;HttpClient&lt;/code&gt; does not directly expose an &lt;code&gt;OutputStream&lt;/code&gt; for streaming data into a request body (for instance, when using Jackson to serialize a large JSON payload), he connected a &lt;code&gt;PipedInputStream&lt;/code&gt; and a &lt;code&gt;PipedOutputStream&lt;/code&gt; and ended up performing both the write and the read on the same thread—even though the JavaDoc explicitly warns that doing so can deadlock. Initial unit tests passed because the test payloads were tiny, but as soon as a payload exceeded the default 1,024-byte pipe buffer in production, the thread blocked forever; repeated enough times, it starves the entire thread pool.&lt;/p&gt;
&lt;p&gt;What could have prevented the bug, the author reflects, was a little less overconfidence, a second pair of eyes in code review, and thorough boundary testing. AI assistants might help generate larger test payloads, he notes, but rarely catch subtle API misuses—and even IntelliJ didn&amp;rsquo;t flag a warning. The fix was to create the two streams independently, connect them outside both the reader and writer lambdas, run the write operation on a dedicated virtual thread, and close the output stream inside that thread. It&amp;rsquo;s a great reminder to read the JavaDoc carefully and understand the threading model of the APIs you use.&lt;/p&gt;
&lt;h2 id="engineers-who-won"&gt;&lt;a href="https://www.seangoedecke.com/taking-a-position/" rel="noopener noreferrer"&gt;Engineers who won&amp;rsquo;t commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that sitting on the fence in technical discussions is only acceptable when you are a junior engineer. Once you are the person in the room with the most context, skill, or influence, you have a responsibility to take a position—even when you are only 55–60% confident. Staying silent forces less-informed teammates to guess, creates a vacuum where the loudest, least-competent voice can steer the group into a bad idea, and ultimately punts hard technical decisions onto engineering managers. The author bluntly calls this refusal to commit cowardice, rooted in a fear of being wrong that he himself had to overcome earlier in his career.&lt;/p&gt;
&lt;p&gt;Managers, he notes, are generally quite forgiving when you make a well-reasoned call that turns out to be wrong, as long as you aren&amp;rsquo;t wrong all the time. Refusing to give time estimates is the same failure mode: managers need a rough ballpark to plan around, and answering &amp;ldquo;it depends&amp;rdquo; just forces them to make up a number themselves. The one exception is genuinely toxic workplaces where engineers are punished for missed estimates—there, keeping your head down is understandable. He also adds that when brainstorming with peers who share your level of context, staying open-minded and exploratory is completely fine.&lt;/p&gt;
&lt;h2 id="patterns-for-building-realtime-features"&gt;&lt;a href="https://zknill.io/posts/patterns-for-building-realtime/" rel="noopener noreferrer"&gt;Patterns for building realtime features&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Zak Knill surveys four common architectural patterns for building real-time features where a server pushes one user&amp;rsquo;s changes out to other connected clients. The &lt;strong&gt;poke/pull&lt;/strong&gt; pattern is the easiest to bolt onto an existing system: the server sends a lightweight &amp;ldquo;poke&amp;rdquo; notification prompting clients to refetch the latest state via standard HTTP APIs, though this can trigger a thundering herd of simultaneous requests that must be mitigated with caching or client-side jitter. &lt;strong&gt;Push state&lt;/strong&gt; sends the entire updated state payload directly, preventing client drift, but scales poorly as state objects grow and makes it hard for clients to tell exactly what changed. &lt;strong&gt;Push ops&lt;/strong&gt; sends only the delta operation (such as flipping a todo item&amp;rsquo;s &lt;code&gt;completed&lt;/code&gt; field), keeping payloads small, but requires a way to fetch initial state and demands that the server track each client&amp;rsquo;s current state version. &lt;strong&gt;Event sourcing&lt;/strong&gt; broadcasts the domain event itself, requiring every client to reimplement the business logic needed to interpret and fold that event into local state.&lt;/p&gt;
&lt;p&gt;At the transport layer, WebSockets, Server-Sent Events (SSE), and long polling all operate as 1-to-1 HTTP connections between a single client and a single server instance. Once you scale horizontally across multiple server replicas, the instance that processes a write is often not the instance holding open connections to the other clients that need the update. Rather than having every server replica poll the database, the author recommends using a Pub/Sub backbone to fan updates out across instances and manage connection infrastructure.&lt;/p&gt;
&lt;h2 id="optimizing-the-databases-at-quora"&gt;&lt;a href="https://quoraengineering.quora.com/Optimizing-the-databases-at-Quora" rel="noopener noreferrer"&gt;Optimizing the databases at Quora&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Quora engineering team shares how they optimized their database tier as the platform scaled to handle massive data volumes while keeping user-facing latency low. Their first strategy was partitioning data (sharding) by &lt;code&gt;user_id&lt;/code&gt; to distribute load across multiple database servers. Alongside sharding, the team profiled common query patterns, added targeted indexes, and eliminated redundant queries. Quora also built a multi-layered caching architecture—spanning application-level caches for hot objects, database-level query caching, and a distributed Memcached tier—while separating read and write paths so each side could scale independently.&lt;/p&gt;
&lt;p&gt;Beyond those core techniques, Quora invested heavily in comprehensive monitoring and alerting to track database health and catch anomalies early. Key takeaways include treating performance optimization as an ongoing discipline rather than a one-off project, building automation tooling for routine database administration, and constantly balancing raw performance gains against system simplicity.&lt;/p&gt;
&lt;h2 id="failure-mitigation-for-microservices-an-intro-to-aperture"&gt;&lt;a href="https://careersatdoordash.com/blog/failure-mitigation-for-microservices-an-intro-to-aperture/" rel="noopener noreferrer"&gt;Failure Mitigation for Microservices: An Intro to Aperture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cong Ma and Matt Ranney from DoorDash examine common failure modes in microservice architectures: cascading failures rippling across service dependencies, retry storms where aggressive retries pile extra load onto an already degraded service, death spirals where failed nodes shift traffic onto surviving nodes until they collapse too, and metastable failures where a positive feedback loop keeps a system wedged even after the original trigger disappears. Traditional defenses like local load shedding, circuit breakers, and reactive autoscaling only see a single service&amp;rsquo;s local state, require brittle threshold tuning, and cannot coordinate with one another; the authors also advocate predictive autoscaling over reactive scaling that kicks in only after load has already spiked.&lt;/p&gt;
&lt;p&gt;From there, the post evaluates Aperture, an open-source reliability management platform from FluxNinja designed around global visibility and closed-loop control. Aperture collects telemetry from service nodes into Prometheus, uses a standalone controller to monitor deviations from SLOs based on declarative YAML policies, and actuates proportional responses—such as load shedding or distributed rate limiting—at individual nodes. After integrating Aperture into a core service in their staging environment, DoorDash found it worked well as an easy-to-configure load shedder compared to their existing setup, though more advanced capabilities like coordinated multi-service failure mitigation remained to be tested.&lt;/p&gt;
&lt;h2 id="zero-configuration-service-mesh-with-on-demand-cluster-discovery"&gt;&lt;a href="https://netflixtechblog.com/zero-configuration-service-mesh-with-on-demand-cluster-discovery-ac6483b52a51" rel="noopener noreferrer"&gt;Zero Configuration Service Mesh with On-Demand Cluster Discovery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Netflix engineering team recounts their journey migrating to a service mesh. Netflix began moving to the cloud in 2008, with the streaming platform running entirely on AWS by 2010. Back when cloud-native tooling barely existed, they built Eureka for service discovery and Ribbon for inter-process communication (IPC). That architecture served them well for a decade, but as internal traffic diversified across REST, GraphQL, and gRPC in multiple programming languages—and teams needed advanced capabilities like adaptive concurrency limits and circuit breaking—maintaining polyglot client libraries became unsustainable. Moving to an Envoy-based service mesh let them centralize IPC logic in an out-of-process proxy.&lt;/p&gt;
&lt;p&gt;The biggest roadblock was that Envoy expects every upstream cluster a service might call to be declared ahead of time, whereas a typical Netflix service talks to dozens of upstream clusters whose owners often don&amp;rsquo;t know the full dependency list—and pushing every cluster in the company to every Envoy proxy was impossible with millions of endpoints. Netflix partnered with Kinvolk and the Envoy community to build &lt;strong&gt;On-Demand Cluster Discovery&lt;/strong&gt;: when an outgoing request targets an unknown cluster, Envoy pauses the request, queries the control plane via CDS (Cluster Discovery Service), fetches its endpoints via EDS backed by Eureka, and resumes the request. This made migration completely zero-configuration for service owners, at the cost of a few extra milliseconds on the very first request to a new cluster—meaning only ultra-latency-sensitive services need to pre-declare clusters or pre-warm connections.&lt;/p&gt;
&lt;h2 id="the-quest-to-understand-metric-movements"&gt;&lt;a href="https://medium.com/pinterest-engineering/the-quest-to-understand-metric-movements-8ab12ae97cda" rel="noopener noreferrer"&gt;The Quest to Understand Metric Movements&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Pinterest engineering team introduces the three pillars behind their automated Root Cause Analysis (RCA) system for investigating sudden spikes or drops in core business metrics—movements that can stem from anything from an OS upgrade to a broken data pipeline. The first approach, &lt;strong&gt;Slice and Dice&lt;/strong&gt;, breaks a metric down across dimensions like country, device type, and Pin format into a hierarchical segment tree (inspired by LinkedIn&amp;rsquo;s ThirdEye) and scores each segment&amp;rsquo;s anomaly contribution; this proved especially effective for video playback metrics. The second approach, &lt;strong&gt;General Similarity&lt;/strong&gt;, searches for other metrics that moved in a similar pattern over the same time window using Pearson correlation, Spearman rank correlation, Euclidean distance, and dynamic time warping—with Pearson and Spearman proving most useful because they provide p-values and capture inverse relationships cleanly (with the standard caveat that correlation does not imply causation).&lt;/p&gt;
&lt;p&gt;The third approach, &lt;strong&gt;Experiment Effects&lt;/strong&gt;, inverts traditional A/B test analysis: given a moving metric, it ranks active experiments that had the strongest statistically significant impact on that metric using Welch&amp;rsquo;s t-test and noise filters, and is now integrated into Pinterest&amp;rsquo;s experimentation platform covering nearly 2,000 metrics. Analysts can chain all three techniques iteratively to narrow down root causes. Looking ahead, Pinterest plans to incorporate user feedback loops, explore causal discovery to map cause-and-effect graphs across metrics, and embed RCA directly into their data discovery and visualization tools.&lt;/p&gt;
&lt;h2 id="meta"&gt;&lt;a href="https://cacm.acm.org/research/metas-hyperscale-infrastructure-overview-and-insights/" rel="noopener noreferrer"&gt;Meta&amp;rsquo;s Hyperscale Infrastructure: Overview and Insights&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chunqiang Tang provides a sweeping overview of Meta&amp;rsquo;s hyperscale infrastructure and the lessons learned along the way, arguing that while few engineers directly build infrastructure at this scale, many mainstream industry technologies originate there. Meta&amp;rsquo;s engineering culture revolves around four pillars: moving fast with continuous deployment, technological openness via a unified monorepo and major open-source projects like PyTorch, Llama, and Presto, conducting systems research directly on production infrastructure rather than in an isolated research lab, and standardizing on shared infrastructure building blocks (for instance, converging product teams onto ZippyDB as a common key-value store). To maximize developer productivity, Meta pushes continuous deployment to extreme scale—executing over 100,000 configuration changes per day with 97% of services deploying completely automatically, while roughly 50% more engineers write serverless functions than traditional long-running services.&lt;/p&gt;
&lt;p&gt;To drive down hardware costs, Meta treats its global fleet of data centers as a single planet-scale computer, automatically placing and migrating workloads across regions, co-designing hardware and software to compensate for commodity hardware failure rates, and tiering storage across hot, warm, and cold media. On the AI front, Meta co-designs the entire stack—from PyTorch, custom AI accelerators, and datacenter fabrics up to foundation models like Llama—and projects that before the end of the decade, more than half of its datacenter power capacity will be dedicated to AI workloads.&lt;/p&gt;
&lt;h2 id="incremental-platforms-monolithic-modular-architecture"&gt;&lt;a href="https://newsletter.optimistengineer.com/p/incremental-platforms-monolithic" rel="noopener noreferrer"&gt;Incremental Platforms: Monolithic Modular Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kicking off a series on incremental architecture for SaaS products, Marcos F. Lobo introduces the &lt;strong&gt;Modular Monolith&lt;/strong&gt;: packaging and deploying the entire application as a single artifact while structuring the internal codebase into well-defined modules with clear responsibilities that communicate strictly through explicit interfaces and contracts. This approach retains the operational simplicity of a monolith while capturing the modularity benefits of decoupled design. To pull it off, the author advises defining strict module boundaries and using patterns like Facade to hide internal implementation details, enforcing high cohesion and low coupling within each module, aligning package structure with module boundaries so modules can be extracted later if needed, pairing use-case testing with CI/CD, and wiring dependencies via dependency injection or in-process messaging and events.&lt;/p&gt;
&lt;p&gt;The benefits include simple single-artifact deployment and operations, easier refactoring and local development, fast in-memory calls between modules instead of network RPCs, straightforward transactional consistency, and natural alignment with Domain-Driven Design when modules map to bounded contexts. According to the author, a modular monolith is an ideal starting point for early-stage products, small teams, and systems that prioritize strong consistency, while serving as a clean stepping stone toward microservices if and when business scale demands it.&lt;/p&gt;
&lt;h2 id="bonus-interesting-videos-from-bytebytego"&gt;Bonus: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=3Kqal7QaCCM" rel="noopener noreferrer"&gt;How the Garbage Collector Works in Java, Python, and Go!&lt;/a&gt;&lt;/p&gt;
&lt;h2 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;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c3beec9e-cd04-4748-ae7e-3299b42883f6_2360x2824.png" alt="How to Build Idempotent APIs"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2f632296-4214-4ec8-a1d2-280e9b7f2696_1280x1532.gif" alt="12 Algorithms for System Design Interviews"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/65a92a81-f2c5-4aed-9faa-35a66124cffe_1283x1536.gif" alt="How Kubernetes Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a6903386-4b5f-450e-b64d-839c6fdf8238_1280x1601.gif" alt="PostgreSQL 101: The Everything Database"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/06c5ad46-faaf-479b-bde3-b5de8033b4e9_1280x1664.gif" alt="Top 12 Tips for API Security"&gt;&lt;/p&gt;
&lt;h2 id="bonus-3-interesting-images-from-designgurus"&gt;Bonus 3: Interesting images from &lt;a href="https://designgurus.io/" rel="noopener noreferrer"&gt;DesignGurus&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://www.designgurus.io/_next/image?url=https%3A%2F%2Fstorage.googleapis.com%2Fdownload%2Fstorage%2Fv1%2Fb%2Fdesigngurus-prod.appspot.com%2Fo%2Fee5726e8e29469477b999c100%3Fgeneration%3D1726724098184989%26alt%3Dmedia&amp;amp;w=3840&amp;amp;q=75&amp;amp;dpl=dpl_3Rx6M949Pc1cQKT3QTdj87FcKNdg" alt="System Design Master Template"&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></channel></rss>