<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>GRPC on miti99</title><link>https://miti99.com/en/tags/grpc/</link><description>Recent content in GRPC 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/grpc/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #76</title><link>https://miti99.com/en/post/2026/01/05/</link><pubDate>Mon, 05 Jan 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/01/05/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #76.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="tcp-vs-udp-vs-grpc-choosing-the-right-protocol-for-your-architecture"&gt;&lt;a href="https://designgurus.substack.com/p/an-engineers-guide-to-basic-networking" rel="noopener noreferrer"&gt;TCP vs. UDP vs. gRPC: Choosing the Right Protocol for Your Architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When you call a local function, data moves entirely within a single machine&amp;rsquo;s memory; modern software, however, constantly communicates with databases, APIs, and browsers halfway around the world. Network protocols are the rules governing data formats, how conversations are opened and closed, and how errors are handled. This article starts at the transport layer with its two pillars: TCP and UDP. TCP prioritizes reliability: before sending data, both sides perform a three-way handshake (&lt;code&gt;SYN&lt;/code&gt;, &lt;code&gt;SYN-ACK&lt;/code&gt;, &lt;code&gt;ACK&lt;/code&gt;); the protocol then guarantees that every byte arrives intact and in order, automatically retransmits lost packets, and uses flow control and congestion control to avoid overwhelming the receiver. That makes TCP ideal when accuracy matters more than raw speed, such as database queries, email, and web pages. UDP is the opposite: connectionless, no handshake, no packet numbering, and any packet dropped in transit is gone for good; in exchange, latency is minimal, making it a great fit for live video streaming or online gaming, where dropping a frame is far better than pausing to wait for an old one.&lt;/p&gt;
&lt;p&gt;At the application layer, HTTP follows a request–response model using methods like &lt;code&gt;GET&lt;/code&gt;, &lt;code&gt;POST&lt;/code&gt;, &lt;code&gt;PUT&lt;/code&gt;, and &lt;code&gt;DELETE&lt;/code&gt;, headers carrying metadata, and status codes like &lt;code&gt;200 OK&lt;/code&gt; or &lt;code&gt;404 Not Found&lt;/code&gt;. The HTTP version matters too: HTTP/1.1 processes requests one at a time per connection and suffers from head-of-line blocking when a slow resource holds up the entire page; HTTP/2 adds multiplexing so multiple requests and responses can run concurrently over a single TCP connection; and HTTP/3 drops TCP entirely in favor of QUIC (built on top of UDP) for better performance on lossy networks. Finally, WebSockets overcome HTTP&amp;rsquo;s unidirectional limitation: a connection begins as an HTTP request asking for an &amp;ldquo;upgrade&amp;rdquo; and then stays open so both client and server can push messages at any time without per-message header overhead—ideal for chat apps or live stock tickers that need low-latency bidirectional communication.&lt;/p&gt;
&lt;h2 id="software-engineering-in-2026"&gt;&lt;a href="https://benjamincongdon.me/blog/2025/12/29/Software-Engineering-in-2026/" rel="noopener noreferrer"&gt;Software Engineering in 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Congdon observes that the biggest impact of LLM tooling so far is a dramatic drop in the marginal cost—both in time and money—of producing high-quality code. Because writing code is only one part of software engineering, the bottleneck is shifting elsewhere. He breaks an engineer&amp;rsquo;s job down into building, evolving, and operating distributed systems: the first two have become much cheaper and easier thanks to LLMs, while operations remains largely untouched. The market will expect engineers to harness LLM productivity, making the profession feel more &amp;ldquo;industrialized&amp;rdquo; yet also higher-leverage. As a result, investments in solid infrastructure pay off faster than ever: metrics, logging, feature flags, deployments, autoscaling, and configuration should be self-service for both humans and LLMs via ergonomic CLIs or MCP-ready APIs. CI infrastructure also becomes more critical as AI agents write more code, potentially justifying investments in property-based testing and formal verification—and since LLMs don&amp;rsquo;t mind writing tests, there is no longer any excuse for poor test coverage.&lt;/p&gt;
&lt;p&gt;He emphasizes human-guided abstractions: without clear guardrails, LLMs fill in the blanks with greedy solutions just to get CI green, steadily degrading the codebase. Module boundaries, library interfaces, and contracts between infrastructure and product layers become the primary levers for maintaining long-term quality. Human code review also becomes a new bottleneck: style issues should be offloaded to automated linters so reviewers can focus on hard-to-reverse decisions like interface changes, data persistence, and performance-critical paths. This creates a paradox for junior engineers, who need to develop &amp;ldquo;review taste&amp;rdquo; earlier while writing less code by hand to build that intuition. Project estimation variance will also widen, since cost now depends heavily on how amenable a task is to LLM automation. On build-versus-buy, thin CRUD-style SaaS tools will increasingly tilt toward &amp;ldquo;build&amp;rdquo; at mid-to-large companies, whereas infrastructure and compliance SaaS will change much less because operational costs haven&amp;rsquo;t fallen like development costs have.&lt;/p&gt;
&lt;h2 id="reflections-on-2025"&gt;&lt;a href="https://samuelalbanie.substack.com/p/reflections-on-2025" rel="noopener noreferrer"&gt;Reflections on 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Samuel Albanie looks back on 2025 across three themes in his trademark witty style. First is &amp;ldquo;The Compute Theory of Everything&amp;rdquo;: in 2021, the handcrafted architectural inductive biases he painstakingly designed for computer vision at VGG (Oxford) were swept aside by a simpler system backed by massive pre-training compute. He revisits Hans Moravec&amp;rsquo;s 1976 argument that intelligence is not about magical symbolic manipulation, but raw processing power—&amp;ldquo;with enough thrust, anything flies.&amp;rdquo; Moravec noted that AI capability scales in lockstep with researchers&amp;rsquo; access to faster hardware; since upcoming hardware clusters will make 2025&amp;rsquo;s supercomputers look like pocket calculators, Albanie believes we are nowhere near hitting a ceiling. His second theme is model evaluation: AI systems are becoming increasingly general, while our benchmarks remain narrow. METR&amp;rsquo;s approach measures the duration of tasks models can complete compared to a skilled human, which jumped from roughly 5 minutes in early 2024 to 4 hours and 49 minutes with Claude Opus 4.5 in late 2025, even as the surface area needing evaluation has exploded from MNIST digit recognition to nearly the entire economy.&lt;/p&gt;
&lt;p&gt;His final theme, &amp;ldquo;Floreat Britannia,&amp;rdquo; examines the UK: real wages grew 33% per decade from 1970 to 2007 before stalling out, industrial electricity prices are the highest in Europe, the Hinkley Point C nuclear plant cost £46 billion, and an acoustic fish deterrent system alone cost roughly £700 million while projected to save just 0.083 salmon per year. In his view, the bottleneck is coordination and decision-making, and he is optimistic that AI will make high-quality probabilistic forecasting cheap and ubiquitous. Still, good forecasts are useless if the culture is paralyzed by risk aversion; invoking Benjamin Franklin flying a kite in a thunderstorm and inventing the lightning rod, he concludes that Britain needs both boldness and prudence—both the &amp;ldquo;kite&amp;rdquo; and the &amp;ldquo;lightning rod.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="8-predictions-for-2026-what-comes-next-in-ai"&gt;&lt;a href="https://www.philschmid.de/2026-predictions" rel="noopener noreferrer"&gt;8 Predictions for 2026. What comes next in AI?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philipp Schmid rarely writes prediction posts, but after a watershed 2025, he outlines eight AI trends for 2026. Generative UI will take off once code-generation latency and quality are good enough for apps to synthesize bespoke interfaces in real time tailored to each user&amp;rsquo;s task and preferences. Personal agents will move to the edge, powered by Small Language Models (SLMs) running locally on dedicated hardware. The smart home will finally deliver on its promise as assistants understand context and intent rather than rigid voice commands, blending into general assistants like the Gemini or ChatGPT apps. As traditional benchmarks saturate, AI labs will compete on &amp;ldquo;harnesses&amp;rdquo;—complex environments that prove agents can reliably execute multi-day workflows. Vibe coding will mature into real engineering: engineers will spend 99% of their time reviewing, evaluating, shaping ideas, and thinking, with the core skill being connecting implementation details, code quality, velocity, and business goals; knowing how to code becomes a distinct competitive advantage.&lt;/p&gt;
&lt;p&gt;His remaining three predictions revolve around social media: &amp;ldquo;AI slop&amp;rdquo; will turn human-created content into a premium market; every post on X, Instagram, or LinkedIn will be assumed AI-generated by default unless it carries a cryptographic signature under a &amp;ldquo;Human-Signed&amp;rdquo; metadata standard (like C2PA for cameras), with unsigned content downranked by algorithms as &amp;ldquo;synthetic noise&amp;rdquo;; and to fight agent spam, platforms will carve out a &amp;ldquo;verified human web&amp;rdquo; requiring biometric proof of personhood. In closing, he isn&amp;rsquo;t worried about the future of software engineers and believes learning to code is still well worth it, as deep technical understanding is more important than ever for steering these systems. His advice: build and learn—closely observe what others are building, dissect the &amp;ldquo;why&amp;rdquo; and &amp;ldquo;how,&amp;rdquo; and build your own version. Agents will remain center stage as successful patterns from coding agents spread to general-purpose agents that proactively anticipate needs rather than waiting for prompts.&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 #13</title><link>https://miti99.com/en/post/2025/04/22/</link><pubDate>Tue, 22 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/22/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #13.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="designing-a-distributed-id-generator"&gt;&lt;a href="https://siddharthsabron.in/blog/id-generator/" rel="noopener noreferrer"&gt;Designing a Distributed ID Generator&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article walks through building a 64-bit Snowflake-style distributed ID generator that produces unique IDs across nodes without relying on a centralized coordinator like a database &lt;code&gt;AUTO_INCREMENT&lt;/code&gt; sequence. First, the author explains why random strings (like UUIDv4) make poor primary keys in relational databases: string comparisons are slower than integer comparisons, indexes take up much more memory, and inserting random keys into a B-Tree causes frequent page splits, fragmentation, and poor cache locality. By contrast, time-ordered 64-bit integers keep indexes compact and append new rows cleanly near the right edge of the B-Tree.&lt;/p&gt;
&lt;p&gt;The core design packs three fields into a 64-bit integer: 41 bits for a millisecond timestamp relative to a custom epoch (good for ~69 years), 10 bits for the shard/machine ID (supporting up to 1,024 shards), and 12 bits for a per-millisecond sequence counter (allowing 4,096 IDs per millisecond per shard), combined using bitwise shifts and &lt;code&gt;OR&lt;/code&gt; operations. The author also candidly notes what needs to be hardened before taking the toy code to production, including handling sequence rollovers within the same millisecond, NTP clock drift, and automated shard ID assignment. It is a clear, practical read on why primary-key layout directly impacts database performance.&lt;/p&gt;
&lt;h2 id="3200-cpu-utilization"&gt;&lt;a href="https://josephmate.github.io/2025-02-26-3200p-cpu-util/" rel="noopener noreferrer"&gt;3,200% CPU Utilization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Joseph Mate recounts a production war story where a Java server spiked so hard that he could barely SSH into the box: CPU utilization hit 3,200%, pegging all 32 cores at 100%. Pulling a Java 17 thread dump—which includes per-thread CPU time—revealed dozens of threads stuck endlessly inside &lt;code&gt;TreeMap.put()&lt;/code&gt;. The culprit was an unsynchronized &lt;code&gt;TreeMap&lt;/code&gt; being mutated concurrently by multiple threads. Under a race condition during tree rebalancing, the internal red-black tree&amp;rsquo;s pointers became corrupted and formed a cycle, causing subsequent lookups and inserts to spin in an infinite loop. Crucially, the bug stayed hidden until &lt;code&gt;NullPointerException&lt;/code&gt;s thrown during concurrent corruption were silently swallowed by an executor thread pool without an uncaught exception handler (or inside a gRPC request handler), leaving the corrupted map live in memory with zero stack traces in the logs.&lt;/p&gt;
&lt;p&gt;The author reproduces the bug in a standalone test, compares how other languages handle concurrent map mutation, and outlines fixes—the simplest being wrapping the map in &lt;code&gt;Collections.synchronizedMap&lt;/code&gt; or switching to &lt;code&gt;ConcurrentSkipListMap&lt;/code&gt;. Beyond the immediate fix, he advocates defense-in-depth: alerting on unexpected NPEs, monitoring sustained CPU anomalies, always registering an &lt;code&gt;UncaughtExceptionHandler&lt;/code&gt; on thread pools, thorough code review, static analysis, and multithreaded stress tests. It&amp;rsquo;s a vivid reminder that data races don&amp;rsquo;t just corrupt state—they can take down an entire server.&lt;/p&gt;
&lt;h2 id="a-map-metaphor-for-architectural-diagrams"&gt;&lt;a href="https://www.giorgiosironi.com/2025/02/maps-metaphor-for-architectural-diagrams.html" rel="noopener noreferrer"&gt;A map metaphor for architectural diagrams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giorgio Sironi suggests thinking of software architecture diagrams as maps: the map is not the territory, and every model is &amp;ldquo;wrong&amp;rdquo; because it leaves out detail, yet it becomes useful precisely by highlighting the specific dimension needed for a given task. Just like a topographic map versus a subway map, each architectural diagram should focus on a single slice of concern. If a diagram constantly falls out of sync with the code, it is probably drawn at too low a level of abstraction.&lt;/p&gt;
&lt;p&gt;Sironi shares his experience maintaining a lightweight set of living &amp;ldquo;maps&amp;rdquo; on a digital whiteboard like Miro, using nothing more than boxes, arrows, sticky notes for open decisions, and color-coding for status. These living boards replace sprawling lists of Architectural Decision Records (ADRs)—which become hard to navigate once you have dozens of them—and differ from ADRs by being edited in place as the system evolves. His core set of maps covers system context (inspired by the C4 model), bounded contexts and their ubiquitous language, static module dependencies, testing strategy, observability pipelines, and technology radar choices. Crucially, the whole team owns and updates these maps together rather than treating them as the tech lead&amp;rsquo;s private artifact, consulting them whenever kicking off a new initiative.&lt;/p&gt;
&lt;h2 id="about"&gt;&lt;a href="https://tryingthings.wordpress.com/2025/02/28/about-developer-philosophy/" rel="noopener noreferrer"&gt;About &amp;ldquo;Developer philosophy&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sorin Costea shares his reflections on reading qntm&amp;rsquo;s &amp;ldquo;Developer philosophy&amp;rdquo; essay. He starts by asking whether there is still room for junior developers in the age of AI, empathizing with new grads struggling to land their first role and drawing parallels to the offshoring wave of the 2000s. On the topic of big-bang rewrites, while he agrees with qntm that the rot leading to a rewrite builds up over years, he argues that accumulated gaps can usually still be paid down incrementally. Full rewrites, he warns, are massive projects that inevitably slip their schedules—at which point &amp;ldquo;non-essential&amp;rdquo; requirements get cut to hit the deadline, birthing a brand-new pile of technical debt in the replacement system.&lt;/p&gt;
&lt;p&gt;In the second half, Costea offers pragmatic caveats on qntm&amp;rsquo;s other rules: automating best practices via linters only works once you have buy-in from the influential voices on the team; edge cases often only reveal themselves late in the game following the 80/20 rule; don&amp;rsquo;t expect a V2 rewrite to stay clean and simple for long; and even code that looks modular, testable, and &amp;ldquo;obviously correct&amp;rdquo; can still surprise you in production. It&amp;rsquo;s a grounded, slightly battle-weary counterpoint to the original essay.&lt;/p&gt;
&lt;h2 id="team-learning-session-surviving-legacy-code-by-jb-rainsberger"&gt;&lt;a href="https://www.giorgiosironi.com/2025/02/team-learning-session-surviving-legacy.html" rel="noopener noreferrer"&gt;Team learning session: surviving legacy code by J.B. Rainsberger&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giorgio Sironi describes how he runs a recurring team learning session built around J.B. Rainsberger&amp;rsquo;s &amp;ldquo;Surviving Legacy Code&amp;rdquo; kata. The fictional premise puts a TypeScript team in charge of maintaining a newly acquired, business-critical PHP codebase with no tests, cryptic logic, and nobody left who knows where the landmines are buried. The exercise targets three learning goals: characterizing and understanding unfamiliar legacy code, writing tests at multiple levels of granularity, and refactoring safely behind a safety net of tests—while also getting comfortable picking up an unfamiliar language and its ecosystem tooling (&lt;code&gt;Composer&lt;/code&gt;, &lt;code&gt;PHPUnit&lt;/code&gt;, &lt;code&gt;PHPStan&lt;/code&gt;, &lt;code&gt;PHP-CS-Fixer&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;The team works together in an ensemble (mob programming) format for an hour a week on a single shared screen against a deliberately awful toy repository. Their progression starts with running the code to see what it does, locking down existing behavior with a &lt;strong&gt;Golden Master&lt;/strong&gt; characterization test (controlling the random number generator seed so outputs are deterministic), and only then extracting smaller seams and writing fine-grained unit tests. Because the codebase is fictional and there is no delivery deadline, teammates feel safe saying &amp;ldquo;I don&amp;rsquo;t know&amp;rdquo; and experimenting aloud. Each session wraps up with a quick retrospective to capture takeaways and pick the next thread to pull.&lt;/p&gt;
&lt;h2 id="trimodal-nature-of-tech-compensation-in-the-us-uk-and-india"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/trimodal" rel="noopener noreferrer"&gt;Trimodal Nature of Tech Compensation in the US, UK and India&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz, author of &lt;em&gt;The Pragmatic Engineer&lt;/em&gt;, analyzes more than 20,000 compensation data points from Levels.fyi to test his &lt;strong&gt;trimodal compensation model&lt;/strong&gt; across the US, the UK, and India. Under this model, tech employers cluster into three distinct pay bands: &lt;strong&gt;Tier 1&lt;/strong&gt; (local market rate—the vast majority of companies), &lt;strong&gt;Tier 2&lt;/strong&gt; (Big Tech and regional leaders), and &lt;strong&gt;Tier 3&lt;/strong&gt; (top scaleups, elite quant trading firms, and hedge funds). In the US, Tier 2 and Tier 3 typically pay roughly double Tier 1 at both the median and 75th percentile for both entry-level and senior engineers, with significant overlap between Tier 2 and Tier 3 packages.&lt;/p&gt;
&lt;p&gt;The post breaks down top-paying companies in each tier by country and surfaces several striking patterns: hedge funds and quant firms don&amp;rsquo;t grant equity, but pay massive year-end cash bonuses that make them the only group paying higher pure cash compensation than Big Tech; in the UK, hedge funds and financial institutions dominate the very top of the market; and in India, top Tier 3 employers pay over ₹1 crore ($120K+) for senior engineers. Orosz also reminds readers that private &amp;ldquo;paper money&amp;rdquo; equity at pre-IPO scaleups can inflate headline numbers while carrying real liquidity risk. It is an essential read for calibrating your market value and career strategy.&lt;/p&gt;
&lt;h2 id="9-software-architecture-patterns-for-distributed-systems"&gt;&lt;a href="https://dev.to/somadevtoo/9-software-architecture-patterns-for-distributed-systems-2o86" rel="noopener noreferrer"&gt;9 Software Architecture Patterns for Distributed Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Soma provides a visual overview of nine fundamental architectural patterns for managing data flow and communication in distributed systems—topics that also come up constantly in system design interviews. The first five cover communication and state: &lt;strong&gt;Peer-to-Peer&lt;/strong&gt;, where nodes communicate directly without a central coordinator; &lt;strong&gt;API Gateway&lt;/strong&gt;, a single entry point handling authentication, rate limiting, and routing to backend services; &lt;strong&gt;Pub-Sub&lt;/strong&gt;, decoupling producers and consumers asynchronously through topics; &lt;strong&gt;Request-Response&lt;/strong&gt;, the classic synchronous client-server model; and &lt;strong&gt;Event Sourcing&lt;/strong&gt;, persisting every state transition as an immutable append-only log of events.&lt;/p&gt;
&lt;p&gt;The remaining four focus on data processing and workflow coordination: &lt;strong&gt;ETL&lt;/strong&gt; (Extract, Transform, Load) for moving data into analytical stores; &lt;strong&gt;Batching&lt;/strong&gt; for high-throughput periodic processing; &lt;strong&gt;Stream Processing&lt;/strong&gt; for continuous real-time event pipelines; and &lt;strong&gt;Orchestration&lt;/strong&gt;, where a central controller coordinates multi-step workflows across services. Each pattern is paired with a clear diagram and real-world use cases, making the post a handy quick-reference refresher before diving deeper into individual patterns.&lt;/p&gt;
&lt;h2 id="extending-java-apis---add-missing-features-without-the-hassle"&gt;&lt;a href="https://foojay.io/today/extending-java-apis-add-missing-features-without-the-hassle/" rel="noopener noreferrer"&gt;Extending Java APIs - Add Missing Features Without the Hassle&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shai Almog introduces the &lt;strong&gt;extension methods&lt;/strong&gt; feature of the Manifold compiler plugin, which lets you add missing methods to existing Java classes (like &lt;code&gt;String&lt;/code&gt; or &lt;code&gt;Collection&lt;/code&gt;) without waiting years for the JDK to add them. You simply create a class annotated with &lt;code&gt;@Extension&lt;/code&gt; inside a package whose name ends with the fully qualified name of the target class, and write &lt;code&gt;static&lt;/code&gt; methods whose first parameter is annotated with &lt;code&gt;@This&lt;/code&gt;. For example, you can add a &lt;code&gt;.map()&lt;/code&gt; method directly onto &lt;code&gt;Collection&lt;/code&gt; to skip the ceremony of calling &lt;code&gt;.stream().map(...).toList()&lt;/code&gt;. Under the hood, Manifold does not modify the bytecode of the target JDK class—instead, it rewrites call sites into static method calls at compile time with zero runtime wrapper overhead. And if a future JDK release adds a native method with the exact same signature, the real JDK method automatically takes precedence, keeping upgrades smooth.&lt;/p&gt;
&lt;p&gt;Manifold also ships with ready-made extension libraries for collections, &lt;code&gt;String&lt;/code&gt;, I/O, and JSON—bringing Kotlin-style helpers like &lt;code&gt;removePrefix()&lt;/code&gt;, &lt;code&gt;padStart()&lt;/code&gt;, and &lt;code&gt;isEmpty()&lt;/code&gt; on arrays straight to Java. Finally, the post showcases &lt;code&gt;@Structural&lt;/code&gt; interfaces, which bring TypeScript/Go-style structural typing to Java so unrelated classes like &lt;code&gt;String&lt;/code&gt; and &lt;code&gt;Collection&lt;/code&gt; can be treated polymorphically through a shared interface without modifying their class declarations.&lt;/p&gt;
&lt;h2 id="how-spring-boot-reloads-configuration-without-restart"&gt;&lt;a href="https://medium.com/@AlexanderObregon/how-spring-boot-reloads-configuration-without-restart-4d9dc9e8b926" rel="noopener noreferrer"&gt;How Spring Boot Reloads Configuration Without Restart&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexander Obregon explains how Spring Boot reloads configuration properties dynamically at runtime without restarting the JVM. By default, &lt;code&gt;@Value&lt;/code&gt; and &lt;code&gt;@ConfigurationProperties&lt;/code&gt; bindings are evaluated once at startup. To make them dynamic, applications typically pull configuration from Spring Cloud Config Server, annotate dynamic beans with &lt;code&gt;@RefreshScope&lt;/code&gt;, and trigger a reload by sending a POST request to Spring Boot Actuator&amp;rsquo;s &lt;code&gt;/actuator/refresh&lt;/code&gt; endpoint.&lt;/p&gt;
&lt;p&gt;The article looks under the hood at what happens when &lt;code&gt;/actuator/refresh&lt;/code&gt; is called: Spring publishes a &lt;code&gt;RefreshEvent&lt;/code&gt;; the &lt;code&gt;ConfigurableEnvironment&lt;/code&gt; re-fetches property sources from the external config server and diffs the changes; and any bean marked with &lt;code&gt;@RefreshScope&lt;/code&gt;—which Spring wraps in a CGLIB proxy at startup—has its cached target instance invalidated in the scope cache, forcing Spring to lazily re-instantiate the bean with the fresh property values on the very next method call. Properties injected into regular singleton beans outside &lt;code&gt;@RefreshScope&lt;/code&gt;, the author notes, will not update until a full restart. For multi-instance deployments, pairing Config Server with &lt;strong&gt;Spring Cloud Bus&lt;/strong&gt; over RabbitMQ or Kafka broadcasts the refresh event across every running instance simultaneously via &lt;code&gt;/actuator/bus-refresh&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="building-high-performance-rpc-services-with-grpc-and-spring-boot"&gt;&lt;a href="https://www.javacodegeeks.com/2025/03/building-high-performance-rpc-services-with-grpc-and-spring-boot.html" rel="noopener noreferrer"&gt;Building High-Performance RPC Services with gRPC and Spring Boot&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Eleftheria Drosopoulou walks through integrating gRPC into a Spring Boot application to build high-performance RPC services. Created by Google, gRPC uses HTTP/2 for transport and Protocol Buffers (Protobuf) as its interface definition language and binary serialization format. Thanks to compact binary payloads, HTTP/2 connection multiplexing, native bidirectional streaming, and strongly typed client/server code generation from &lt;code&gt;.proto&lt;/code&gt; schemas, gRPC is a strong fit for internal microservice-to-microservice communication. The article opens with a comparison table pitting gRPC against REST and WebSockets across transport protocol, payload format, performance, streaming support, and browser compatibility.&lt;/p&gt;
&lt;p&gt;The hands-on tutorial steps through adding &lt;code&gt;grpc-spring-boot-starter&lt;/code&gt;, defining a service contract in a &lt;code&gt;.proto&lt;/code&gt; file, configuring the Maven Protobuf plugin to generate Java stubs, implementing the server-side service class, and wiring up the gRPC server port. It wraps up with clear guidance on when to pick each protocol: gRPC for low-latency polyglot microservices and streaming RPCs, REST for public-facing CRUD APIs and direct browser clients, and WebSockets for stateful real-time browser push.&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/39f5b04d-ad39-4bbe-a32f-f47792d4ef62_2250x2682.png" alt="Latency and Partition Tolerance in Distributed Systems"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: 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=3Lis4w4_bBc" rel="noopener noreferrer"&gt;8 Most Important Tips for Designing Fault-Tolerant System&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>