<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Redis on miti99</title><link>https://miti99.com/en/tags/redis/</link><description>Recent content in Redis 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/redis/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #130</title><link>https://miti99.com/en/post/2026/09/08/</link><pubDate>Tue, 08 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #130.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-anthropic-runs-large-scale-code-migrations-with-claude-code"&gt;&lt;a href="https://claude.com/blog/ai-code-migration" rel="noopener noreferrer"&gt;How Anthropic runs large-scale code migrations with Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Migrating a large codebase to another language used to be a multi-year endeavor undertaken only as a last resort. Anthropic shows how that calculus has changed: Bun migrated one million lines of code from Zig to Rust in under two weeks, consuming roughly 5.9 billion input tokens and 690 million output tokens (around $165,000 at standard API pricing). In return, the entire existing test suite passed before merging (19 regressions surfaced afterward and were all fixed), the binary shrank by 19%, runtime performance improved by 2–5%, and one memory benchmark dropped from 6,745 MB to 609 MB. In another example, 165,000 lines of Python were migrated to TypeScript over a single weekend.&lt;/p&gt;
&lt;p&gt;The workflow follows six steps: author a translation rulebook alongside a dependency graph, pilot the rules on a sample batch of files, translate the codebase in parallel using worker agents, run a compilation loop pairing a fixer agent with an adversarial reviewer agent, run fast tests to catch runtime bugs, and finally verify behavioral parity against the original implementation. The core lesson is to fix the generation loop rather than hand-patching generated code: whenever a mistake repeats, update the rulebook and regenerate. Doing so requires an objective &amp;ldquo;oracle&amp;rdquo;—such as a compiler and test suite—up front, plus a resumable work queue. Compute spend should also be tiered deliberately: smaller models like Sonnet handle bulk translation, while larger models like Fable or Opus write the rulebook and perform adversarial reviews.&lt;/p&gt;
&lt;h2 id="the-vfs"&gt;&lt;a href="https://internals-for-interns.com/posts/linux-kernel-vfs/" rel="noopener noreferrer"&gt;The VFS&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Whether you read a file on ext4, a virtual file in &lt;code&gt;/proc&lt;/code&gt; that exists only in kernel memory, or a remote file over NFS, you use the exact same system calls and file descriptor semantics. The layer that makes this possible is the VFS (Virtual File System), sitting between the syscall interface and concrete filesystems. This article explains the VFS as a textbook application of &amp;ldquo;program to an interface, not an implementation&amp;rdquo;—where, in C, an interface is simply a struct of function pointers. Four core objects do the heavy lifting: a &lt;code&gt;superblock&lt;/code&gt; represents a mounted filesystem, an &lt;code&gt;inode&lt;/code&gt; represents an object within it (a file, directory, or link), a &lt;code&gt;dentry&lt;/code&gt; binds a name to an inode (since inodes themselves don&amp;rsquo;t know their own filenames), and a &lt;code&gt;file&lt;/code&gt; represents a specific open handle held by a process with its own read/write offset. The &lt;code&gt;super_operations&lt;/code&gt;, &lt;code&gt;inode_operations&lt;/code&gt;, and &lt;code&gt;file_operations&lt;/code&gt; tables hold filesystem-specific behaviors, falling back to generic VFS implementations whenever a hook is left unimplemented.&lt;/p&gt;
&lt;p&gt;In practice, most work is handled by shared VFS code before ever touching a filesystem driver. When resolving a path like &lt;code&gt;/etc/hostname&lt;/code&gt;, the kernel walks component by component and calls the filesystem&amp;rsquo;s &lt;code&gt;lookup&lt;/code&gt; hook only when the dentry cache (dcache) misses. That cache even remembers nonexistent paths (negative dentries) and is read locklessly via RCU. Reading file contents works similarly: most reads simply copy bytes out of the page cache without touching the disk, and a user-space file descriptor is nothing more than an index into the process&amp;rsquo;s &lt;code&gt;struct file *&lt;/code&gt; array.&lt;/p&gt;
&lt;h2 id="text-editor-data-structures"&gt;&lt;a href="https://cdacamar.github.io/data%20structures/algorithms/benchmarking/text%20editors/c&amp;#43;&amp;#43;/editor-data-structures/" rel="noopener noreferrer"&gt;Text Editor Data Structures&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When building a text editor from scratch, the first question is how to represent file contents in memory. Cameron DaCamara starts by laying out his requirements: fast insertions and deletions, fast undo/redo, UTF-8 support, and simultaneous multi-cursor editing. From there, he systematically eliminates candidates. A single contiguous string is simple to render, but bogs down on files over 1 MB, reallocations can turn $O(n)$ edits into $O(n^2)$, and snapshotting for undo/redo burns memory. Emacs-style gap buffers are simple but poorly suited to multiple cursors. Ropes give $O(\log n)$ operations, but copy-on-write overhead bloats memory usage. Traditional piece tables, once used in Microsoft Word, hit contiguous-array bottlenecks during long editing sessions. VS Code&amp;rsquo;s piece tree combines the strengths of ropes and piece tables by backing the piece table with a red-black tree.&lt;/p&gt;
&lt;p&gt;DaCamara takes that approach a step further by building an &lt;em&gt;immutable&lt;/em&gt; piece tree called &lt;code&gt;fredbuf&lt;/code&gt;. A purely functional red-black tree needs no parent pointers and allows cheap $O(1)$ snapshots at any point, turning undo and redo into two simple linked lists of tree roots. CRLF line-ending normalization is handled outside the tree, and a &lt;code&gt;TreeWalker&lt;/code&gt; abstraction simplifies character iteration and correctness testing. Two takeaways stand out: analyzing constraints up front saves wasted effort, and investing in debugging tools—like visual tree dumpers—is what gets a complex project across the finish line, especially when implementing notoriously tricky immutable red-black tree deletions. The library is MIT-licensed and requires only C++20.&lt;/p&gt;
&lt;h2 id="scaling-to-1-million-concurrent-sandboxes-in-seconds"&gt;&lt;a href="https://modal.com/blog/scaling-to-1-million-concurrent-sandboxes-in-seconds" rel="noopener noreferrer"&gt;Scaling to 1 million concurrent sandboxes in seconds&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Modal rewrote its entire sandbox control plane from the ground up and demonstrated the result with a striking milestone: spinning up one million concurrent sandboxes in under 60 seconds. Their previous architecture, much like Kubernetes, relied on strong consistency across the backend: every placement decision required global coordination, and database writes scaled linearly with sandbox count, making horizontal scaling impossible once demand reached millions of concurrent sandboxes and tens of thousands of creations per second.&lt;/p&gt;
&lt;p&gt;The new architecture embraces decentralization. Instead of a single serialized central scheduler, multiple scheduler servers run in parallel using load-balancing algorithms over in-memory state. Each worker node becomes the source of truth for its own sandboxes, periodically publishing state to Redis rather than writing synchronously to a central datastore, removing Postgres from the sandbox creation hot path entirely. RPC calls that previously scaled per sandbox are coalesced into batches. As a result, creating a sandbox takes just two network hops and a single CPU operation with zero central coordination, achieving a median startup time under 500 ms and scheduling latency of just a few tens of milliseconds. The multi-month effort began with an intense prototyping sprint by four engineers before reimplementing every feature, monitoring pipeline, and container runtime detail—including tracking down and fixing Linux kernel &lt;code&gt;rtnl&lt;/code&gt; lock contention when spinning up containers en masse.&lt;/p&gt;
&lt;h2 id="making-768-servers-look-like-1"&gt;&lt;a href="https://planetscale.com/blog/making-768-servers-look-like-1" rel="noopener noreferrer"&gt;Making 768 servers look like 1&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When an application has to serve millions of queries per second over petabytes of data, a single database server is no longer enough. PlanetScale outlines three fundamental walls in single-primary scaling: writes always funnel into one machine because the write-ahead log (WAL) is a serialization bottleneck regardless of how many read replicas you add; replicas duplicate the full dataset rather than dividing it; and backing up or restoring a massive monolithic database can take hours or days. The solution is horizontal sharding—splitting both data and queries across many independent primary servers. In the article&amp;rsquo;s example, one petabyte is split across 256 shards of roughly 4 TB each, with one primary and two replicas per shard, totaling 768 servers.&lt;/p&gt;
&lt;p&gt;To shield application developers from that complexity, a routing proxy layer sits between the app and the shards—Vitess for MySQL and Neki for Postgres. Unlike simple connection poolers such as PgBouncer, this router parses SQL queries, understands how data is distributed, plans and scatters queries to the right shards, and merges the results back together. The sharding topology is declared in JSON (a VSchema)—for instance, sharding the &lt;code&gt;user&lt;/code&gt; table by a hash of its &lt;code&gt;id&lt;/code&gt; column. Ultimately, the application connects to a single hostname like &lt;code&gt;mydb.pscale.com&lt;/code&gt;: DNS resolves to network load balancers that distribute connections across stateless query routers, and the application never knows 768 database servers are working behind the scenes.&lt;/p&gt;
&lt;h2 id="branchavoidant-programming"&gt;&lt;a href="https://easylang.online/blog/branchless" rel="noopener noreferrer"&gt;Branch‑Avoidant Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Modern CPUs speculate on which way branches will go to keep their instruction pipelines full; when a prediction is wrong, the pipeline must be flushed and refilled at a steep penalty. This article illustrates the cost by filtering numbers smaller than 500 out of a random array—a workload where the branch predictor is essentially guessing a coin flip. The trick is to eliminate the &lt;code&gt;if&lt;/code&gt; statement: unconditionally write the current number into the output slot, and conditionally advance the output index with &lt;code&gt;smlen += (numbers[i] &amp;lt; 500);&lt;/code&gt;. You perform extra writes, but they are far cheaper than branch mispredictions. Filtering 100,000 numbers 1,000 times on an Apple M1 takes 0.345 seconds with an &lt;code&gt;if&lt;/code&gt; branch versus just 0.036 seconds branchless—nearly 10x faster; on an Intel Xeon, it drops from 0.576 to 0.110 seconds. Inspecting the assembly shows why: conditional jump instructions like &lt;code&gt;b.gt&lt;/code&gt; (ARM) or &lt;code&gt;jg&lt;/code&gt; (x86) are replaced by predication instructions like &lt;code&gt;cinc&lt;/code&gt; or &lt;code&gt;setle&lt;/code&gt;, keeping control flow completely straight.&lt;/p&gt;
&lt;p&gt;Compilers don&amp;rsquo;t apply this transformation automatically because they don&amp;rsquo;t know the statistical distribution of your runtime data, nor can they safely assume that a conditional memory write is valid to execute unconditionally (since the destination buffer might only be sized for matching elements or could trigger a data race). Developers therefore have to write branchless loops deliberately when profiling calls for it. The author notes that quicksort partitioning is a prime candidate, as partitioning is fundamentally conditional data movement around a pivot.&lt;/p&gt;
&lt;h2 id="your-redis-leaderboard-is-probably-breaking-ties-wrong"&gt;&lt;a href="https://dev.to/trungdlp/your-redis-leaderboard-is-probably-breaking-ties-wrong-39k4" rel="noopener noreferrer"&gt;Your Redis Leaderboard Is Probably Breaking Ties Wrong&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Building a leaderboard with a Redis sorted set is a classic pattern, but few developers think about what happens when two players have the exact same score. By default, Redis breaks ties lexicographically by member string, meaning the player ID arbitrarily decides who ranks higher—deterministic, but meaningless to players. Common quick fixes have flaws of their own: millisecond timestamps collide under concurrency and suffer from clock skew across servers, while packing both score and timestamp into a single 64-bit IEEE 754 &lt;code&gt;double&lt;/code&gt; eats into the precision and safe range of both numbers.&lt;/p&gt;
&lt;p&gt;Podium, an open-source leaderboard service, implements a clean rule: whoever reaches a tied score first ranks higher. Each leaderboard maintains a monotonic counter initialized to the maximum signed 64-bit integer; whenever a player posts a new score, a Lua script decrements the counter and prepends that 19-digit number to the player&amp;rsquo;s public ID, ensuring earlier arrivals have a lexicographically larger prefix and sort ahead in descending queries. The script atomically updates four keys: the descending sorted set, an ascending sorted set (where counter digits are inverted so earlier arrivals still win ties), a hash mapping public IDs to internal member strings, and the counter itself. If a submitted score equals the player&amp;rsquo;s current score, their existing internal member name is preserved, making retries idempotent. The trade-off is roughly 11–17% higher write latency and 287 bytes per member instead of 99 bytes in local benchmarks—a reasonable price for fair, intuitive tie-breaking.&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 #92</title><link>https://miti99.com/en/post/2026/03/20/</link><pubDate>Fri, 20 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/20/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #92.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-i-became-good-at-leading-incidents"&gt;&lt;del&gt;&lt;a href="https://tomasztomczyk.com/blog/2026/how-i-became-good-at-leading-incidents/" rel="noopener noreferrer"&gt;How I became good at leading incidents&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;Tomasz Tomczyk shares lessons from leading more than 100 incidents over his career, emphasizing that incident management is not just a technical skill, but a blend of analytical thinking and leadership under pressure. He views every incident as an opportunity to deepen system understanding and build a culture that learns from failure.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;To handle incidents effectively, you need a solid grasp of your deployment pipeline and the entire tech stack from DNS up to the application layer, backed by comprehensive observability. When an incident hits, delegate investigation along clear tracks, make decisive calls when features need to be disabled, and communicate timely updates to stakeholders. Documenting recurring failure patterns in runbooks and practicing through chaos-engineering game days also prepares teams much better for real-world outages.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Key takeaways:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- Master the deployment pipeline and full tech stack to pinpoint root causes quickly&lt;/del&gt;
&lt;del&gt;- Read stack traces fluently and use error-tracking tools like Sentry for deeper investigation&lt;/del&gt;
&lt;del&gt;- Build a culture of psychological safety so failures become learning opportunities&lt;/del&gt;
&lt;del&gt;- Delegate investigation strategically and make decisive calls under pressure&lt;/del&gt;
&lt;del&gt;- Maintain runbooks and run game days to prepare for real incidents&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="decision-trees"&gt;&lt;a href="https://mlu-explain.github.io/decision-tree/" rel="noopener noreferrer"&gt;Decision Trees&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part of the interactive MLU-Explain series by Jared Wilber and Lucía Santamaría, this visual essay introduces decision trees from the ground up. It opens with an intuitive example: a farmer trying to tell apple, cherry, and oak trees apart using only trunk diameter and height. At each step, the algorithm searches for the best split—for instance, nearly every tree with a diameter of 0.45 or greater is an oak, making that condition the root node; the remaining data is recursively partitioned by height or diameter until each region contains mostly a single tree species. The result is a nested set of rules that any new data point can walk down to be classified.&lt;/p&gt;
&lt;p&gt;To pick each split, the ID3 algorithm favors the threshold that yields the highest &lt;em&gt;information gain&lt;/em&gt;—that is, the largest reduction in data entropy. Splitting too deeply, however, causes the tree to memorize noise in the training set rather than generalizable patterns, a classic illustration of the bias–variance trade-off leading to overfitting. Decision trees are easy to interpret, fast to train, require minimal preprocessing, and handle outliers well, but they are notoriously unstable: a tiny change in training data can produce a completely different tree structure. Pruning techniques—such as capping maximum depth or requiring a minimum number of samples per leaf—help keep overfitting in check.&lt;/p&gt;
&lt;h2 id="containers-are-not-a-security-boundary"&gt;&lt;del&gt;&lt;a href="https://www.lucavall.in/blog/containers-are-not-a-security-boundary" rel="noopener noreferrer"&gt;Containers Are Not a Security Boundary&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Drawing on Liz Rice&amp;rsquo;s book &lt;em&gt;Container Security&lt;/em&gt; and his own exploration of the Linux primitives underneath, Luca Cavallin reminds us that containers are not automatically secure. At bottom, a container is just a normal Linux process wrapped in a few isolation primitives: namespaces restrict what the process can see, and cgroups cap the resources it can consume, yet every container on a host shares the exact same Linux kernel. Consequently, kernel vulnerabilities, misconfigured mounts, overly broad capabilities like &lt;code&gt;CAP_SYS_ADMIN&lt;/code&gt;, or forgotten setuid binaries can all become privilege-escalation paths; simply &amp;ldquo;not running as root&amp;rdquo; isn&amp;rsquo;t enough. Classic principles like least privilege, defense in depth, attack-surface reduction, and blast-radius containment still apply in full.&lt;/p&gt;
&lt;p&gt;To harden containers, the author recommends filtering syscalls with seccomp, adding mandatory access control via AppArmor or SELinux, and using user namespaces to map root inside the container to an unprivileged user on the host. When stronger isolation is required—such as running untrusted code or multi-tenant workloads—teams can turn to gVisor, Kata Containers, Firecracker, or full virtual machines where each guest gets its own kernel. The post also emphasizes supply-chain security: treating the Dockerfile as an enforceable policy, using minimal base images, pinning image digests rather than mutable tags, separating build and runtime stages, signing images with Cosign, and having admission controllers reject unsigned or untrusted images before deployment.&lt;/p&gt;
&lt;h2 id="an-ode-to-bzip"&gt;&lt;a href="https://purplesyringa.moe/blog/an-ode-to-bzip/" rel="noopener noreferrer"&gt;An ode to bzip&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Purplesyringa needed to compress Lua source code for the ComputerCraft mod in Minecraft, where in-game floppy disk space is tight and the decompressor itself has to fit inside a tiny budget. Compressing a 327 KB Lua source bundle, &lt;code&gt;bzip2&lt;/code&gt; reached 63,727 bytes and &lt;code&gt;bzip3&lt;/code&gt; reached 61,067 bytes—beating &lt;code&gt;zopfli&lt;/code&gt;, &lt;code&gt;zstd&lt;/code&gt;, &lt;code&gt;xz&lt;/code&gt;, &lt;code&gt;brotli&lt;/code&gt;, and &lt;code&gt;lzip&lt;/code&gt; on that file. The secret lies in the algorithm: whereas most mainstream compressors are built on LZ77 (replacing repeated substrings with back-references to earlier occurrences), &lt;code&gt;bzip&lt;/code&gt; uses the Burrows–Wheeler Transform (BWT) to sort characters by their surrounding context. That clusters identical characters into long runs that compress exceptionally well with run-length encoding—making it a natural fit for structured text like source code.&lt;/p&gt;
&lt;p&gt;Because the BWT transform itself is deterministic while leaving room for simpler block-size and entropy-coding choices, even a stripped-down custom encoder achieves strong compression ratios. By dropping compatibility with the standard container format and using a single Huffman table, the author&amp;rsquo;s custom bzip-style decompressor came in at roughly 1.5 KB of code. &lt;code&gt;bzip&lt;/code&gt; is often dismissed as slow, but when you are compressing to squeeze under a hard size cap, the difference is between booting and not booting at all—and in a high-level interpreted language like Lua where every operation carries overhead anyway, &lt;code&gt;bzip&lt;/code&gt;&amp;rsquo;s speed disadvantage largely fades. The author concludes that while &lt;code&gt;bzip&lt;/code&gt; may no longer be the default general-purpose choice, it remains remarkably effective for text and source code.&lt;/p&gt;
&lt;h2 id="why-arm-is-becoming-the-cpu-foundation-for-ai-data-center-architecture"&gt;&lt;a href="https://newsroom.arm.com/blog/why-system-architects-default-to-arm-in-ai-data-centers" rel="noopener noreferrer"&gt;Why Arm is becoming the CPU foundation for AI data center architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Arm Newsroom piece argues that AI workloads are exposing the limits of traditional general-purpose server designs across power delivery, cooling, memory bandwidth, and system-level efficiency. As a result, data centers are shifting toward purpose-built rack-scale AI systems where the defining question is no longer raw peak FLOPS, but how effectively accelerators, CPUs, memory, networking, and software work together. Agentic AI sharpens this shift: agents plan, invoke tools, retrieve data, and loop continuously, creating 24/7 inference traffic. In that world, the CPU acts as the orchestration hub—handling scheduling, routing, I/O, networking, storage, and security so the accelerators stay fed.&lt;/p&gt;
&lt;p&gt;According to Arm, performance per watt has become the decisive metric because power availability and energy budgets are hard constraints. The post cites projections that nearly half of the compute capacity shipped to top hyperscalers by late 2025 is expected to be Arm-based, alongside benchmarks showing AWS Graviton4 (Neoverse) delivering stronger performance and price-performance than comparable AMD and Intel instances. New rack-scale architectures like the NVIDIA Vera Rubin NVL72—pairing 72 Rubin GPUs with 36 Arm-based Vera CPUs—and the AWS Trainium3 UltraServer with Graviton follow this exact blueprint. Arm also highlights software portability across hardware generations without rewriting application code.&lt;/p&gt;
&lt;h2 id="we-built-an-agent-skill-so-ai-writes-redis-code"&gt;&lt;a href="https://redis.io/blog/we-built-an-agent-skill-so-ai-writes-redis-code/" rel="noopener noreferrer"&gt;We built an Agent Skill so AI writes Redis code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Redis introduces an official Agent Skill—a markdown knowledge pack that AI coding agents like Claude Code, Cursor, Codex, and GitHub Copilot can load into context on demand with a single install command. The team noticed that AI-generated Redis code routinely suffers from three problems. First, models trained on older corpora write code as if Redis stopped at version 6, ignoring vector sets, native JSON, the query engine, and LangCache. Second, agents improvise fragile patterns instead of using battle-tested idioms—building rate limiters without sliding-window sorted sets, omitting cache-stampede protection, or forgetting pipelining. Third, models don&amp;rsquo;t warn you about what they don&amp;rsquo;t know, casually emitting blocking &lt;code&gt;KEYS *&lt;/code&gt; calls against million-key instances or stuffing large JSON blobs into plain strings instead of hashes.&lt;/p&gt;
&lt;p&gt;The skill supplies up-to-date reference patterns for caching, rate limiting, session stores, vector search, semantic caching, agent memory, pub/sub, and streams; decision guides for picking between hashes, JSON, sorted sets, and vector sets; guardrails against anti-patterns like &lt;code&gt;KEYS&lt;/code&gt; in loops or unbounded key growth; and production-ready defaults for connection pooling, pipelining, and cluster compatibility. As Anthropic&amp;rsquo;s team puts it, MCP gives agents tools, while Skills teach them how to use those tools well. Built on an open format, the skill loads only when relevant to keep context windows lean, can be versioned in Git, shared across teams, and composed with other skills.&lt;/p&gt;
&lt;h2 id="inside-the-archive-the-tech-behind-your-2025-wrapped-highlights"&gt;&lt;a href="https://engineering.atspotify.com/2026/3/inside-the-archive-2025-wrapped" rel="noopener noreferrer"&gt;Inside the Archive: The Tech Behind Your 2025 Wrapped Highlights&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spotify&amp;rsquo;s engineering team shares how they built the Wrapped Archive feature for 2025 Wrapped: for every eligible listener, the system selects up to five &amp;ldquo;memorable days&amp;rdquo; from the past year and uses an LLM to write personalized narrative recaps grounded strictly in the user&amp;rsquo;s actual listening history. Candidate days are picked by a prioritized set of heuristics—such as biggest listening day, most new artists discovered, or most unusual listening pattern. To generate roughly 1.4 billion stories across 350 million users at a sustainable cost, the team distilled a frontier model into a much smaller model using a carefully curated &amp;ldquo;golden&amp;rdquo; dataset, then aligned it further with Direct Preference Optimization (DPO) from human evaluations. The batch pipeline ran continuously for four days at thousands of requests per second.&lt;/p&gt;
&lt;p&gt;On the storage side, each memorable day was written to its own column in a column-oriented key-value store, so concurrent writes for the same user never collided or required locks or read-modify-write cycles. Because Wrapped launches globally all at once, the team pre-scaled infrastructure and ran full load tests across every region hours ahead of launch. Quality was guarded by an LLM-as-a-judge pipeline that scored roughly 165,000 sampled stories for factual accuracy, safety, tone, and formatting—which caught a timezone bug in the data pipeline that was shifting dates in generated stories, letting the team fix and regenerate the affected batch before launch. Their biggest takeaway: at this scale, calling the LLM is the easy part; capacity planning and automated safety loops are where the real engineering lives.&lt;/p&gt;
&lt;h2 id="managing-multiple-agents"&gt;&lt;a href="https://fffej.substack.com/p/managing-multiple-agents" rel="noopener noreferrer"&gt;Managing Multiple Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jeff explores what happens when you apply classic human management styles to multi-agent AI orchestration through a playful simulation: four &amp;ldquo;minions&amp;rdquo; assembling an Ikea Billy bookcase—Kevin reading the manual, Stuart fetching parts, Bob assembling, and Dave running quality checks—all powered by the open-weights &lt;code&gt;gpt-oss:20b&lt;/code&gt; model. Under &lt;em&gt;Command and Control&lt;/em&gt;, every action had to be approved by the coordinator, burning through messages and moving at a crawl. &lt;em&gt;Taylorism&lt;/em&gt; broke the job into rigid, standardized micro-steps, running much faster but stripping the agents of any autonomy to adapt.&lt;/p&gt;
&lt;p&gt;In the simulation, &lt;em&gt;management by outcomes&lt;/em&gt;—stating the goal alongside a work-in-progress (WIP) limit—won handily, finishing five times faster than Command and Control and three times faster than Taylorism. Most delightfully, Stuart noticed on his own that assembly had become the bottleneck and jumped in to help Bob without being told. By contrast, &lt;em&gt;total autonomy&lt;/em&gt; with no constraints still got the bookcase built, but devolved into chaos with agents duplicating each other&amp;rsquo;s work—echoing Kent Beck&amp;rsquo;s line that &amp;ldquo;autonomy without constraints is chaos.&amp;rdquo; The author concludes that orchestrating AI agents mirrors managing people: less capable agents need tight scaffolding, while capable agents perform best when given clear goals and constraints and left to figure out the rest.&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 #35</title><link>https://miti99.com/en/post/2025/07/24/</link><pubDate>Thu, 24 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #35.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-magic-of-software-or-what-makes-a-good-engineer-also-makes-a-good-engineering-organization"&gt;&lt;a href="https://moxie.org/2024/09/23/a-good-engineer.html" rel="noopener noreferrer"&gt;The magic of software; or, what makes a good engineer also makes a good engineering organization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Moxie Marlinspike argues that software development sits at the intersection of science and engineering, where product vision and technical understanding shape each other rather than flowing one way from idea to implementation. His classic example is &amp;ldquo;color cycling&amp;rdquo; animation in 1980s games: it didn&amp;rsquo;t come from a top-down spec, but emerged because programmers understood indexed-color palettes deeply enough to use them in a way nobody had anticipated. In his view, a great engineer stays curious, refuses to treat abstraction layers as black boxes, and lets that deep understanding unlock new product possibilities.&lt;/p&gt;
&lt;p&gt;The same principle applies to an entire engineering organization. When teams operate in silos and treat each other as black boxes, the organization loses the end-to-end visibility needed to pull off major shifts—Marlinspike points to Skype&amp;rsquo;s struggles transitioning to mobile as an example. He also warns against cargo-culting the org charts of big tech companies, since many succeeded despite their current structure rather than because of it. The takeaway: both individual engineers and organizations need to cultivate curiosity and encourage understanding across team boundaries instead of walling knowledge off into compartments.&lt;/p&gt;
&lt;h2 id="redis-is-open-source-again-but-is-it-too-late"&gt;&lt;a href="https://blog.abhimanyu-saharan.com/posts/redis-is-open-source-again-but-is-it-too-late" rel="noopener noreferrer"&gt;Redis Is Open Source Again. But Is It Too Late?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In March 2024, Redis dropped its BSD license in favor of dual RSALv2/SSPLv1 licensing to stop cloud providers from selling managed Redis without contributing back. The move sparked immediate backlash: Amazon and Google backed Valkey, a Linux Foundation-hosted fork of Redis 7.2.4, and distributions like Arch Linux switched over to Valkey completely. With Redis 8, the company reversed course and added AGPLv3—a genuine copyleft open-source license—helped in part by the return of creator Salvatore Sanfilippo. Redis 8 folds in JSON, time series, and probabilistic data structures that previously lived in separate modules, and adds a beta &lt;code&gt;vector set&lt;/code&gt; type for similarity search.&lt;/p&gt;
&lt;p&gt;Even so, the author argues that broken trust is hard to repair: &amp;ldquo;Trust is built over years and lost in a moment.&amp;rdquo; Many teams have already migrated their infrastructure to Valkey, which continues to gain momentum with strong enterprise backing, and Redis Ltd.&amp;rsquo;s decision to keep RSALv2 and SSPLv1 alongside AGPLv3 in a tri-license model leaves parts of the community skeptical of its long-term commitment. The practical verdict: teams already on Valkey have little reason to switch back, while for brand-new projects Redis 8 is once again a contender worth weighing.&lt;/p&gt;
&lt;h2 id="write-the-most-clever-code-you-possibly-can"&gt;&lt;a href="https://buttondown.com/hillelwayne/archive/write-the-most-clever-code-you-possibly-can" rel="noopener noreferrer"&gt;Write the most clever code you possibly can&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hillel Wayne offers a counterintuitive piece of advice: write the cleverest code you possibly can—as deliberate practice, not for production. By &amp;ldquo;clever,&amp;rdquo; he means reaching for unfamiliar language features or domain concepts. Practicing this way pays off in four ways: combining powerful features teaches you how they interact; mastering unfamiliar concepts deepens your grasp of the language; you build fluency for the rare moments when performance or tooling constraints genuinely demand a tricky solution; and sharing non-production &amp;ldquo;cursed&amp;rdquo; snippets is a fun way to bond with teammates.&lt;/p&gt;
&lt;p&gt;The key is separating practice from production code, where clarity and maintainability still come first. Wayne suggests three responsible outlets: solve a problem both ways and commit only the simple version, go wild in personal scripts and tools, or if a clever solution really is markedly better in production, document it thoroughly. His examples span Python pattern matching, JavaScript function composition, and pandas data transformations, and he points out that many idioms once dismissed as &amp;ldquo;too clever&amp;rdquo;—like list comprehensions—are simply standard language features used well.&lt;/p&gt;
&lt;h2 id="semantic-unit-testing"&gt;&lt;a href="https://www.alexmolas.com/2025/04/09/semantic-unit-testing.html" rel="noopener noreferrer"&gt;Semantic Unit Testing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Semantic unit testing is the idea of using a large language model (LLM) to check whether a function&amp;rsquo;s implementation matches the behavior described in its docstring, rather than writing traditional input/output assertions. The author&amp;rsquo;s hypothesis is that a capable enough model, given sufficient context, can spot bugs without executing the code. His Python library &lt;code&gt;suite&lt;/code&gt; uses the &lt;code&gt;inspect&lt;/code&gt; module to extract a function&amp;rsquo;s source code and docstring, recursively collects internal helper functions up to a configurable depth, bundles everything into a structured prompt for an LLM, and returns a pass/fail verdict with reasoning. In the example below, &lt;code&gt;multiply&lt;/code&gt; actually performs addition—and the model flags the mismatch between docstring and implementation.&lt;/p&gt;
&lt;p&gt;This approach adds a semantic review layer, integrates with pytest, supports async execution, and can run against local models to avoid sending proprietary code to external APIs. Still, the author is upfront about its limits: LLMs hallucinate and cannot be trusted blindly, token costs can get steep (a single pandas method consumed roughly 112k tokens), and traditional tests remain far more reliable. Semantic unit testing should therefore be treated strictly as a complement to, never a replacement for, standard unit tests.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;span class="lnt"&gt;4
&lt;/span&gt;&lt;span class="lnt"&gt;5
&lt;/span&gt;&lt;span class="lnt"&gt;6
&lt;/span&gt;&lt;span class="lnt"&gt;7
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-python" data-lang="python"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;multiply&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;int&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;int&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;int&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="s2"&gt;&amp;#34;&amp;#34;&amp;#34;Multiply x and y&amp;#34;&amp;#34;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="c1"&gt;# Intentionally buggy implementation&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;tester&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;suite&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;model_name&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;&amp;#34;openai/o3-mini&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;tester&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;multiply&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# LLM detects that the implementation does not match the docstring&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;h2 id="solid-principles-in-java-with-real-life-examples"&gt;&lt;a href="https://dev.to/chhavirana/understanding-solid-principles-in-java-with-real-life-examples-1ked" rel="noopener noreferrer"&gt;SOLID Principles in Java (With Real life Examples)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SOLID is a set of five object-oriented design principles for keeping code understandable, flexible, and maintainable; this post walks through each one using a Java food-ordering system. For Single Responsibility, instead of a single &lt;code&gt;OrderService&lt;/code&gt; that handles order placement, invoicing, and notifications all at once, the responsibilities are split across &lt;code&gt;OrderService&lt;/code&gt;, &lt;code&gt;InvoiceService&lt;/code&gt;, and &lt;code&gt;NotificationService&lt;/code&gt;. For Open/Closed, instead of a &lt;code&gt;PaymentService&lt;/code&gt; packed with &lt;code&gt;if/else&lt;/code&gt; branches for every payment type, a &lt;code&gt;PaymentMethod&lt;/code&gt; interface is implemented by &lt;code&gt;CardPayment&lt;/code&gt;, &lt;code&gt;UpiPayment&lt;/code&gt;, and others so new payment methods can be added without modifying existing code. For Liskov Substitution, an abstract &lt;code&gt;DeliveryMode&lt;/code&gt; class has &lt;code&gt;BikeDelivery&lt;/code&gt; and &lt;code&gt;ScooterDelivery&lt;/code&gt; subclasses that honor the parent contract and can be swapped cleanly without surprises.&lt;/p&gt;
&lt;p&gt;For Interface Segregation, rather than forcing every restaurant to implement a giant &lt;code&gt;RestaurantPartner&lt;/code&gt; interface covering orders, nutrition info, and customer feedback, the design splits it into &lt;code&gt;OrderAcceptance&lt;/code&gt;, &lt;code&gt;FeedbackHandler&lt;/code&gt;, and &lt;code&gt;NutritionInfoProvider&lt;/code&gt; so a small stall only implements what applies to it. Finally, Dependency Inversion is shown with &lt;code&gt;OrderNotifier&lt;/code&gt; depending on an abstract &lt;code&gt;Notifier&lt;/code&gt; interface instead of a concrete &lt;code&gt;EmailService&lt;/code&gt;, making it trivial to swap in &lt;code&gt;SmsService&lt;/code&gt; or another channel. The takeaway: SOLID isn&amp;rsquo;t just textbook theory—it&amp;rsquo;s a practical toolkit for writing clean code that adapts easily to new requirements.&lt;/p&gt;
&lt;h2 id="a-year-on-valkey-charts-path-to-v9-after-break-from-redis"&gt;&lt;a href="https://www.theregister.com/software/2025/05/15/a-year-on-valkey-charts-path-to-v9-after-break-from-redis/852499" rel="noopener noreferrer"&gt;A year on, Valkey charts path to v9 after break from Redis&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;One year after forking from Redis over its controversial license change, Valkey is showing strong momentum. Madelyn Olson, principal engineer at AWS and Valkey co-maintainer who helped lead the exodus from Redis, notes that the project just shipped version 8.1. Earlier, version 8.0 added per-slot metrics to improve cluster observability—a feature former Redis leadership had previously passed over. Rather than releasing an 8.2, the team is heading straight to version 9 to take on more invasive architectural changes. On support lifecycles, every release receives at least three years of support, while the final minor release of each major version gets five years, matching enterprise expectations for long-term stability.&lt;/p&gt;
&lt;p&gt;Olson emphasizes keeping Valkey &amp;ldquo;not a single-vendor project&amp;rdquo; by expanding its maintainer ranks and Technical Steering Committee, with contributors like Percona&amp;rsquo;s Ricardo Dias now working on it full time. She admits burning out during the first six months and believes spreading responsibility across organizations will keep the project sustainable. Valkey also collects no telemetry, relying instead on direct feedback from users and managed-service providers. Valkey&amp;rsquo;s trajectory shows how an open-source fork can thrive when backed by open governance and genuine multi-company community investment.&lt;/p&gt;
&lt;h2 id="stack-overflow-is-almost-dead"&gt;&lt;a href="https://blog.pragmaticengineer.com/stack-overflow-is-almost-dead" rel="noopener noreferrer"&gt;Stack Overflow is almost dead&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Stack Overflow, once an everyday destination for millions of developers, is in steep decline: according to data from the site&amp;rsquo;s own Data Explorer, monthly question volume in May 2025 fell back to levels last seen at its 2009 launch. The slide happened in stages. Starting around 2014, better moderation tooling led to faster question closures and mass deletions of &amp;ldquo;low-quality&amp;rdquo; posts, leaving many users—especially newcomers—feeling unwelcome. The 2020 pandemic briefly boosted traffic as newly remote developers searched online instead of asking coworkers at the next desk, but the downward trend resumed soon after—two full years before ChatGPT launched, pointing to deeper structural issues. In 2021, Prosus acquired Stack Overflow.&lt;/p&gt;
&lt;p&gt;The decisive blow arrived with ChatGPT in November 2022: question volume plunged as large language models offered faster, friendlier, and—in the author&amp;rsquo;s view—comparably accurate answers, ironically trained on Stack Overflow&amp;rsquo;s own archive. Orosz suggests the question is no longer whether the decline will continue, but when the site will wind down or be sold at a steep discount. Even so, developers&amp;rsquo; need to help each other won&amp;rsquo;t disappear—it will simply move to Discord servers, group chats, and new community platforms.&lt;/p&gt;
&lt;h2 id="why-i-use-webassembly"&gt;&lt;a href="https://nasso.dev/blog/why-i-use-wasm" rel="noopener noreferrer"&gt;Why I use WebAssembly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author shares why he reaches for WebAssembly (WASM), starting with the most compelling reason: it dramatically simplifies application state management. When computation runs directly on the user&amp;rsquo;s machine, the app doesn&amp;rsquo;t need to constantly talk to a backend server to track progress, eliminating complex polling or streaming setups. WASM also lets teams reuse battle-tested native code: Figma compiled its C++ vector graphics renderer to WASM and cut load times by 3x, while running FFmpeg in the browser enables completely offline media conversion without uploading files anywhere.&lt;/p&gt;
&lt;p&gt;More importantly, the author views WASM as a &amp;ldquo;universal binary format&amp;rdquo; for sharing core logic across platforms—making the web just one more target alongside desktop. His own project, Nema Studio, a Digital Audio Workstation, shares the same core engine between its native and web builds. That powers a two-tier product strategy: casual users can try the web version with 80–90% of features right in their browser, while serious users download the full native app. Because &amp;ldquo;nobody starts out as a power user,&amp;rdquo; the web build removes installation friction and acts as a funnel into the native application. He also gives a nod to Tauri as a lighter alternative to Electron thanks to using the OS webview instead of bundling Chromium.&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 #9</title><link>https://miti99.com/en/post/2025/04/01/</link><pubDate>Tue, 01 Apr 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/04/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #9.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="to-avoid-being-replaced-by-llms-do-what-they-can"&gt;&lt;a href="https://www.seangoedecke.com/what-llms-cant-do/" rel="noopener noreferrer"&gt;To avoid being replaced by LLMs, do what they can&amp;rsquo;t&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke offers career advice for software engineers facing a future where large language models (LLMs) keep getting better at writing code, broken down across three time horizons. In the short term, lean heavily into AI tools, understand how language models work under the hood so you can get staffed on AI projects, and push for promotion—since junior roles are the most likely to be automated first. The author expects this phase to last at least five years, because large enterprises simply don&amp;rsquo;t move that fast.&lt;/p&gt;
&lt;p&gt;In the medium term, he advises diving into sprawling legacy codebases inside large organizations. LLMs currently shine at competitive programming, where problems are self-contained, well-specified, easy to verify, and only a few hundred lines long; building features inside a decade-old enterprise system is the exact opposite: ambiguous requirements, messy verification, and millions of lines of code. Conquering that will require solving massive-context reasoning and building better evals against proprietary data locked inside company firewalls. Over the long run, the one thing LLMs cannot replace is accountability: engineers are trusted because they have skin in the game when things go wrong, whereas an LLM has nothing to lose. Companies will always need at least one human engineer in the loop to supervise the models and turn their plans into commitments the business can rely on.&lt;/p&gt;
&lt;h2 id="how-instagram-scaled-its-infrastructure-to-support-a-billion-users"&gt;&lt;a href="https://blog.bytebytego.com/p/how-instagram-scaled-its-infrastructure" rel="noopener noreferrer"&gt;How Instagram Scaled Its Infrastructure To Support a Billion Users&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This ByteByteGo article traces how Instagram scaled its infrastructure from a 13-person photo-sharing app running on AWS to a platform serving over a billion users. In the early days, the team had to manually spin up extra servers before every weekend, the database was constantly overwhelmed, and neither monitoring nor load balancing was automated. After being acquired by Facebook, Instagram migrated into Facebook&amp;rsquo;s data centers and scaled along three axes: scaling horizontally (adding servers and data centers), squeezing more performance out of each machine (batching queries, aggressive caching, and rewriting CPU-heavy Python functions in C++), and scaling the engineering organization through continuous deployment exceeding 40 production pushes a day.&lt;/p&gt;
&lt;p&gt;Architecturally, Django handles web requests, RabbitMQ and Celery process asynchronous background jobs like push notifications, PostgreSQL stores structured relational data requiring strong consistency, Cassandra handles distributed workloads like feeds and activity logs, Memcached serves as the caching tier, and Facebook&amp;rsquo;s Haystack stores photos and videos. One notable technique is the &lt;strong&gt;Memcache Lease&lt;/strong&gt; mechanism to prevent thundering herds: when a cached item expires, only the first app server granted a &amp;ldquo;lease&amp;rdquo; token is allowed to query the database, while other servers wait briefly or serve slightly stale data. Their deployment pipeline combines code review, automated tests, canary rollouts on a small subset of machines, and per-function CPU profiling in production.&lt;/p&gt;
&lt;h2 id="the-state-of-scala--clojure-surveys"&gt;&lt;a href="https://www.jvm-weekly.com/p/the-state-of-scala-and-clojure-surveys" rel="noopener noreferrer"&gt;The State of Scala &amp;amp; Clojure Surveys&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Artur Skowronski (JVM Weekly) examines two recent community surveys covering Scala and Clojure. VirtusLab&amp;rsquo;s late-2024 Scala Survey of 232 respondents found that while 93.1% like or love Scala, the average project age is now seven years—meaning most Scala work happens on legacy systems. The most popular ecosystems are Typelevel (41.8%), Akka (35.3%), and ZIO (23.3%), with 53% of projects mixing multiple stacks, and only 22.4% of commercial codebases have migrated fully to Scala 3. The top three pain points are slow compile times, ecosystem fragmentation complicating the Scala 3 upgrade, and a shortage of resources to maintain older libraries. Hiring is another sore spot: 56.5% don&amp;rsquo;t know where to find Scala developers and 23.2% of companies are considering migrating to Kotlin, Rust, or Go—even though 88.4% of respondents would still pick Scala for a greenfield project.&lt;/p&gt;
&lt;p&gt;On the Clojure side, the 2024 State of Clojure survey shows 73% of respondents using the language professionally, primarily for web development and enterprise backends; 58% have upgraded to Clojure 1.12 and 54% run on Java 21 LTS. A highlight this year is the growing ecosystem of Clojure dialects: Babashka is widely loved for fast scripting without JVM startup overhead, and ClojureDart brings Clojure to the Dart/Flutter ecosystem for web and mobile, alongside experimental compilers like Squint, Jank, and Cherry. For newcomers, the steepest learning curve remains grokking macros and homoiconicity.&lt;/p&gt;
&lt;h2 id="linkedin-integrates-protocol-buffers-with-restli-for-improved-microservices-performance"&gt;&lt;a href="https://www.linkedin.com/blog/engineering/infrastructure/linkedin-integrates-protocol-buffers-with-rest-li-for-improved-m" rel="noopener noreferrer"&gt;LinkedIn Integrates Protocol Buffers With Rest.li for Improved Microservices Performance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Karthik Ramgopal and Aman Gupta share how LinkedIn replaced JSON with Protocol Buffers (Protobuf) as the default serialization format for Rest.li, their open-source REST framework powering over 50,000 production API endpoints. While JSON is human-readable and universally supported, its text-based representation produces bulky payloads that consume extra bandwidth and make serialization and deserialization a major CPU bottleneck. After benchmarking alternatives including FlatBuffers, Cap&amp;rsquo;n Proto, MessagePack, CBOR, and Kryo, the team chose Protobuf for the best overall balance of compact payload size, serialization speed, and broad language support across LinkedIn&amp;rsquo;s stack.&lt;/p&gt;
&lt;p&gt;The catch was that Rest.li&amp;rsquo;s PDL schema language lacks the explicit numeric field tags that Protobuf requires. The team solved this with a bidirectional &lt;strong&gt;symbol table&lt;/strong&gt; mapping field names to integer IDs: services generate their symbol table at startup and clients fetch and cache it dynamically, while for web and mobile clients the table is generated at build time in an append-only manner. Rollout was controlled incrementally via client-side configuration. Across production, average throughput improved by 6.25% for responses and 1.77% for requests, latency dropped by up to 60% for services with large payloads, and no service saw a meaningful regression. LinkedIn&amp;rsquo;s next step is gradually migrating from Rest.li to gRPC.&lt;/p&gt;
&lt;h2 id="story-redis-and-its-creator-antirez"&gt;&lt;a href="https://blog.brachiosoft.com/en/posts/redis/" rel="noopener noreferrer"&gt;Story: Redis and its creator antirez&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Brachiosoft profile traces the journey of Salvatore Sanfilippo (antirez), the creator of Redis. Growing up in Sicily, antirez got his start on a TI-99/4A home computer at age six, learning BASIC alongside his father. After setting programming aside during his teenage years, he returned to it around age 18–19, taught himself C, and discovered a security flaw in the &lt;code&gt;ping&lt;/code&gt; utility. His post on the Bugtraq mailing list landed him a job offer at Milan security firm SECLAB, where he invented the Idle Scan port-scanning technique and wrote the &lt;code&gt;hping&lt;/code&gt; tool before moving back to Sicily six months later.&lt;/p&gt;
&lt;p&gt;Redis grew out of LLOOGG, a real-time web analytics tool antirez launched in 2007. Because MySQL couldn&amp;rsquo;t keep up with the disk I/O of real-time per-visit list updates, he prototyped an in-memory list database in Tcl called LMDB, rewrote it in C, and released Redis in 2009. The initial reception on Hacker News was lukewarm, but Redis quickly won pivotal early adopters: GitHub used it to build the Resque background job queue, Instagram built its early storage layer almost entirely on Redis, and Twitter repeatedly flew antirez out to their headquarters to help architect their timeline cache. VMware later hired him to work on Redis full-time, followed by stints at Pivotal and Redis Labs. In 2020, after more than a decade at the helm, antirez stepped down as maintainer, worn out by the constant tension between keeping the codebase crafted like a work of art and meeting the practical demands of a massive global user base.&lt;/p&gt;
&lt;h2 id="tracing-structured-logging-but-better-in-every-way"&gt;&lt;a href="https://andydote.co.uk/2023/09/19/tracing-is-better/" rel="noopener noreferrer"&gt;Tracing: structured logging, but better in every way&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andy Dote explains why he believes distributed tracing beats structured logging in every way, and shows how to migrate incrementally from logs to traces. Log levels (debug, info, warning…), he argues, are largely meaningless; free-text messages force slow full-text searches; log output gets interleaved with stdout; individual log lines lack causal relationships; and timing measurements have to be wired up manually and inconsistently. Traces solve all of these: every span automatically records a start time, end time, and duration, maintains parent-child hierarchy, propagates across service boundaries for distributed tracing, and makes it trivial to plot latency distributions or answer negative queries like &amp;ldquo;which requests did &lt;em&gt;not&lt;/em&gt; find the user in the cache?&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The hands-on walkthrough takes a small Go service using OpenTelemetry through three steps: adding a tracer and opening a span in each function, wrapping errors so status codes and error events are recorded on the active span, and replacing log lines with filterable span attributes—turning &lt;code&gt;&amp;quot;found user in cache&amp;quot;&lt;/code&gt; into &lt;code&gt;user_in_cache: true&lt;/code&gt;. The resulting code is only a few lines longer while capturing far richer telemetry. For loops, the author recommends extracting the loop body into a helper function with its own child span or recording aggregate counts after the loop to avoid overwriting span attributes, adopting Observability-Driven Development, and viewing traces in tools like Honeycomb or Lightstep.&lt;/p&gt;
&lt;h2 id="software-engineering-job-openings-hit-five-year-low"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/software-engineering-job-openings" rel="noopener noreferrer"&gt;Software engineering job openings hit five-year low?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz analyzes Indeed job-posting data showing that US software engineering openings currently sit at just 65% of their January 2020 baseline—down 3.5x from their mid-2022 peak and 8% lower than a year ago. Similar drops appear across Canada, the UK, France, and Germany, with Australia the lone market still above 2020 levels. Even more striking, while total job postings across all sectors on Indeed are up 10% compared to 2020, software development postings have fallen 34%—a much steeper drop than marketing (-19%), sales (-8%), or banking and finance (-7%).&lt;/p&gt;
&lt;p&gt;The author points to several overlapping drivers: rising interest rates ending the zero-interest-rate policy (ZIRP) era and drying up venture capital; companies still digesting the overhiring binge of 2021–2022; enterprises taking a &amp;ldquo;wait and see&amp;rdquo; approach to headcount while evaluating GenAI productivity gains (such as Salesforce freezing engineering hiring after reporting a 30% AI productivity boost); and lean teams proving how much a small group can ship—like Linear with 25 engineers or Bluesky with 13. He notes that Indeed skews toward traditional enterprises and may undercount startups and Big Tech. Looking ahead, he sketches a few scenarios: smaller, higher-leverage teams spawning a wave of new startups; platforms that turn plain-English specs into working apps; or a surge of AI-generated apps built by non-programmers eventually creating &lt;em&gt;more&lt;/em&gt; demand for professional engineers to scale and maintain them.&lt;/p&gt;
&lt;h2 id="we-switched-from-java-to-go-and-don"&gt;&lt;a href="https://glasskube.dev/blog/from-java-to-go/" rel="noopener noreferrer"&gt;We switched from Java to Go and don&amp;rsquo;t regret it&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philip Miglinci from Glasskube shares why his team switched from Java/Kotlin to Go. Despite years of experience with Java and Spring, while building Kubernetes tooling they noticed that other Kubernetes operators—mostly written in Go—used next to no resources, whereas their Kotlin-based operator and its supporting stack consumed over 2 GB of RAM even when completely idle. That prompted them to rewrite their open-source package manager in Go, and later choose Go for Distr, their open-source software distribution platform and first full Go web application.&lt;/p&gt;
&lt;p&gt;The post compares the two ecosystems across several dimensions. Java relies on JIT compilation and supports incremental builds and hot reloading, but Gradle and Maven are memory-hungry; Go compiles AOT into a single static binary, with a lightweight Spring Boot app taking roughly 8.2 seconds to start compared to under 100 milliseconds for a Go server. Java favors batteries-included frameworks like Spring or Quarkus, whereas Go prefers small, composable libraries with less &amp;ldquo;black magic,&amp;rdquo; eschewing Spring-style annotation-driven dependency injection in favor of explicit constructor or function arguments (keeping &lt;code&gt;context.Context&lt;/code&gt; strictly for deadlines, cancellation signals, and request-scoped values). Debugging and IDE support are roughly on par—though Java stack traces are easier to follow—and GoReleaser shines for release automation. The author concludes that Go is a natural fit for cloud-native and Kubernetes tooling, even if Java remains a strong choice for other domains.&lt;/p&gt;
&lt;h2 id="secure-java-applications-a-deep-look-into-3-different-issues"&gt;&lt;a href="https://developers.redhat.com/articles/2024/11/18/secure-java-applications-deep-look-3-different-issues" rel="noopener noreferrer"&gt;Secure Java applications: A deep look into 3 different issues&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martin Balao Alonso (Red Hat) examines three classes of vulnerabilities that can compromise data confidentiality, integrity, or availability in Java applications. The first is &lt;strong&gt;integer overflow&lt;/strong&gt;: &lt;code&gt;byte&lt;/code&gt;, &lt;code&gt;short&lt;/code&gt;, &lt;code&gt;int&lt;/code&gt;, and &lt;code&gt;long&lt;/code&gt; use signed two&amp;rsquo;s-complement representation. While &lt;code&gt;javac&lt;/code&gt; catches certain out-of-range literal assignments without an explicit cast, arithmetic operations silently wrap around according to the language specification. Using &lt;code&gt;Math::xxxExact&lt;/code&gt; methods or &lt;code&gt;BigInteger&lt;/code&gt; helps detect overflow immediately or compute with arbitrary-precision integers.&lt;/p&gt;
&lt;p&gt;The second issue is &lt;strong&gt;untrusted input driving resource allocation&lt;/strong&gt;: if a server pre-allocates a buffer based directly on a length field declared in an incoming message header, an attacker can trigger an &lt;code&gt;OutOfMemoryError&lt;/code&gt; at almost zero cost; defenses include allocating memory incrementally as bytes arrive and capping concurrent connections per client. The third is &lt;strong&gt;timing attacks&lt;/strong&gt; involving the JVM interpreter and JIT compiler: security-sensitive code must run in constant time regardless of secret values, yet even a simple byte-by-byte array comparison takes different execution paths depending on where a mismatch occurs—and an attacker can even manipulate the C2 JIT compiler&amp;rsquo;s branch profiling statistics to trigger a deoptimization trap that leaks secret information through timing differences. The author recommends constant-time bitwise operations like XOR for secret comparisons and carefully inspecting the native machine code emitted by the JIT.&lt;/p&gt;
&lt;h2 id="java-devs-rejoice-this-open-source-secret-weapon-will-cut-your-coding-time-in-half"&gt;&lt;a href="https://www.indiehackers.com/post/java-devs-rejoice-this-open-source-secret-weapon-will-cut-your-coding-time-in-half-a7869a56de" rel="noopener noreferrer"&gt;Java Devs Rejoice! This Open-Source Secret Weapon Will Cut Your Coding Time in Half&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Brett Hoffman introduces &lt;strong&gt;esProc SPL&lt;/strong&gt;, an open-source data processing language written entirely in Java. The post opens with a familiar dilemma: writing structured data manipulation logic in plain Java is verbose (even grouping and aggregating by two fields takes dozens of lines of boilerplate), while SQL is concise but tightly coupled to a relational database, making it hard to scale independently or run outside the DB. Java 8 Streams, Kotlin, and Scala tried to bridge the gap but still fall short of SQL&amp;rsquo;s expressiveness—and because Java is compiled, every logic change requires a full rebuild and redeploy.&lt;/p&gt;
&lt;p&gt;According to the author, SPL solves both problems: its syntax is as concise as SQL—and often shorter for complex order-dependent calculations, like computing the longest streak of consecutive price increases for a stock in a single line—while running independently of any database; it comes with a dedicated IDE supporting step-by-step debugging and visual data inspection; it handles both in-memory and out-of-core datasets larger than RAM, enabling parallel execution simply by adding an &lt;code&gt;@m&lt;/code&gt; flag. SPL embeds directly into Java applications via a standard JDBC driver, is lightweight enough to run on Android or act as a compute engine inside microservices, joins data seamlessly across heterogeneous sources (databases, REST APIs, CSVs, JSON), and—because it is interpreted—supports hot-swapping business logic on the fly without restarting the service.&lt;/p&gt;
&lt;h2 id="bonus-interesting-videos-from-inside-java"&gt;Bonus: Interesting videos from &lt;a href="https://inside.java/" rel="noopener noreferrer"&gt;Inside Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://inside.java/2025/02/15/devoxxbelgium-gc-progress/" rel="noopener noreferrer"&gt;Garbage Collection in Java - The progress since JDK 8&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><item><title>Newsletter #6</title><link>https://miti99.com/en/post/2025/03/08/</link><pubDate>Sat, 08 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/08/</guid><description>&lt;i&gt;
Happy International Women's Day (March 8)! Wishing all the ladies a wonderful day, and may you always stay joyful and happy!
Girls are meant to be loved :&gt;
Welcome to Newsletter #6.
&lt;/i&gt;
&lt;h2 id="how-i-use-llms-as-a-staff-engineer"&gt;&lt;a href="https://www.seangoedecke.com/how-i-use-llms/" rel="noopener noreferrer"&gt;How I use LLMs as a staff engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke, a staff engineer at GitHub, shares how he actually uses large language models (LLMs) in his day-to-day work. For production code, he uses Copilot primarily as a supercharged autocomplete for repetitive boilerplate like function arguments or type definitions; in his core stack (Ruby on Rails), he is still faster and better writing the logic himself. When making small changes in unfamiliar territory—such as a Go service or a C library—he leans on LLMs much more, asking questions like &amp;ldquo;is this idiomatic for this language?&amp;rdquo;, while always having a domain expert review the result. For throwaway code, like one-off research scripts running on his laptop, he lets the LLM write nearly everything and estimates it makes him 2–4x faster.&lt;/p&gt;
&lt;p&gt;In his view, the biggest value comes from using LLMs as an on-demand tutor when learning a new domain: asking follow-up questions, summarizing what he just learned in his own words, and asking the model to point out any misconceptions. He also uses LLMs as a last-resort rubber duck for debugging (asking once and moving on if it doesn&amp;rsquo;t help) and for proofreading long design documents for typos and logical gaps. Conversely, he never lets an LLM write an entire pull request in a codebase he knows well, never lets it draft ADRs or high-stakes technical strategy docs, and hasn&amp;rsquo;t found it useful yet for navigating massive codebases.&lt;/p&gt;
&lt;h2 id="software-development-topics-i"&gt;&lt;a href="https://chriskiehl.com/article/thoughts-after-10-years" rel="noopener noreferrer"&gt;Software development topics I&amp;rsquo;ve changed my mind on after 10 years in the industry&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chris Kiehl, a software engineer at Amazon, looks back on ten years in the industry through three short lists, following up on a similar post he wrote four years earlier. Things he has changed his mind on include: simplicity doesn&amp;rsquo;t happen by accident—it requires constant cultivation; there is no badge of honor in being able to juggle complexity; static typing is essential on teams with mixed skill levels; Java is great precisely because it is boring; most of the real work of programming should happen before writing the first line of code; &amp;ldquo;elegance&amp;rdquo; is a mirage; a great manager is worth their weight in gold; and DynamoDB is genuinely great when your access patterns match what it is built for.&lt;/p&gt;
&lt;p&gt;He also adds several new convictions: software engineering is mostly communication; thinking a problem is easy usually means you don&amp;rsquo;t understand it yet; junior engineers need room to try things and fail; you should avoid ORMs and write SQL directly; you will eventually regret building a system on Serverless Functions; distributed locking remains bafflingly hard; and test code can never have too many comments. Views he still holds: code coverage says nothing about test quality, monoliths are fine, microservices must be justified rather than chosen by default, and almost nobody needs &amp;ldquo;scale&amp;rdquo; the way they think they do.&lt;/p&gt;
&lt;h2 id="looking-under-the-lamppost-on-problem-solving"&gt;&lt;a href="https://edbatista.com/2025/01/looking-under-the-lamppost-on-problem-solving.html" rel="noopener noreferrer"&gt;Looking Under the Lamppost (On Problem-Solving)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ed Batista opens with the classic joke about a man searching for his lost keys under a streetlamp even though he dropped them in the dark yard, simply because &amp;ldquo;the light is better here.&amp;rdquo; That, Batista argues, is how we routinely approach problem-solving: instead of tackling the problem we &lt;em&gt;need&lt;/em&gt; to solve, we pick the problem we &lt;em&gt;want&lt;/em&gt; to solve. The reasons are all too human: the real problem lies outside our expertise; it takes too long when we crave the quick dopamine hit of crossing small tasks off a list; or it might not have an answer at all, exposing us to failure and embarrassment.&lt;/p&gt;
&lt;p&gt;The author doesn&amp;rsquo;t suggest beating yourself up over this tendency, but warns that if we only ever pick small, tractable problems we&amp;rsquo;re guaranteed to solve, we never grow—our comfort zone only expands when we step outside it. He draws a distinction between confidence (a calculation of your odds of success) and courage (recognizing that the cost of not trying outweighs the cost of failing). When we reframe failure as learning—or &amp;ldquo;eliminating possibilities,&amp;rdquo; as Peter Attia puts it—we realize that staying under the streetlamp is the real risk, because the answers to the problems that actually matter are out there in the dark.&lt;/p&gt;
&lt;h2 id="sliding-window-log-rate-limiter-redis--java"&gt;&lt;a href="https://foojay.io/today/sliding-window-log-rate-limiter-redis-java/" rel="noopener noreferrer"&gt;Sliding Window Log Rate Limiter (Redis &amp;amp; Java)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raphael De Lio walks through building a Sliding Window Log rate limiter using Redis and Java. Unlike the Fixed Window Counter, which slices time into rigid intervals, this algorithm logs the timestamp of every request and counts only those falling within a rolling window (such as the last second or minute), enforcing a smooth limit without sudden resets at window boundaries. Starting in Redis 7.4, the &lt;code&gt;HEXPIRE&lt;/code&gt; command allows setting a TTL on individual fields within a hash, which makes the implementation remarkably clean: each client gets its own hash, every allowed request is stored as a field that expires automatically after the window duration, and &lt;code&gt;HLEN&lt;/code&gt; returns the current count of active requests; if the count has reached the threshold, the new request is rejected.&lt;/p&gt;
&lt;p&gt;The Java implementation uses Jedis, wrapping &lt;code&gt;HSET&lt;/code&gt; and &lt;code&gt;HEXPIRE&lt;/code&gt; inside a transaction so they execute together and save network round-trips—though because the &lt;code&gt;HLEN&lt;/code&gt; read and threshold check happen outside the transaction, concurrent requests can still race past the check; each field key uses a random UUID so multiple requests arriving in the same millisecond don&amp;rsquo;t overwrite one another. Finally, the author writes a test suite using Redis TestContainers, JUnit 5, and AssertJ covering requests within the limit, exceeding the limit, window expiration roll-off, and concurrent access from multiple clients.&lt;/p&gt;
&lt;h2 id="project-loom-structured-concurrency--java"&gt;&lt;a href="https://foojay.io/today/project-loom-structured-concurrency-java/" rel="noopener noreferrer"&gt;Project Loom: Structured Concurrency – Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mahendra Rao B introduces Structured Concurrency, a Project Loom feature that debuted as an incubator API in Java 19 (JEP 428) and advanced to preview in Java 21 (JEP 453) and Java 23 (JEP 480). The core idea is that when a task splits into concurrent subtasks, they all return to the same lexical scope—the parent task waits until its child subtasks complete, preserving a clear parent-child hierarchy and eliminating common bugs around cancellation, thread leaks, and shutdown. Before diving into the API, the post reviews foundational concepts including processes, threads, synchronization, deadlocks, and semaphores.&lt;/p&gt;
&lt;p&gt;At the center of the API is &lt;code&gt;StructuredTaskScope&lt;/code&gt; in &lt;code&gt;java.util.concurrent&lt;/code&gt;: you open a scope in a &lt;code&gt;try-with-resources&lt;/code&gt; block, spawn subtasks with &lt;code&gt;fork&lt;/code&gt;, wait for completion with &lt;code&gt;join&lt;/code&gt;, and handle the results. Two built-in policies are provided as subclasses: &lt;code&gt;ShutdownOnSuccess&lt;/code&gt; (cancels remaining subtasks as soon as one succeeds, ideal when you only need the first result) and &lt;code&gt;ShutdownOnFailure&lt;/code&gt; (cancels all subtasks if any one fails); you can also subclass &lt;code&gt;StructuredTaskScope&lt;/code&gt; to define custom completion policies. For debugging, running &lt;code&gt;jcmd &amp;lt;PID&amp;gt; Thread.dump_to_file -format=json &amp;lt;file&amp;gt;&lt;/code&gt; exports a structured JSON thread dump showing the task hierarchy. The main benefits are simpler lifecycle management, consistent error handling, automatic resource cleanup, and no orphaned background threads.&lt;/p&gt;
&lt;h2 id="taking-out-the-trash-in-java"&gt;&lt;a href="https://medium.com/@benweidig/taking-out-the-trash-in-java-19bcc0c7bd0c" rel="noopener noreferrer"&gt;Taking Out the Trash in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ben Weidig provides an overview of garbage collection (GC) on the JVM: rather than requiring manual memory allocation and deallocation like C or C++, the JVM automatically tracks down unreachable objects and reclaims their memory—though that convenience isn&amp;rsquo;t free and directly impacts application performance. The article explains how the heap stores objects and is organized around the weak generational hypothesis into the Young Generation (Eden plus two Survivor spaces) and the Old Generation, alongside Metaspace (which replaced PermGen in Java 8), while each thread has its own stack for method call frames. Minor GCs are fast and barely noticeable, whereas major GCs can trigger significant &amp;ldquo;stop-the-world&amp;rdquo; pauses.&lt;/p&gt;
&lt;p&gt;Next, the author compares the available JVM collectors: Serial for single-threaded or resource-constrained environments, Parallel for maximum throughput, G1 (the default in modern JDKs) which divides the heap into regions, ZGC and Shenandoah for ultra-low pause times at the cost of higher CPU usage, and Epsilon—a no-op collector used primarily for benchmarking and allocation testing. The closing section offers practical guidance: cut down on unnecessary object allocations, pick appropriate data structures, use &lt;code&gt;try-with-resources&lt;/code&gt;, enable GC logging, and profile with tools like VisualVM or JDK Mission Control before tweaking heap sizes and JVM flags.&lt;/p&gt;
&lt;h2 id="how-precision-time-protocol-handles-leap-seconds"&gt;&lt;a href="https://engineering.fb.com/2025/02/03/production-engineering/how-precision-time-protocol-ptp-handles-leap-seconds/" rel="noopener noreferrer"&gt;How Precision Time Protocol handles leap seconds&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Meta explains how they handle leap seconds as Precision Time Protocol (PTP) increasingly replaces NTP for time synchronization across their data centers. With NTP, which synchronizes clocks at the millisecond level, Meta historically used &amp;ldquo;leap smearing&amp;rdquo;—gradually slowing down or speeding up the clock over a window using a linear or quadratic curve to absorb the extra second. However, PTP synchronizes clocks down to the nanosecond level, where even linear smearing introduces unacceptable drift between servers.&lt;/p&gt;
&lt;p&gt;Meta&amp;rsquo;s solution is to perform leap smearing inside their client-side &lt;code&gt;fbclock&lt;/code&gt; library: whenever called during a smearing window, the library shifts the returned timestamp using a stateless, reproducible algorithm, keeping the underlying time service on monotonic TAI internally while still exposing smeared UTC to client applications. Even so, this approach introduces noticeable divergence—drifting by more than 100 microseconds relative to quadratic-smeared NTP sources and shifting a 60-second periodic timer by nearly 1 millisecond during the smear window. Because of these trade-offs, Meta recommends using TAI instead of UTC wherever possible (even though conversion to UTC is still unavoidable at system boundaries) and backs the international proposal to retire leap seconds after 2035 so the industry can rely on continuous UTC and simplify timekeeping infrastructure.&lt;/p&gt;
&lt;h2 id="developer-philosophy"&gt;&lt;a href="https://qntm.org/devphilo" rel="noopener noreferrer"&gt;Developer philosophy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;qntm, a science fiction author and software engineer, writes down the software development philosophy he shared in a talk for junior developers. His number-one rule is to never let a project deteriorate to the point where a rewrite from scratch looks tempting—because by the time you reach that point, the real mistakes happened long ago; watch out for early warning signs like mounting technical debt, simple changes taking longer and longer, painful onboarding for new teammates, and mysterious bugs nobody understands. He also advises aiming to finish 90% of the work in 50% of the allotted time, since getting the happy path working is only half the battle—the rest goes to polish, edge cases, testing, and performance tuning.&lt;/p&gt;
&lt;p&gt;Other core principles include: automating good habits through tests, linters, and auto-formatters instead of relying on manual nagging; always thinking about &amp;ldquo;pathological data&amp;rdquo; like requests that hang forever, billion-row tables, or empty strings, because handling edge cases is the essence of the job; using leftover time to make code simpler; writing testable code with clean interfaces and minimal side effects; and finding the right balance between microservices and a monolith, splitting services only when there is a clear payoff. Finally, code shouldn&amp;rsquo;t just be theoretically correct—it should be &lt;em&gt;obviously&lt;/em&gt; correct, so that modifying surrounding code months later doesn&amp;rsquo;t turn into a minefield.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="bonus-1-interesting-videos-from-bytebytego"&gt;Bonus 1: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=QEzbZKtLi-g" rel="noopener noreferrer"&gt;System Design: Why Is Docker Important?&lt;/a&gt;&lt;/p&gt;
&lt;h3 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus 2: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fc4c9cac-3046-4b45-9dd8-7dccc79b4e2c_1280x1608.gif" alt="JWT 101: Key to Stateless Authentication"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #4</title><link>https://miti99.com/en/post/2025/02/27/</link><pubDate>Thu, 27 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/27/</guid><description>&lt;i&gt;
Hello everyone, I found quite a lot of articles last week, and cramming them all into a single issue would have made it way too long. So today I'm posting an extra mid-week newsletter ^^.
&lt;/i&gt;
&lt;h2 id="management-mantras"&gt;&lt;a href="https://blog.staysaasy.com/p/management-mantras" rel="noopener noreferrer"&gt;Management Mantras&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on the Stay SaaSy blog distills four mantras for engineering managers. The first is &amp;ldquo;don&amp;rsquo;t do anyone any favors&amp;rdquo;: everyone at a company should be working on the highest-priority thing they can do, so when someone says &amp;ldquo;let me do you a favor,&amp;rdquo; it&amp;rsquo;s usually either already their job, a broken process, or a subversion of priorities. That leads directly to the second mantra: employees don&amp;rsquo;t need charity. Whatever the company provides to employees is either compensation they have earned or a core responsibility of management—so when you tell a report they got a raise and they thank you, tell them &amp;ldquo;don&amp;rsquo;t thank me, you earned it.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The third mantra is &amp;ldquo;I can fix it.&amp;rdquo; The larger a company grows, the easier it is to point fingers elsewhere. At good companies, if every project you touch fails, the burden is on you to prove it wasn&amp;rsquo;t your fault; managers must coach their teams to take ownership of anything blocking their results. Finally, management is an everyday job: most of the work consists of uncomfortable tasks like pushing people to do better, resolving conflicts, and delivering tough feedback. A manager&amp;rsquo;s value lies in changing behavior, and that comes from the compounding effect of small daily nudges and coaching moments rather than a few dramatic decisions a year.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-programming-languages-choosing-the-right-tool-for-the-job"&gt;&lt;a href="https://dev.to/mohammad-reza-mahdiani/the-ultimate-guide-to-programming-languages-choosing-the-right-tool-for-the-job-4be2" rel="noopener noreferrer"&gt;The Ultimate Guide to Programming Languages: Choosing the Right Tool for the Job&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DEV Community article surveys five popular programming languages in 2025 along with their strengths and trade-offs. Python is easy to learn and boasts a rich ecosystem for machine learning, data science, web development, and automation, though it is slower than compiled languages and poorly suited for mobile apps. JavaScript remains the &amp;ldquo;king of the web&amp;rdquo;: running natively in browsers, on servers via Node.js, and across platforms with Electron or React Native, at the cost of dynamic typing pitfalls at runtime. Java is the enterprise workhorse thanks to the JVM, stability, and scalability, despite verbose syntax and slower startup for small apps. C++ excels at raw performance and hardware control—ideal for game engines, embedded systems, and simulations—but has a steep learning curve and manual memory management. Rust is the rising star offering memory safety without a garbage collector, well suited for systems programming, WebAssembly, and cryptography, though its ecosystem is still smaller.&lt;/p&gt;
&lt;p&gt;Looking at broader trends, Python still leads in machine learning even as Julia gains ground in high-performance numerical computing; Solidity and Rust stand out in blockchain development; and Kotlin Multiplatform and Flutter (Dart) are popular for unifying mobile, web, and desktop development. The author&amp;rsquo;s conclusion: there is no silver-bullet language, and the right choice depends on project requirements, team expertise, and long-term goals.&lt;/p&gt;
&lt;h2 id="discovery-coding"&gt;&lt;a href="http://jimmyhmiller.com/discovery-coding" rel="noopener noreferrer"&gt;Discovery Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jimmy Miller borrows a familiar distinction from fiction writing: some writers outline everything in advance, while others discover the story in the act of writing. He calls the programming equivalent &amp;ldquo;Discovery Coding&amp;rdquo;—understanding a problem by writing code first rather than designing everything up front. A discovery coder asks what the new code needs to accomplish and how different parts of the system interact, and only by writing code and feeling where the system &amp;ldquo;pushes back&amp;rdquo; do they chart a path forward. This style is easily dismissed as messy, especially in a culture that prizes static type systems and rigid upfront constraints, but the author stresses separating the creative process from the finished artifact: discovery coders can still produce clean, rigorous code once they understand the problem.&lt;/p&gt;
&lt;p&gt;Even natural outliners can benefit from this approach: because you don&amp;rsquo;t walk in with a pre-baked solution, exploratory coding helps you avoid forcing a familiar pattern onto a new problem and loads the system&amp;rsquo;s real constraints into your head. Tools that support live programming against a running system (like Clojure or Smalltalk) and instant visual feedback are especially helpful here. The post closes with a call to accept that programmers think in different ways: a less tidy process doesn&amp;rsquo;t mean a worse outcome, and software design is ultimately a human activity.&lt;/p&gt;
&lt;h2 id="building-a-best-selling-game-with-a-tiny-team"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/thronefall" rel="noopener noreferrer"&gt;Building a best-selling game with a tiny team&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This episode of The Pragmatic Engineer Podcast features Jonas Tyroller, one of the two developers behind &lt;em&gt;Thronefall&lt;/em&gt;, a minimalist strategy game blending tower defense and kingdom building that sold roughly one million copies in its first year. Jonas built the game using Unity, C#, and Blender, structuring each level as a scene populated with scripted game objects. Surprisingly, the duo did no code reviews, wrote no unit tests, and pushed straight to &lt;code&gt;main&lt;/code&gt;: for a small, ship-once game built by two experienced developers, those practices weren&amp;rsquo;t worth the overhead, even if they matter on larger teams. Bugs were caught primarily through constant playtesting, beta testing, and post-launch player feedback.&lt;/p&gt;
&lt;p&gt;Their workflow started with rapid prototyping—spending just 1–2 days per prototype and prioritizing gameplay feel before visuals—to find an idea that was both commercially viable and fun for them to build. The biggest technical challenge was unit pathfinding: they bought an off-the-shelf A* plugin and customized it so troop movement felt natural. Jonas also used ChatGPT to generate boilerplate code, translate shader code, and get up to speed on unfamiliar topics. Key takeaways: indie game development demands wearing many hats—from design and programming to music composition and marketing; the way to get good at making games is to make lots of them; and with Unity and today&amp;rsquo;s wealth of tutorials, getting started has never been more accessible.&lt;/p&gt;
&lt;h2 id="serving-a-billion-web-requests-with-boring-code"&gt;&lt;a href="https://notes.billmill.org/blog/2024/06/Serving_a_billion_web_requests_with_boring_code.html" rel="noopener noreferrer"&gt;Serving a billion web requests with boring code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bill Mill recounts designing the backend API system for the US government&amp;rsquo;s Medicare Plan Finder, where millions of Americans compare and enroll in health insurance plans. The system serves around 5 million requests a day with an average latency under 10 milliseconds, totaling well over a billion requests. Guided by the &amp;ldquo;Choose Boring Technology&amp;rdquo; philosophy, the team picked PostgreSQL, Go, and React. Their only two architectural bets were splitting the backend into three coarse-grained services (&lt;code&gt;druginfo&lt;/code&gt;, &lt;code&gt;planinfo&lt;/code&gt;, &lt;code&gt;beneinfo&lt;/code&gt;), each with its own database, and using gRPC for inter-service communication. While gRPC provided code-defined interfaces, its tooling proved clunky and the author admits they probably would have been better off without it; on the flip side, &lt;code&gt;grpc-gateway&lt;/code&gt; served over a billion requests without a single outage.&lt;/p&gt;
&lt;p&gt;Several other decisions leaned heavily into simplicity: enforcing strict backward compatibility (only adding fields, never removing them), building multi-criteria search by concatenating SQL strings inside a single long but thoroughly commented function instead of standing up Elasticsearch, and rebuilding the databases from scratch every day via a shell-script-and-cron ETL pipeline that used PostgreSQL&amp;rsquo;s &lt;code&gt;COPY&lt;/code&gt; command to load over 250 million rows. The author&amp;rsquo;s biggest regret was writing brittle SQL-mock unit tests that were painful to maintain instead of testing against a real database instance. The takeaway: high-quality, resilient software can absolutely be built within the constraints of government contracting.&lt;/p&gt;
&lt;h2 id="java-language-evolution-in-2025---inside-java-newscast-84"&gt;&lt;a href="https://www.youtube.com/watch?v=dPzle3EN4CM" rel="noopener noreferrer"&gt;Java Language Evolution in 2025 - Inside Java Newscast #84&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Episode #84 of the Inside Java Newscast reviews how the Java language is evolving in 2025 under Project Amber, the initiative focused on language syntax and developer productivity features. Active preview features include flexible constructor bodies (allowing statements to run before &lt;code&gt;super()&lt;/code&gt; or &lt;code&gt;this()&lt;/code&gt;), simplified &lt;code&gt;main&lt;/code&gt; methods and compact source files for smaller programs, single-statement module imports, and primitive types in &lt;code&gt;instanceof&lt;/code&gt; and &lt;code&gt;switch&lt;/code&gt; pattern matching. The video distinguishes these from earlier-stage explorations such as deconstruction patterns for extracting data from objects, &amp;ldquo;withers&amp;rdquo; for creating modified copies of records, and the redesign of string templates, before touching briefly on serialization improvements.&lt;/p&gt;
&lt;h2 id="valhalla---java"&gt;&lt;a href="https://www.youtube.com/watch?v=Dhn-JgZaBWo" rel="noopener noreferrer"&gt;Valhalla - Java&amp;rsquo;s Epic Refactor&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this Devoxx Belgium 2024 talk, Brian Goetz explains Project Valhalla, the long-running effort to heal the rift between objects and primitives in Java. At the center are value classes, which let developers model data with standard class abstractions while enabling flat, dense memory layouts like primitives. The talk also covers null-restricted types, tearing analysis under concurrent updates, and stricter object initialization rules.&lt;/p&gt;
&lt;h2 id="how-might-ai-change-programming"&gt;&lt;a href="https://registerspill.thorstenball.com/p/how-might-ai-change-programming" rel="noopener noreferrer"&gt;How might AI change programming?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball argues that AI is undeniably going to change programming, pointing to a string of tools Claude wrote for him: a Python script that converts a newsletter RSS feed into Markdown, an MCP server for Tailscale, over 200 lines of Rust, and a small Go server that renders Markdown files—most of which worked on the very first try. Even though AI isn&amp;rsquo;t equally effective across every codebase yet, writing and rewriting certain kinds of code has become dirt cheap, and that shift will reshape software development just as compilers, the Internet, version control, and Stack Overflow did. The real question is how.&lt;/p&gt;
&lt;p&gt;The author poses a series of thought-provoking open questions: will new programming languages struggle to gain traction when LLMs lack training data for them? Will we check prompts into version control alongside source code, or structure systems as collections of tiny programs that fit neatly into an AI&amp;rsquo;s context window? Will &lt;code&gt;CONTEXT.md&lt;/code&gt; become the new &lt;code&gt;robots.txt&lt;/code&gt;, guiding AI agents through a repository? Will we see a new form of technical debt when codebases are over-optimized for the quirks of today&amp;rsquo;s models? Will compilers emit richer, more contextual error messages tailored for AI self-correction, and will function names grow longer and more descriptive because they help LLMs reason better? The post doesn&amp;rsquo;t claim to have the answers, but offers plenty of food for thought about the future of the craft.&lt;/p&gt;
&lt;h2 id="hands-on-career-the-evolution-of-a-java-champion"&gt;&lt;a href="https://blog.vanillajava.blog/2025/01/hands-on-career-evolution-of-java.html" rel="noopener noreferrer"&gt;Hands-On Career: The Evolution of a Java Champion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Lawrey, founder of Chronicle Software and a ten-year Java Champion, reflects on more than 30 years of coding and what a programming career looks like in the era of generative AI. He outlines eight dimensions of career growth—ranging from technical depth, problem-solving, and collaboration/communication to business acumen and strategic management—and traces how an engineer&amp;rsquo;s focus shifts from junior developer up to principal engineer or solutions architect. When you start your own company, that scope expands further into sales, finance, legal, and HR. Just as ATMs didn&amp;rsquo;t eliminate bank tellers but shifted them toward higher-value relationship work, developers will adapt and gravitate toward problems that still demand human judgment.&lt;/p&gt;
&lt;p&gt;On working with AI, the author emphasizes that LLMs are statistical rather than deterministic, meaning their output is only probabilistically correct and requires domain experts to verify. A practical tip is to ask the AI to produce a plan before writing code, which consistently yields more complete results; maintaining living requirements and design documents alongside the project (documentation-driven development) also keeps AI outputs much more consistent. AI remains weak at self-evaluation, quantitative performance analysis, and aesthetic judgment. His conclusion: the ability to choose the right code matters more than the ability to type it out, and AI cannot replace hard-won experience, domain expertise, or engineering judgment.&lt;/p&gt;
&lt;h2 id="token-bucket-rate-limiter-redis--java"&gt;&lt;a href="https://foojay.io/today/token-bucket-rate-limiter-redis-java/" rel="noopener noreferrer"&gt;Token Bucket Rate Limiter (Redis &amp;amp; Java)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This tutorial walks through implementing the Token Bucket rate-limiting algorithm using Redis and Java. The core idea is a &amp;ldquo;bucket&amp;rdquo; that refills with tokens at a constant rate; each incoming request consumes one token and is rejected if the bucket is empty, while the bucket&amp;rsquo;s maximum capacity allows the system to absorb short bursts of traffic. In Redis, each client has two keys storing its current token count and the timestamp of the last refill; on every request, the application reads both values, calculates how many tokens to add based on elapsed time (capped at the bucket capacity), deducts one token if available, and writes the updated state back inside a &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction (because the reads happen outside the transaction, the operation is not strictly atomic under concurrent requests). The author uses Jedis to build a &lt;code&gt;TokenBucketRateLimiter&lt;/code&gt; class and tests it with Redis TestContainers, JUnit 5, and AssertJ across scenarios such as allowing requests within capacity, rejecting when tokens are exhausted, refilling over time, isolating multiple clients, and not counting rejected requests. Full source code in both Java and Kotlin is available on GitHub.&lt;/p&gt;
&lt;p&gt;One subtlety to watch out for: the code floors the number of newly generated tokens using integer division, yet updates the last-refill timestamp on every request—including rejected ones. If requests arrive continuously faster than the time needed to mint a single token, the accumulated fractional time is lost and the bucket fails to refill at the intended rate.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus?&lt;/h2&gt;&lt;p&gt;Boohoo, no bonus items this time around, folks :&amp;lt;&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 #3</title><link>https://miti99.com/en/post/2025/02/23/</link><pubDate>Sun, 23 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/23/</guid><description>&lt;i&gt;
Hello everyone, another weekend has rolled around—sit back, relax, and enjoy MiTi's Newsletter #3.
&lt;/i&gt;
&lt;h2 id="java"&gt;&lt;a href="https://www.youtube.com/watch?v=y26XGt8d_kI" rel="noopener noreferrer"&gt;Java&amp;rsquo;s Plans for 2025 - Inside Java Newscast #83&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Episode #83 of the Inside Java Newscast from the official Java channel surveys Java&amp;rsquo;s roadmap for 2025 across the major OpenJDK projects: Babylon, Loom, Leyden, Lilliput, Panama, and Valhalla. For each project, the video recaps what has been accomplished so far and what is planned next, saving Project Amber for a dedicated follow-up episode. It is a quick way to get the big picture of where the Java language and platform are headed.&lt;/p&gt;
&lt;h2 id="why-you-should-learn-kotlin-in-2025"&gt;&lt;del&gt;&lt;a href="https://dev.to/empiree/why-you-should-learn-kotlin-in-2025-47g0" rel="noopener noreferrer"&gt;Why You Should Learn Kotlin in 2025&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This article on Dev.to encourages developers to learn Kotlin in 2025, highlighting its modern features, Java interoperability, and versatile applications. The post also discusses the job market and salary potential for Kotlin developers.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="mastering-java-logging-best-practices-for-effective-application-monitoring"&gt;&lt;a href="https://dev.to/nithinbharathwaj/mastering-java-logging-best-practices-for-effective-application-monitoring-20h7" rel="noopener noreferrer"&gt;Mastering Java Logging: Best Practices for Effective Application Monitoring&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Dev.to article rounds up best practices for logging in Java applications. The author recommends pairing SLF4J as the logging facade with Logback as the underlying implementation so you can swap logging frameworks without touching application code, and explains how to choose appropriate log levels from TRACE to FATAL to avoid both missing critical errors and flooding alerting systems (the post mentions FATAL, though SLF4J and Logback only define TRACE, DEBUG, INFO, WARN, and ERROR). It also walks through structured JSON logging with &lt;code&gt;logstash-logback-encoder&lt;/code&gt; and using MDC (Mapped Diagnostic Context) to automatically attach contextual metadata like request IDs or user IDs to every log line.&lt;/p&gt;
&lt;p&gt;The second half focuses on performance and operations: using asynchronous appenders, avoiding expensive computations inside logging calls, and deferring message construction (in SLF4J 2, you can pass a &lt;code&gt;Supplier&lt;/code&gt; via the fluent logging API). On the security front, the author stresses masking sensitive data such as credit card numbers and passwords. Finally, the post covers centralized log aggregation with the ELK stack or Graylog, along with log rotation and retention policies to keep disks from filling up.&lt;/p&gt;
&lt;h2 id="fixed-window-counter-rate-limiter-redis--java"&gt;&lt;a href="https://foojay.io/today/fixed-window-counter-rate-limiter-redis-java/" rel="noopener noreferrer"&gt;Fixed Window Counter Rate Limiter (Redis &amp;amp; Java)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This foojay.io tutorial walks through building a Fixed Window Counter rate limiter using Redis and Java. The algorithm divides time into fixed intervals, counts requests within each interval, and rejects requests once the threshold is exceeded; its main advantage is simplicity, though bursts of traffic near the boundary between two windows can let twice the allowed rate through. The implementation uses Jedis with a dedicated key per client: it reads the current counter with &lt;code&gt;GET&lt;/code&gt;, and then inside a &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction increments the counter with &lt;code&gt;INCR&lt;/code&gt; and sets the TTL using &lt;code&gt;EXPIRE&lt;/code&gt; with the &lt;code&gt;NX&lt;/code&gt; flag so the expiration is only set when the key is first created rather than extending the window on every request.&lt;/p&gt;
&lt;p&gt;The post also demonstrates how to test the rate limiter using Redis TestContainers, JUnit 5, and AssertJ, covering key scenarios: requests within the limit are allowed, requests exceeding the limit are rejected, the counter resets once the window expires, separate clients maintain independent counters, and rejected requests do not increment the counter. Note that because the initial &lt;code&gt;GET&lt;/code&gt; and threshold check happen outside the &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction, concurrent requests can still race past the limit; stricter enforcement requires a Lua script or &lt;code&gt;WATCH&lt;/code&gt; with retries.&lt;/p&gt;
&lt;h2 id="how-jvm-handles-exceptions"&gt;&lt;a href="https://foojay.io/today/how-jvm-handles-exceptions/" rel="noopener noreferrer"&gt;How JVM handles exceptions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This foojay.io article explains how the Java Virtual Machine (JVM) handles exceptions at the bytecode level. Each method can carry an exception table where every entry specifies a protected bytecode range (&lt;code&gt;from&lt;/code&gt;, &lt;code&gt;to&lt;/code&gt;), a handler jump target (&lt;code&gt;target&lt;/code&gt;), and the exception type to catch—or &lt;code&gt;any&lt;/code&gt; for handlers that catch all throwables. When an &lt;code&gt;athrow&lt;/code&gt; instruction executes, the JVM pops the exception object from the operand stack and searches the current method&amp;rsquo;s exception table for a matching handler; if none is found, it unwinds the call stack frame by frame. If the exception remains uncaught all the way up the call chain, the active thread terminates after running its uncaught exception handler.&lt;/p&gt;
&lt;p&gt;The author also dissects how the compiler translates &lt;code&gt;try-catch-finally&lt;/code&gt; blocks into bytecode. In the example, the &lt;code&gt;finally&lt;/code&gt; block&amp;rsquo;s bytecode is duplicated along the normal execution path, while &lt;code&gt;any&lt;/code&gt; entries in the exception table route control flow through the &lt;code&gt;finally&lt;/code&gt; block whenever an exception is thrown inside &lt;code&gt;try&lt;/code&gt; or &lt;code&gt;catch&lt;/code&gt;. It is a great read if you want to see what actually happens under the hood when an exception is thrown.&lt;/p&gt;
&lt;h2 id="database-sharding-explained"&gt;&lt;a href="https://architecturenotes.co/p/database-sharding-explained" rel="noopener noreferrer"&gt;Database Sharding Explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Architecture Notes piece explains database sharding—the technique of partitioning data across multiple machines when a single database server can no longer handle the load. Before reaching for sharding, the author advises exhausting simpler alternatives: doing nothing if there isn&amp;rsquo;t a clear bottleneck yet, scaling vertically with bigger hardware, adding read replicas to offload read traffic, or moving specific workloads to specialized stores like Elasticsearch for search or S3 for large blobs.&lt;/p&gt;
&lt;p&gt;The article then covers three primary sharding strategies: hash-based sharding (distributes data evenly but makes resharding painful), range-based sharding (requires a lookup table and a well-distributed shard key to avoid hot spots), and relationship-based sharding (keeps related entities together on the same shard). The author clarifies the role of the shard key, distinguishes logical shards from physical shards, and introduces two-phase commit (2PC) as a way to coordinate atomic transactions across multiple shards—at the cost of extra write latency and significant complexity. The overarching message: sharding unlocks horizontal scale, but comes with a heavy operational burden.&lt;/p&gt;
&lt;h2 id="protecting-your-time-from-predators-in-large-tech-companies"&gt;&lt;a href="https://www.seangoedecke.com/predators/" rel="noopener noreferrer"&gt;Protecting your time from predators in large tech companies&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this post, Sean Goedecke warns high-performing engineers at large tech companies about people who constantly try to hijack their time—whom he calls &amp;ldquo;predators.&amp;rdquo; Two archetypes stand out: product managers from other teams who slide into DMs asking for a &amp;ldquo;quick fix&amp;rdquo; to bypass official prioritization channels, and underperforming engineers who lean on others as a substitute for learning on their own, claiming credit for the resulting work without acknowledging the help.&lt;/p&gt;
&lt;p&gt;To protect yourself, the author advises spotting asymmetric requests—where the requester puts in minimal effort while expecting hours of work from you—and matching their level of effort in your response. Move private requests into public channels so your contributions are visible and your manager stays in the loop. He also makes sure to distinguish legitimate demands on your time: helping your own manager, your reports, or junior teammates who are genuinely ramping up is part of the job. Above all, remember that shipping your own assigned projects is your primary responsibility.&lt;/p&gt;
&lt;h2 id="how-to-improve-your-wfh-lighting-to-reduce-eye-strain"&gt;&lt;a href="https://rustle.ca/posts/articles/work-from-home-lighting" rel="noopener noreferrer"&gt;How to improve your WFH lighting to reduce eye strain&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on rustle.ca shares practical ways to set up your work-from-home lighting to reduce eye strain. The author identifies three main culprits: imperceptible monitor flicker (PWM), especially when screen brightness is turned down and the monitor is the sole light source in the room; high-contrast environments such as harsh window glare or unevenly lit rooms; and focusing at a fixed distance for hours on end. For the last issue, the author recommends the 20/20/20 rule: every 20 minutes, look at something at least 20 feet (about 6 meters) away for at least 20 seconds.&lt;/p&gt;
&lt;p&gt;Concrete recommendations include making the most of natural daylight, using sheer curtains to diffuse direct sunlight rather than blocking it completely, placing multiple indirect light sources around the room to eliminate dark corners, choosing dimmable, flicker-free bulbs with a high Color Rendering Index (CRI) and a warm color temperature around 2700K, and adding a desk lamp or monitor bias lighting matched roughly to your screen&amp;rsquo;s brightness.&lt;/p&gt;
&lt;h2 id="working-fast-and-slow"&gt;&lt;a href="https://www.seangoedecke.com/working-fast-and-slow/" rel="noopener noreferrer"&gt;Working fast and slow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke argues that uneven productivity isn&amp;rsquo;t a flaw to be fixed; instead, he deliberately alternates between two working modes. During high-focus states, complex problems feel effortless, so he channels that energy into high-impact tasks, blocks out distractions, and works for hours at a stretch. However, this state burns through a finite internal reservoir of energy that takes time to recharge.&lt;/p&gt;
&lt;p&gt;When focus is low, he switches to lighter work such as knocking out easy tickets, reviewing pull requests, or unblocking other projects. Trying to force hard engineering work while unfocused, he notes, only introduces bugs that take longer to fix than simply waiting for focus to return—and usually gives you a headache to boot. This two-speed rhythm also aligns naturally with the cadence of large tech companies, where quiet maintenance periods alternate with high-stakes crunches that demand everything you&amp;rsquo;ve got.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;h3 id="bonus-1-interesting-images-from-bytebytego"&gt;Bonus #1: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fe9062b4-fd0e-4530-8e20-eea854b8490e_2250x2814.png" alt="Top Strategies to Reduce Latency"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9c309ad3-78a8-4511-a6f2-e69c06d5c500_1280x1566.gif" alt="The Ultimate API Learning Roadmap"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/a44f9f4b-193d-484e-bbf1-169751104380_1280x1568.gif" alt="10 Essential Components of a Production Web Application"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/d5155be3-163d-479c-a75e-632e0f98dd36_3006x3453.jpeg" alt="How do we design effective and safe APIs?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/aad520f5-00d9-4606-af4b-fdb5d1ac63c4_1600x1483.png" alt="Code First v.s. API First"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/bb375f63-bf06-4956-b3a3-914fd6aa2d91_1280x1664.jpeg" alt="Oauth 2.0 Explained With Simple Terms"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/c1155e03-c3dc-4192-8e05-e6b87dc6a574_1280x1664.gif" alt="Session, Cookie, JWT, Token, SSO, and OAuth 2.0 Explained in One Diagram"&gt;&lt;/p&gt;
&lt;h3 id="bonus-2-other-interesting-links"&gt;Bonus #2: Other interesting links&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href="https://openalternative.co/self-hosted" rel="noopener noreferrer"&gt;Self-hosted Alternatives to Popular Software&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #2</title><link>https://miti99.com/en/post/2025/02/16/</link><pubDate>Sun, 16 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/16/</guid><description>&lt;i&gt;
Hello everyone, right on schedule, here is my Newsletter #2. I went on a weekend trip to Xuyên Mộc and just got back today, which is why this issue is going up a bit late.
&lt;p&gt;Without further ado, let&amp;rsquo;s jump straight into MiTi&amp;rsquo;s Newsletter #2.
&lt;/i&gt;&lt;/p&gt;
&lt;h2 id="some-things-to-expect-in-2025"&gt;&lt;a href="https://lwn.net/Articles/1003780/" rel="noopener noreferrer"&gt;Some things to expect in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In keeping with his New Year tradition, LWN.net&amp;rsquo;s Jonathan Corbet shares a set of predictions for the Linux and free software communities in 2025. Sched-ext—the mechanism for loading CPU schedulers from user space as BPF programs—will ship in more distributions, sparking a wave of new scheduling ideas tested rapidly on real production systems. More Rust code will land in the Linux kernel, this time in components that everyday users will actually run without realizing it. The author also expects another XZ-style backdoor attempt to come to light, and predicts that single-maintainer projects will increasingly be viewed as a risk, both for security and maintainer burnout.&lt;/p&gt;
&lt;p&gt;A major project may discover it has merged a substantial amount of AI-generated code that the contributor didn&amp;rsquo;t actually understand, forcing a revert; alongside that, efforts to build truly free generative AI systems will continue. Free software foundations will keep facing funding struggles, though a dedicated fund to support maintainers may emerge. More cloud-dependent consumer devices will turn into &amp;ldquo;bricks&amp;rdquo; when their manufacturers go under, creating opportunities for open solutions like Home Assistant; open hardware like the OpenWrt One will gain traction, and alternative mobile Linux distributions will see renewed interest. Finally, the author worries that global geopolitical tensions will spill over into the community and urges everyone to hold fast to the spirit of building systems for all and welcoming contributions from anyone.&lt;/p&gt;
&lt;h2 id="why-you-should-use-compact-table-columns"&gt;&lt;a href="https://vladmihalcea.com/compact-table-columns/" rel="noopener noreferrer"&gt;Why you should use compact table columns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vlad Mihalcea explains why choosing compact column types matters when designing database schemas. Relational database management systems cache disk pages in a Buffer Pool (such as PostgreSQL&amp;rsquo;s shared buffers); because RAM is orders of magnitude faster than SSDs, narrower columns pack more rows and index entries into each page, allowing more queries to be served directly from memory. StackOverflow is a prime example: they serve roughly 11,000 queries per second from a single active SQL Server node thanks to 1.5 TB of RAM fronting a 2.8 TB database and a Frugal Schema—avoiding 16-byte UUIDs for primary and foreign keys, using 4-byte &lt;code&gt;int&lt;/code&gt; or 1-byte &lt;code&gt;tinyint&lt;/code&gt; instead of &lt;code&gt;bigint&lt;/code&gt; for most primary keys, keeping enums to 1 byte, and bounding &lt;code&gt;VARCHAR&lt;/code&gt; column lengths.&lt;/p&gt;
&lt;p&gt;The author backs this up with concrete measurements. On MySQL, in a five-million-row &lt;code&gt;customer&lt;/code&gt; table, using &lt;code&gt;tinyint&lt;/code&gt; instead of &lt;code&gt;smallint&lt;/code&gt; for a single indexed foreign key saves about 71.59 MB; across ten such columns on a 100-million-row table, that adds up to roughly 14.3 GB. PostgreSQL lacks a 1-byte integer type and enforces column data alignment, so columns should be ordered using &amp;ldquo;Column Tetris&amp;rdquo; to avoid wasted padding bytes; even so, using &lt;code&gt;smallint&lt;/code&gt; instead of &lt;code&gt;int&lt;/code&gt; shrinks the &lt;code&gt;customer&lt;/code&gt; table by 38 MB. The takeaway: right-sizing column types is a proven performance optimization strategy that has served StackOverflow well for over 15 years.&lt;/p&gt;
&lt;h2 id="rate-limiting-with-redis-an-essential-guide"&gt;&lt;a href="https://foojay.io/today/rate-limiting-with-redis-an-essential-guide/" rel="noopener noreferrer"&gt;Rate limiting with Redis: An essential guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raphael De Lio opens with familiar encounters with rate limiting, such as &amp;ldquo;429 Too Many Requests&amp;rdquo; errors or tiered API quotas. Rate limiting prevents abuse, ensures fair access, smooths traffic spikes, controls costs, and protects service availability: Figma famously stopped a mass-invite spam attack using a Redis-backed rate limiter, while Stripe relies on rate limiting to keep misconfigured scripts or bad actors from monopolizing resources. Redis is a popular choice thanks to its speed, reliability, atomic operations, persistence options, and Lua scripting; GitHub also migrated to a Redis-based rate-limiting setup with client-side sharding.&lt;/p&gt;
&lt;p&gt;The article compares five common algorithms. Leaky Bucket processes requests at a steady rate, ideal for smooth traffic flows but unforgiving of bursts; Token Bucket allows short bursts as long as tokens remain; Fixed Window Counter is simple to implement but vulnerable to boundary spikes across adjacent time windows; Sliding Window Log is the most accurate but consumes significant memory and CPU at scale; and Sliding Window Counter balances accuracy with resource efficiency. Choosing the right algorithm depends on traffic patterns, required precision, resource constraints, and user experience. As the author notes, rate limiting isn&amp;rsquo;t just about setting caps—it&amp;rsquo;s about designing efficient, fair, and user-friendly systems; follow-up posts implementing each algorithm in Java and Redis will roll out weekly.&lt;/p&gt;
&lt;h2 id="why-does-cloudflare-pages-have-such-a-generous-free-tier"&gt;&lt;a href="https://mattsayar.com/why-does-cloudflare-pages-have-such-a-generous-free-tier/" rel="noopener noreferrer"&gt;Why does Cloudflare Pages have such a generous Free tier?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matt Sayar, who hosts his personal site on Cloudflare Pages, wonders why there are so many high-quality free hosting tiers available today. The biggest concern with free hosting is bandwidth, since a surprise viral post can stick you with a massive bill or knock your site offline. Comparing providers, GitHub Pages has a soft limit of 100 GB per month, Netlify and AWS S3 offer around 100 GB, GitLab Pages throttles by requests per minute, whereas Cloudflare Pages offers completely unlimited bandwidth.&lt;/p&gt;
&lt;p&gt;The author outlines three practical reasons behind this generosity. First, static sites are tiny—his own site is only about 2.2 MB—so with Cloudflare&amp;rsquo;s massive edge network, aggressive caching, and optimization techniques, the marginal cost of serving them is negligible. Second, Cloudflare benefits from a fast, secure internet: the more people and businesses come online, the more enterprises need commercial security products—which is exactly what Cloudflare sells, in the same spirit as its free 1.1.1.1 DNS resolver and unmetered DDoS protection. Third is the classic freemium flywheel: developers try the free tier, have a great experience, and later champion Cloudflare&amp;rsquo;s paid plans at work. Although the author initially couldn&amp;rsquo;t find an official statement explaining the bandwidth policy, the Hacker News community pointed him to a Cloudflare post affirming their commitment to the free tier; even so, he keeps a mirror on GitHub just in case policies change.&lt;/p&gt;
&lt;h2 id="how-i-program-with-llms"&gt;&lt;a href="https://crawshaw.io/blog/programming-with-llms" rel="noopener noreferrer"&gt;How I program with LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Crawshaw reflects on a year of actively programming with large language models (LLMs) and concludes that they deliver a clear productivity boost. He uses LLMs in three ways: code autocomplete, search engine replacement, and chat-driven programming—the hardest mode to master, but also the most valuable. Chat is especially helpful when you know what needs to be written but lack the energy to set up a new file and look up library APIs: the LLM produces a first draft with good structure, the right imports, and a few bugs, and fixing bugs is much easier than staring at a blank page. His advice is to frame prompts like exam questions: specific goals, self-contained context, and verifiable outputs—and always compile and run tests before reading the generated code closely.&lt;/p&gt;
&lt;p&gt;As a concrete example, he walks through writing a reservoir sampler in Go to estimate quartiles. The LLM generated a well-structured package with clean interfaces, though the initial code failed to compile due to an unused variable and included fabricated expected values in the unit test. When prompted, it wrote a naive reference implementation for comparison and a fuzz test that initially passed the wrong argument types, which it fixed as soon as the compiler error was pasted back; in the author&amp;rsquo;s experience, over 80% of tool-reported errors can be resolved by the LLM on its own. He argues that LLMs shift traditional software engineering trade-offs: favoring smaller packages, more thorough tests, and a looser adherence to DRY—such as generating a 200-line custom wrapper for the exact subset of an API you need rather than pulling in a bloated official SDK. He is currently automating these workflows at sketch.dev.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;p&gt;This week comes with quite a few bonuses from various sources.&lt;/p&gt;
&lt;h3 id="bonus-1-a-couple-of-ebooks-i-found"&gt;Bonus #1: A couple of ebooks I found&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href="https://info.microsoft.com/rs/157-GQE-382/images/EN-CNTNT-eBook-DesigningDistributedSystems.pdf" rel="noopener noreferrer"&gt;Designing Distributed Systems&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://drive.google.com/file/d/1U7EchvgzCjTtF5JzGVVCFgjXC-qw7lIG/view" rel="noopener noreferrer"&gt;Quastor Summaries&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus #2: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/11b53f30-8dba-4520-9b1a-425b54b9b84a_1280x1585.gif" alt="Cookies Vs Sessions Vs JWT Vs PASETO"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fdbcc119-8f5d-4d27-9a4b-2c8bde82b537_4026x8030.jpeg" alt="Algorithms you should know before taking System Design Interviews"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/12dffcce-f231-48cc-915f-d53c0f8bce0c_3735x3573.jpeg" alt="Top 6 Load Balancing Algorithms"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>