<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Garbage Collection on miti99</title><link>https://miti99.com/en/tags/garbage-collection/</link><description>Recent content in Garbage Collection 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/garbage-collection/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #96</title><link>https://miti99.com/en/post/2026/04/16/</link><pubDate>Thu, 16 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #96.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="clean-architecture--separation-of-concerns-trong-go"&gt;&lt;a href="https://vjerci.com/writings/clean/separation-of-concerns/" rel="noopener noreferrer"&gt;Clean Architecture → Separation of Concerns trong Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains the principle of Separation of Concerns in Go: once a responsibility is handled in one place in the system, other parts shouldn&amp;rsquo;t have to worry about it or duplicate it. The author opens with an anti-pattern where a single handler function parses an HTTP request, validates the payload, and executes SQL queries directly. When everything is tangled together like that, changing any detail requires understanding the whole stack, and the codebase quickly becomes unmaintainable as complexity grows.&lt;/p&gt;
&lt;p&gt;The fix is splitting the service into four layers: HTTP handlers only decode requests and encode responses, Services hold pure business logic decoupled from infrastructure, Repositories handle all database queries, and Models define data structures with zero dependencies on other layers. Go makes this natural through structural typing: a struct satisfies an interface implicitly without &lt;code&gt;implements&lt;/code&gt; declarations. The author recommends giving each package a single, obvious responsibility and wiring components together via constructor dependency injection so the dependency graph is visible right in &lt;code&gt;main&lt;/code&gt;. Helpful Go tips include using your IDE&amp;rsquo;s &amp;ldquo;Find Implementations&amp;rdquo; shortcut and adding a compile-time interface check like &lt;code&gt;var _ MyInterface = (*MyStruct)(nil)&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-garbage-collector"&gt;&lt;a href="https://internals-for-interns.com/posts/go-garbage-collector" rel="noopener noreferrer"&gt;The Garbage Collector&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This deep dive explores Go 1.26&amp;rsquo;s garbage collector, which introduces the GreenTea GC. Go&amp;rsquo;s collector is a non-moving, concurrent, tri-color mark-and-sweep collector: because objects never move in memory over their lifetime, pointers stay valid and interoperating with &lt;code&gt;unsafe&lt;/code&gt; or C code is much simpler. Each GC cycle runs through four phases: sweep termination, concurrent mark (running alongside application goroutines and capped at roughly 25% of CPU), mark termination, and lazy sweep driven by allocation demand—pausing the program (stop-the-world) only twice for very brief intervals.&lt;/p&gt;
&lt;p&gt;GreenTea&amp;rsquo;s key innovation is queuing entire memory spans (contiguous pages holding same-sized objects) rather than individual object pointers during marking, batching marked objects together before scanning to dramatically improve CPU cache locality. When a span has more than 12.5% of its objects marked, the collector uses AVX-512 SIMD instructions on x86-64 to scan it 4–8x faster. A hybrid Yuasa–Dijkstra write barrier shades both overwritten and newly written pointers during concurrent marking so live objects are never missed. If goroutines allocate faster than background workers can mark, &lt;em&gt;mark assist&lt;/em&gt; forces allocating goroutines to do marking work themselves as backpressure. Finally, the GC Pacer schedules cycles using &lt;code&gt;GOGC&lt;/code&gt; (default 100, triggering when the heap doubles) and &lt;code&gt;GOMEMLIMIT&lt;/code&gt; (a soft memory cap for the Go runtime).&lt;/p&gt;
&lt;h2 id="the-skill-of-using-ai-agents-well"&gt;&lt;a href="https://www.lesswrong.com/posts/9xAwybDhtgzGYPnbs/the-skill-of-using-ai-agents-well" rel="noopener noreferrer"&gt;The Skill of Using AI Agents Well&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post shares practical habits for working effectively with AI coding agents, centered on one insight: the real bottleneck is human attention, not AI capability. Accordingly, the author designs his workflow to minimize personal friction: always use the strongest frontier model at its highest reasoning setting, turn on verbose debug logging so the agent can diagnose failures on its own, and give every AI session its own isolated branch via &lt;code&gt;git worktree&lt;/code&gt; so multiple agents can run in parallel without stepping on each other&amp;rsquo;s files. Tasks that parallelize naturally—like testing five hypotheses at once—get fanned out to subagents.&lt;/p&gt;
&lt;p&gt;For permissions, he recommends whitelisting obviously safe commands, using a secondary AI classifier to auto-approve routine permission prompts, and enabling audio notifications when an agent blocks waiting for human input. Spinning up a fresh agent session purely to review a diff regularly catches bugs the authoring session missed, while a central dashboard across all active sessions makes it easy to see which agents need attention. He also delegates setup chores like spinning up test databases or driving browser UI checks entirely to agents, switches providers promptly whenever a model feels degraded, and is experimenting with cross-session memory systems—though he hasn&amp;rsquo;t found a silver bullet there yet.&lt;/p&gt;
&lt;h2 id="the-unwritten-laws-of-software-engineering"&gt;&lt;a href="https://newsletter.manager.dev/p/the-unwritten-laws-of-software-engineering" rel="noopener noreferrer"&gt;The unwritten laws of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This piece rounds up seven unwritten laws that software engineers usually learn only after painful production incidents. First, when production breaks right after a deployment, roll back first and investigate second—don&amp;rsquo;t burn hours trying to prove your commit was innocent while users are down. Second, a backup doesn&amp;rsquo;t exist until you have successfully restored from it; you also need to know your recovery point objective, who has permissions to run the restore, and how long a restore actually takes now that the database is ten times larger. Third, logging is an eternal balancing act: either too sparse to diagnose an outage, or a noisy flood missing a shared correlation/request ID across services.&lt;/p&gt;
&lt;p&gt;Fourth, every data migration needs a tested rollback plan, because an untested rollback plan will almost certainly fail when you need it most. Fifth, every external dependency &lt;em&gt;will&lt;/em&gt; eventually fail—know its rate limits, test how your app behaves when it goes down, and prepare caches, queues, or graceful degradation; chaining two independent 99.9% services in series drops combined availability to ~99.8%. Sixth, risky production operations require the &amp;ldquo;four-eyes principle&amp;rdquo;: have a teammate watch, because simply explaining what you are about to do out loud often catches the mistake. Finally, nothing is more permanent than a temporary hack—so build a small, scoped, clean solution rather than a messy kludge.&lt;/p&gt;
&lt;h2 id="big-tech-engineers-need-big-egos"&gt;&lt;a href="https://www.seangoedecke.com/big-tech-needs-big-egos/" rel="noopener noreferrer"&gt;Big tech engineers need big egos&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke pushes back against the cliché that there is no room for ego in software engineering, arguing that engineers at big tech companies actually need a healthy dose of ego to succeed. Day to day, senior engineers constantly confront their own mistakes and sprawl across codebases too vast for any one person to hold in their head—requiring stubborn self-belief that they can solve problems that look impossible at first glance. Organizationally, strong self-confidence lets an engineer stake out a clear technical position amid ambiguity, make unpopular calls that affect hundreds of peers, and push back when senior leadership misunderstands a technical constraint.&lt;/p&gt;
&lt;p&gt;The paradox is that effective big-tech engineers must also be able to set their ego aside entirely before the org chart: accepting canceled projects, losing internal political battles, or executing murky top-down priorities without becoming bitter. Goedecke calls this the &amp;ldquo;chameleon&amp;rdquo; posture—assertive with peers, yet adaptable toward hierarchy. Burnout, he argues, rarely comes from working too hard; it comes from unrewarded effort, especially when a technically sound decision gets punished because it clashed with organizational politics. Mastering that delicate balance is a big reason truly effective staff-plus engineers are so rare.&lt;/p&gt;
&lt;h2 id="sorting-algorithms"&gt;&lt;a href="https://simonwillison.net/2026/Mar/11/sorting-algorithms/" rel="noopener noreferrer"&gt;Sorting algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison shares how he used Claude Artifacts to build an animated side-by-side visualization of classic sorting algorithms—starting with bubble sort, selection sort, insertion sort, merge sort, quicksort, and heapsort. When asked to add Timsort, Claude autonomously cloned the CPython repository from GitHub and read &lt;code&gt;Objects/listobject.c&lt;/code&gt; and &lt;code&gt;Objects/listsort.txt&lt;/code&gt; to implement it. However, when Willison asked GPT-5.4 Thinking to audit the result, it pointed out that Claude had actually written a simplified adaptive mergesort inspired by Timsort rather than the full algorithm—a great illustration of using one frontier model to cross-check another.&lt;/p&gt;
&lt;p&gt;After a few rounds of UI polish, the artifact gained a &amp;ldquo;Run all&amp;rdquo; button that races all seven algorithms simultaneously in a grid, complete with live comparison and swap counters and color-coded operations: pink for comparisons, orange for swaps, red for pivots, and purple for sorted runs. In the live race, Timsort finishes first, followed closely by quicksort and merge sort, with bubble sort trailing far behind. The post showcases how quickly modern AI tools can turn a conversational prompt into a rich, interactive learning tool.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F438c4c2f-0fa8-4748-9953-b63fd69674f4_2508x3000.png" alt="12 Claude Code Features Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F75e97a13-b186-4f16-ab59-f9a96867f744_1899x1536.jpeg" alt="How does REST API work?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0169578f-af50-4b3a-b8ed-542ee7ebf80f_2250x2814.png" alt="7 Key Load Balancer Use Cases"&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 #78</title><link>https://miti99.com/en/post/2026/02/01/</link><pubDate>Sun, 01 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #78.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-next-two-years-of-software-engineering"&gt;&lt;a href="https://addyosmani.com/blog/next-two-years/" rel="noopener noreferrer"&gt;The Next Two Years of Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani observes that the software industry is at an inflection point: AI coding tools have evolved from autocomplete suggestions into autonomous agents that execute end-to-end tasks, while the hiring boom has given way to an efficiency mandate where companies favor experienced engineers and small, well-tooled teams. Rather than making single-track predictions, he poses five open questions through 2026, each paired with two contrasting scenarios. Junior hiring could collapse (a Harvard study found junior roles dropped roughly 9–10% after companies adopted generative AI) or rebound as software expands into every industry. Foundational computer science skills could atrophy or become more valuable than ever. The developer role could narrow into an AI code reviewer or expand into a full-system orchestrator. Narrow specialists risk displacement, while T-shaped engineers (deep in one or two areas, broad across many) are in high demand. And traditional CS degrees could be overtaken by bootcamps, online courses, and internal apprenticeships.&lt;/p&gt;
&lt;p&gt;With 84% of developers already using or planning to use AI, value lies in reviewing AI output for logic bugs, security vulnerabilities, and requirement drift; the best engineers aren&amp;rsquo;t the ones who write code the fastest, but the ones who know when not to trust AI. Juniors should use AI to learn rather than as a crutch; seniors should anchor quality assurance, mentorship, and architecture. The common denominator is continuous learning.&lt;/p&gt;
&lt;h2 id="databases-in-2025-a-year-in-review"&gt;&lt;a href="https://www.cs.cmu.edu/~pavlo/blog/2026/01/2025-databases-retrospective.html" rel="noopener noreferrer"&gt;Databases in 2025: A Year in Review&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andy Pavlo (Carnegie Mellon University) looks back at the database world in 2025, starting with PostgreSQL&amp;rsquo;s continued dominance. Version 18 added an asynchronous I/O subsystem and B-tree skip scans. The business side was even livelier: Databricks paid $1 billion to acquire Neon, Snowflake paid $250 million for CrunchyData, Microsoft launched HorizonDB, and three horizontally scalable PostgreSQL sharding projects—Multigres (Supabase), Neki (PlanetScale), and PgDog—entered the ring. 2025 was also the year every DBMS shipped an MCP (Model Context Protocol) server, exploding after OpenAI backed the standard in March. Pavlo cautions that these servers mostly just forward queries to the database, making least-privilege access essential. The columnar file format space heated up as well, with five new formats challenging Parquet: FastLanes, F3, Vortex, AnyBlox, and Amudai.&lt;/p&gt;
&lt;p&gt;The industry roundup covers a wave of acquisitions: IBM bought DataStax (for an estimated $3 billion) and Confluent, Salesforce acquired Informatica ($8 billion), and Fivetran and dbt Labs announced a surprise merger. Databricks raised two massive funding rounds of $4 billion and $1 billion, while several database startups shut down, including Fauna, PostgresML, Hydra, MyScaleDB, and Voltron Data. The post closes with Oracle founder Larry Ellison briefly becoming the richest person in the world with an estimated net worth of $393 billion—which Pavlo notes makes him the richest database person in history, surpassing even John D. Rockefeller on an inflation-adjusted basis.&lt;/p&gt;
&lt;h2 id="12-predictions-for-2026"&gt;&lt;a href="https://tomtunguz.com/2026-predictions/" rel="noopener noreferrer"&gt;12 Predictions for 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tomasz Tunguz shares 12 predictions for 2026 centered on AI agents moving into real production work. For the first time, enterprises will spend more on agents than on human labor in certain workflows, much as riders willingly pay a ~31% premium to take a Waymo over an Uber. 2026 is poised to set a liquidity record with potential IPOs from SpaceX, OpenAI, Anthropic, Stripe, and Databricks. Vector databases will enjoy a renaissance as essential agent infrastructure. According to METR, the task duration AI can reliably complete doubles every seven months, putting agents on track to run 8+ hour workflows autonomously by year&amp;rsquo;s end. AI budgets will face real scrutiny for the first time, pushing small and open-source models ahead thanks to up to 10x lower costs, while Google widens its lead through strength across frontier models, video generation, and search.&lt;/p&gt;
&lt;p&gt;Agent observability will become the most fiercely contested infrastructure layer. Stablecoins are projected to capture 30% of cross-border payments, eating into SWIFT&amp;rsquo;s volume. Agents will issue at least an order of magnitude more queries than humans, forcing database architectures to adapt. US data center investment will reach 3.5% of GDP, rivaling the railroad boom. The web will shift toward agent-first design as purchasing decisions increasingly begin with agent-led research, and Cloudflare will emerge as the toll collector for agent payments via the x402 protocol, reviving the long-dormant HTTP &lt;code&gt;402 Payment Required&lt;/code&gt; status code.&lt;/p&gt;
&lt;h2 id="the-garbage-collection-handbook"&gt;&lt;a href="https://gchandbook.org/index.html" rel="noopener noreferrer"&gt;The Garbage Collection Handbook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This page introduces the second edition of &lt;em&gt;The Garbage Collection Handbook&lt;/em&gt;, the classic reference on automatic memory management. Descending from Richard Jones&amp;rsquo;s original &lt;em&gt;Garbage Collection&lt;/em&gt; (Wiley, 1996) and the first Handbook edition in 2012, this new edition thoroughly updates the material to reflect modern hardware, software, and runtime environments. It progresses from simple, traditional algorithms to modern parallel, incremental, concurrent, and real-time collectors, illustrated throughout with pseudocode and diagrams. The book analyzes high-performance commercial collectors in detail, explains tricky runtime interface mechanics, and adds over 90 pages of new material including chapters on persistence (non-volatile memory) and energy-aware garbage collection.&lt;/p&gt;
&lt;p&gt;Because nearly all modern programming languages rely on garbage collection, understanding how collectors work helps developers confidently select and tune them for their workloads. The e-book edition features over 37,000 internal cross-references linking chapters, sections, algorithms, figures, and original research papers, accompanied by an online bibliography database of nearly 3,400 garbage-collection publications. The first edition of the Handbook was also translated into Chinese and Japanese in 2016.&lt;/p&gt;
&lt;h2 id="vibe-coded-is-the-new"&gt;&lt;a href="https://gabriel-afonso.com/blog/vibe-coded-is-the-new-made-in-china/" rel="noopener noreferrer"&gt;Vibe-Coded Is the New &amp;ldquo;Made in China&amp;rdquo;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gabriel Afonso notices that on &lt;code&gt;r/selfhosted&lt;/code&gt;, any new project labeled &amp;ldquo;vibe-coded&amp;rdquo; is immediately met with skepticism. Coined by Andrej Karpathy in early 2025, &amp;ldquo;vibe coding&amp;rdquo; means giving in to the vibes and letting large language models handle the implementation while you focus only on what you want to build. In Afonso&amp;rsquo;s view, the backlash usually isn&amp;rsquo;t about the code quality itself, but what the label signals. Historically, the sheer difficulty of building software acted as a natural filter: anyone who shipped an open-source project had invested enough sweat equity that they were likely to stick around and maintain it. Now that anyone can spin up an app in a few hours and code far beyond their actual skill level, a project&amp;rsquo;s author might not even understand the code they published. As a result, &amp;ldquo;vibe-coded&amp;rdquo; has become like the old &amp;ldquo;Made in China&amp;rdquo; label—shorthand for cheap, disposable software.&lt;/p&gt;
&lt;p&gt;He draws a parallel to chess: after Deep Blue defeated Kasparov in 1997, chess became even more popular as humans learned to work alongside engines. Respected developers like DHH, Tanner Linsley, and Boris Cherny (creator of Claude Code, who shared that 100% of his contributions over the prior 30 days were written by Claude Code) use AI heavily without drawing backlash because they remain true authors who understand and own their systems. Time remains the most reliable filter: a project maintained for two years with real users proves a level of commitment that cannot be faked. Today&amp;rsquo;s skepticism is simply the ecosystem&amp;rsquo;s immune system adapting while the rules are being rewritten.&lt;/p&gt;
&lt;h2 id="the-production-bug-that-made-me-care-about-undefined-behavior"&gt;&lt;a href="https://gaultier.github.io/blog/the_production_bug_that_made_me_care_about_undefined_behavior.html" rel="noopener noreferrer"&gt;The production bug that made me care about undefined behavior&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Philippe Gaultier recounts a production bug in a C++ system processing billions of euros in payments each year. An HTTP endpoint was supposed to return either &lt;code&gt;error&lt;/code&gt; or &lt;code&gt;succeeded&lt;/code&gt; set to &lt;code&gt;true&lt;/code&gt;—never both—yet clients occasionally received responses with both fields set to &lt;code&gt;true&lt;/code&gt;, even though each field was assigned at most once in mutually exclusive branches. The culprit was the declaration &lt;code&gt;Response response;&lt;/code&gt;. In C, reading an uninitialized struct field is straightforward undefined behavior; C++ is subtler: because &lt;code&gt;Response&lt;/code&gt; contained a &lt;code&gt;std::string&lt;/code&gt;, it was a non-POD type, so the compiler synthesized and called a default constructor—which default-constructed the &lt;code&gt;std::string&lt;/code&gt; but left the two &lt;code&gt;bool&lt;/code&gt; fields uninitialized with garbage stack bytes.&lt;/p&gt;
&lt;p&gt;The fix is to use value initialization (&lt;code&gt;Response response{};&lt;/code&gt;) to zero-initialize every field, or provide explicit default member initializers. Compilers emit no warning even with all warning flags enabled; &lt;code&gt;clang-tidy&lt;/code&gt; catches it statically, and AddressSanitizer paired with UndefinedBehaviorSanitizer (or Valgrind) catches it at runtime, though only if test coverage hits that code path and the stack happens to contain non-zero bytes. Gaultier wrote a custom &lt;code&gt;libclang&lt;/code&gt; plugin to scan the entire codebase for similar bugs. The post also highlights a bizarre C++ quirk: reading an uninitialized &lt;code&gt;std::byte&lt;/code&gt; or &lt;code&gt;unsigned char&lt;/code&gt; is permitted in many cases without triggering undefined behavior, whereas reading an uninitialized &lt;code&gt;bool&lt;/code&gt; is instant UB. His takeaway: C++ has far too many initialization syntaxes, looks deceptively like C while behaving differently, and changes its rules across language standards.&lt;/p&gt;
&lt;h2 id="don"&gt;&lt;a href="https://antirez.com/news/158" rel="noopener noreferrer"&gt;Don&amp;rsquo;t fall into the anti-AI hype&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Salvatore Sanfilippo (&lt;code&gt;antirez&lt;/code&gt;), creator of Redis, loves crafting software line by line, yet admits that AI has changed programming forever. He used to think this inflection point was still a few years away, but changed his mind now that modern LLMs can complete major features or medium-sized projects almost autonomously. In a single week, by writing prompts and occasionally reviewing code to steer direction, he finished four projects in hours that would otherwise have taken weeks: adding UTF-8 support to his &lt;code&gt;linenoise&lt;/code&gt; library along with a pseudo-terminal test harness; fixing transient timing and TCP deadlock test failures in Redis; having Claude Code write a 700-line pure C library in 5 minutes to run BERT-style embedding inference within 15% of PyTorch&amp;rsquo;s speed; and having Claude Code reproduce internal Redis Streams changes from a design spec in about 20 minutes.&lt;/p&gt;
&lt;p&gt;In his view, writing code by hand is no longer necessary for most projects. He is happy that his open-source code was used to train models, seeing it as a continuation of the open-source mission to democratize code and knowledge; AI will empower small teams to compete with tech giants just as open source did in the 1990s. Still, he worries about this technology concentrating in the hands of a few corporations. His advice: don&amp;rsquo;t fall for anti-AI hype—give modern tools a serious multi-week trial rather than a five-minute test, because the joy of programming is building, and we can now build more and better than ever.&lt;/p&gt;
&lt;h2 id="performance-hints"&gt;&lt;a href="https://abseil.io/fast/hints.html" rel="noopener noreferrer"&gt;Performance Hints&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the &amp;ldquo;Performance Hints&amp;rdquo; guide written by Jeff Dean and Sanjay Ghemawat on Google&amp;rsquo;s Abseil site, distilling the principles and techniques they use when optimizing software performance. They quote Donald Knuth in full: we should forget about small efficiencies about 97% of the time, yet we should not pass up our opportunities in that critical 3%. The common advice to &amp;ldquo;write it simply first and optimize later&amp;rdquo; often fails in practice because large systems built without regard for performance end up with flat profiles where CPU time is diffused across thousands of functions with no obvious hotspot; instead, engineers should instinctively choose the faster alternative whenever it doesn&amp;rsquo;t noticeably harm readability. The guide shows how to do back-of-the-envelope estimates using basic latency numbers (L1 cache ~0.5 ns, branch mispredict ~5 ns, main memory ~50 ns), measure with profilers, and tackle flat CPU profiles by stacking many 1% wins or restructuring higher-level architecture.&lt;/p&gt;
&lt;p&gt;The remainder of the document is a catalog of concrete techniques with code examples: designing APIs that allow optimization behind encapsulation boundaries (such as bulk operations and passing buffers); algorithmic improvements; compact memory representations that touch fewer cache lines (indices instead of pointers, arenas, arrays instead of maps, bitvectors); reducing allocations by pre-sizing containers, reusing objects, and avoiding copies; avoiding unnecessary work via fast paths, precomputation, caching, and keeping logging off hot paths; controlling code size; and parallelizing with short critical sections, sharding to reduce contention, SIMD, and avoiding false sharing. It concludes with specific advice for Protocol Buffers and containers like &lt;code&gt;absl::flat_hash_map&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="software-engineering-job-market-2026-data-trends-and-outlook"&gt;&lt;a href="https://www.finalroundai.com/blog/software-engineering-job-market-2026" rel="noopener noreferrer"&gt;Software Engineering Job Market 2026: Data, Trends and Outlook&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article analyzes why software engineering—once considered the safest career track—now feels vulnerable amid near-weekly layoff headlines. Indeed job-posting data via FRED shows software roles peaked in mid-2022, plunged through 2024, and have yet to rebound to pandemic highs. The primary driver isn&amp;rsquo;t AI, but the 2021–2022 digitization bubble: fear of missing out and near-zero interest rates led everyone from Big Tech to startups to overhire massively. When demand normalized, AI became a convenient scapegoat for headcount reductions. Another major factor is global remote hiring: a senior engineer might cost $100,000+ per year in the US versus $40,000 in India, and telling investors &amp;ldquo;we&amp;rsquo;re replacing roles with AI&amp;rdquo; sounds much more forward-looking than &amp;ldquo;we&amp;rsquo;re offshoring.&amp;rdquo; A METR study even found that experienced developers were 19% slower when using AI tools across 246 tasks.&lt;/p&gt;
&lt;p&gt;Even so, the profession isn&amp;rsquo;t disappearing—only demand for basic boilerplate coding is shrinking. The US Bureau of Labor Statistics still projects ~15% employment growth for software developers, SignalFire reports that Meta, Netflix, Uber, and Google are hiring faster than attrition, and Antler founder Magnus Grimeland points out that more AI-generated code means more bugs that require human engineers to fix. What has changed is the skill bar: system design, performance, security, and effective AI orchestration. Entry-level candidates face the toughest market, with junior postings down roughly 40% compared to pre-2022 levels. The article closes with recommended languages to learn in 2026: Python for AI/ML, JavaScript/TypeScript for frontend, Go for backend and cloud infrastructure, Java for enterprise, and Swift for iOS.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!0P7Z!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7546f89c-8b6f-4ced-8d40-4e0137ab5941_2360x2852.png" alt="12 Architectural Concepts Developers Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Co3P!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fb7f3c175-c0d6-4d02-992d-114ac588b45c_2252x2752.png" alt="Top Developer Tools You Can Use in 2026"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Ty5s!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fecc68f5e-6353-4487-a779-92bb11440bc5_2360x2960.png" alt="5 Rate Limiting Strategies To Protect the System"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!dPjo!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fc2543392-5e04-4dd6-b39a-72fdfe3a3048_2360x2770.png" alt="How Live Streaming Works?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!MJUT!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F06243bf8-f149-4075-bc81-99af15be3579_6001x7802.png" alt="5 Leader Election Algorithms Powering Modern Databases"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!Xrbz!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8c99d0d5-8e5b-4e82-bb28-9fbd470e3bc6_2250x2624.png" alt="A Guide to Database Sharding"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!NCWv!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0adc9c84-37f2-4a96-96a6-f7f26bbd1b7e_2360x2960.jpeg" alt="Modern Storage Systems"&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 #33</title><link>https://miti99.com/en/post/2025/07/22/</link><pubDate>Tue, 22 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/22/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #33.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-zgc-allocates-memory-for-the-java-heap"&gt;&lt;a href="https://joelsiks.com/posts/zgc-heap-memory-allocation/" rel="noopener noreferrer"&gt;How ZGC allocates memory for the Java heap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ZGC is Java&amp;rsquo;s low-latency garbage collector, and this post dives into how it allocates memory for the heap. ZGC divides the heap into logical &amp;ldquo;pages&amp;rdquo; of three sizes: small 2 MB pages for most objects, medium pages dynamically sized between 4 and 32 MB, and large pages that hold a single object each. Crucially, ZGC decouples physical memory from virtual memory and reserves virtual address space up to 16 times the maximum heap size (32 times on NUMA machines) so it can easily find contiguous virtual ranges and minimize fragmentation.&lt;/p&gt;
&lt;p&gt;Free memory is tracked in a mapped cache organized as a red-black tree. When an allocation is needed, ZGC tries in order: grabbing an existing contiguous range from the cache (the fastest path), committing more physical memory, &amp;ldquo;harvesting&amp;rdquo; by remapping multiple discontiguous regions into a single contiguous virtual range, or combining the latter two; only if all of those fail does it trigger garbage collection or throw an &lt;code&gt;OutOfMemoryError&lt;/code&gt;. On NUMA systems, the heap is partitioned evenly across nodes to favor local memory allocation. The post also highlights a practical trade-off: setting minimum heap size equal to maximum heap size pre-allocates all memory at startup, whereas dynamic allocation at runtime adds latency.&lt;/p&gt;
&lt;h2 id="optimizing-the-garbage-collector-when-migrating-cloud-workloads"&gt;&lt;a href="https://foojay.io/today/optimizing-the-garbage-collector-when-migrating-cloud-workloads/" rel="noopener noreferrer"&gt;Optimizing the Garbage Collector when Migrating Cloud Workloads&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Java&amp;rsquo;s &amp;ldquo;write once, run anywhere&amp;rdquo; promise makes moving applications from x86 machines to Arm-based cloud instances like AWS Graviton or Azure Cobalt fairly smooth, but getting peak performance on Arm Neoverse still requires tuning the garbage collector (GC). The post recommends using OpenJDK 11 or newer to pick up optimizations for modern Arm platforms, starting with G1 as a safe default for most server workloads thanks to its balance of throughput and latency, and considering ZGC or Shenandoah (Java 17+) for latency-sensitive applications with large heaps.&lt;/p&gt;
&lt;p&gt;On configuration, the author suggests setting &lt;code&gt;-XX:MaxGCPauseMillis&lt;/code&gt; to define a pause-time target and let the JVM self-tune, enabling &lt;code&gt;-XX:+UseAdaptiveSizePolicy&lt;/code&gt; so the JVM adjusts heap and generation sizes to real traffic, and sizing the heap carefully to balance collection frequency against pause duration. Finally, turn on GC logging with &lt;code&gt;-Xlog:gc&lt;/code&gt; and use Java Flight Recorder to inspect GC behavior, because only testing under realistic production workloads will tell you which settings meet your performance goals.&lt;/p&gt;
&lt;h2 id="how-javascript-works-behind-the-scenes"&gt;&lt;a href="https://www.deepintodev.com/blog/how-javascript-works-behind-the-scenes" rel="noopener noreferrer"&gt;How JavaScript Works Behind the Scenes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;JavaScript is single-threaded, so how does it handle asynchronous work without freezing up? This post explains the internals of a JavaScript engine (such as V8 in Chrome and Node.js), which centers on two components: the heap, where objects and variables live in memory, and the call stack, which tracks program execution and reflects JavaScript&amp;rsquo;s single thread of control. Every function call pushes a new execution context onto the stack containing local variables, arguments, the &lt;code&gt;this&lt;/code&gt; binding, and a reference to the outer scope; because contexts run sequentially, a heavy loop on the stack blocks everything behind it.&lt;/p&gt;
&lt;p&gt;To avoid blocking, slow operations are handed off to browser Web APIs like &lt;code&gt;fetch&lt;/code&gt;, &lt;code&gt;setTimeout&lt;/code&gt;, or geolocation. When they finish, their callbacks land in the task queue, whereas Promise-based continuations (&lt;code&gt;.then&lt;/code&gt;, &lt;code&gt;.catch&lt;/code&gt;, &lt;code&gt;async/await&lt;/code&gt;) go into the microtask queue. The event loop continuously watches the call stack, and whenever the stack is empty it drains the entire microtask queue before pulling the next regular task. That is why Promise callbacks typically run before &lt;code&gt;setTimeout&lt;/code&gt; callbacks, and how JavaScript stays non-blocking without extra execution threads—even though a CPU-heavy loop can still freeze the UI.&lt;/p&gt;
&lt;h2 id="why-embedding-models-should-match--advice-for-starting-a-blog"&gt;&lt;a href="https://foojay.io/today/breaktime-tech-talks-ep39-why-embedding-models-should-match-advice-for-starting-a-blog/" rel="noopener noreferrer"&gt;Why embedding models should match + Advice for starting a blog&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this episode of Breaktime Tech Talks, Jennifer Reif shares a practical lesson on why embedding models have to match. She generated vectors in Pinecone and Neo4j using two different OpenAI models (&lt;code&gt;text-embedding-ada-002&lt;/code&gt; and &lt;code&gt;text-embedding-3-small&lt;/code&gt;), then queried them from her application using a mismatched model. Even within the same provider family, the vector representations differed enough that similarity search returned nonsensical matches or nothing at all. The fix is to use the exact same embedding model for both stored documents and application queries; even then, different vector databases can return slightly different results due to their own similarity-search implementations—something to keep in mind when building RAG systems.&lt;/p&gt;
&lt;p&gt;The second half offers advice for starting a technical blog: write for yourself first, documenting your learning journey and how you solved problems so you can look them up later; keep a natural, conversational tone; let completed projects serve as a ready-made outline and edit just enough without over-polishing; remember that readers will skim for the section they need; and prioritize writing about problems you struggled to find answers for online, since others are likely searching for the exact same thing.&lt;/p&gt;
&lt;h2 id="hula-human-in-the-loop-llm-based-agents-for-software-development"&gt;&lt;a href="https://www.atlassian.com/blog/atlassian-engineering/hula-blog-autodev-paper-human-in-the-loop-software-development-agents" rel="noopener noreferrer"&gt;HULA: Human-in-the-loop LLM-based agents for software development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Atlassian introduces HULA, a human-in-the-loop LLM agent framework designed to automate routine development tasks while keeping engineers in control. Accepted to the ICSE 2025 SEIP track, the workflow runs in four stages: an engineer selects a Jira issue and adds context; HULA drafts a plan listing the files and changes required for the engineer to approve or revise; HULA generates code, using compiler and linter feedback to iterate until it passes checks before waiting for engineer review; and finally the approved changes are opened as a pull request following the team&amp;rsquo;s normal process. At the time of writing, Atlassian reported that roughly 900 HULA-generated pull requests had been merged.&lt;/p&gt;
&lt;p&gt;In a September 2024 evaluation on SWE-bench Verified, HULA passed unit tests on 31% of issues, and a GPT-based metric judged its patches highly similar to human solutions in 45% of cases. Across 663 real Jira issues over two months, HULA produced a plan for 79% of items (82% of which engineers approved), generated code for 87% of approved plans, reached a pull request on 25%, and saw 59% of those PRs merged. Surveying 109 engineers showed 62% agreed HULA identified the right files to change and 61% found its code easy to understand, though only 33% felt the generated code fully solved the task. Engineers valued the time savings and better documentation, but still had to manually finish functionality and wanted a smoother UX.&lt;/p&gt;
&lt;h2 id="refactoring-gone-wild-avoiding-code-smells-and-cleaning-up-the-mess"&gt;&lt;a href="https://techhub.iodigital.com/articles/refactoring-gone-wild-avoiding-code-smells-and-cleaning-up-the-mess" rel="noopener noreferrer"&gt;Refactoring Gone Wild: Avoiding Code Smells and Cleaning Up the Mess&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Refactoring is a core engineering skill, but doing it well starts with spotting code smells. Using Kotlin examples, this article walks through more than ten common smells: the Pyramid of Doom (deeply nested conditionals), inconsistent naming, mysterious parameters, god functions, forests of null checks, tangled boolean expressions, chaotic error handling, overuse of mutable collections, duplicated validation logic, and misused coroutines. Each smell makes code harder to read, harder to maintain, and more complex than it needs to be.&lt;/p&gt;
&lt;p&gt;For every smell, the author pairs a concrete remedy: flatten nesting with guard clauses, standardize naming conventions, group related parameters into a &lt;code&gt;data class&lt;/code&gt;, split large functions into small testable ones, use safe-call and Elvis operators for nulls, extract named helper functions for complex boolean conditions, centralize error handling and validation, default to immutability, adopt structured concurrency, and lean on standard-library helpers like &lt;code&gt;groupBy&lt;/code&gt;, &lt;code&gt;takeIf&lt;/code&gt;, and &lt;code&gt;runCatching&lt;/code&gt;. The closing message is that &amp;ldquo;small, incremental improvements add up to a big difference&amp;rdquo;: you don&amp;rsquo;t need a massive rewrite—just steady cleanup to keep code readable and maintainable.&lt;/p&gt;
&lt;h2 id="how-to-write-error-messages-that-actually-help-users-rather-than-frustrate-them"&gt;&lt;a href="https://piccalil.li/blog/how-to-write-error-messages-that-actually-help-users-rather-than-frustrate-them/" rel="noopener noreferrer"&gt;How to write error messages that actually help users rather than frustrate them&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Error messages show up at the exact moment a user is already stuck, yet they are often written in robotic jargon. This post lays out a practical approach to writing error messages that genuinely help: start by auditing every place an error can occur—form fields, validation checks, 404 and 500 pages, empty search results, and dropped connections. Then write as if you were sitting next to the person and walking them through it: instead of &amp;ldquo;Invalid input,&amp;rdquo; write &amp;ldquo;Please enter the 6-digit code we emailed you&amp;rdquo;; instead of &amp;ldquo;No WiFi connection detected,&amp;rdquo; write &amp;ldquo;It looks like you&amp;rsquo;re offline—connect to WiFi and try again.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The author advises skipping cute or joking copy, which makes frustrated users feel their problem isn&amp;rsquo;t being taken seriously; the post cites a shopper who abandoned their cart after a typo triggered a message calling them a &amp;ldquo;silly sausage.&amp;rdquo; Use active voice to state clearly what went wrong and why—for example, &amp;ldquo;We couldn&amp;rsquo;t process your application because that file format isn&amp;rsquo;t supported; please re-attach it as a JPEG.&amp;rdquo; When users can fix the issue themselves, tell them the exact step to take; when they can&amp;rsquo;t, offer a clear fallback such as a retry button, support contact details, or reassurance that their work was saved. Finally, document message patterns for common scenarios to keep tone and clarity consistent across the product.&lt;/p&gt;
&lt;h2 id="the-difficulty-in-big-tech"&gt;&lt;a href="https://www.seangoedecke.com/difficulty-in-big-tech/" rel="noopener noreferrer"&gt;The difficulty in big tech&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many people assume big tech companies move slowly because of bad processes or lazy engineers, but Sean Goedecke argues the real culprit is accumulated feature complexity. Every new feature can interact with every existing feature, causing the number of interactions engineers must reason about to explode as a product matures. Worse are &amp;ldquo;evil&amp;rdquo; cross-cutting features that touch the entire system: adding a new user type, for instance, forces engineers to audit permissions across every existing feature and remember that constraint forever after. The resulting cognitive load is so heavy that &amp;ldquo;getting anything done at all is really, really hard,&amp;rdquo; making it easy for engineers to miss even seemingly obvious edge cases.&lt;/p&gt;
&lt;p&gt;So why do big companies keep shipping features anyway? Because they make money: as Dan Luu has noted, seemingly minor features can each add a few percentage points of revenue, and 1% of revenue on products like Google Ads or AWS S3 is an enormous sum. In Goedecke&amp;rsquo;s view, big-tech slowness isn&amp;rsquo;t a sign of organizational dysfunction—it is a deliberate trade-off that accepts slower development velocity in exchange for the revenue of a densely featured product.&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 #28</title><link>https://miti99.com/en/post/2025/05/15/</link><pubDate>Thu, 15 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/15/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #28.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-airbnb-measures-listing-lifetime-value"&gt;&lt;a href="https://medium.com/airbnb-engineering/how-airbnb-measures-listing-lifetime-value-a603bf05142c" rel="noopener noreferrer"&gt;How Airbnb Measures Listing Lifetime Value&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Airbnb&amp;rsquo;s Data Science team introduces their framework for measuring Listing Lifetime Value (LTV) on a two-sided marketplace where many hosts and guests interact simultaneously. The framework builds on three metrics. &lt;em&gt;Baseline LTV&lt;/em&gt; is the total booking value a listing is expected to generate over the next 365 days, predicted via machine learning from features like calendar availability, nightly price, location, and host tenure, then discounted to present value. &lt;em&gt;Incremental LTV&lt;/em&gt; subtracts marketplace cannibalization from Baseline LTV—accounting for bookings that would have gone to another Airbnb listing if the new listing didn&amp;rsquo;t exist. Finally, &lt;em&gt;Marketing Incremental LTV&lt;/em&gt; isolates the additional value genuinely driven by Airbnb&amp;rsquo;s own host-acquisition campaigns.&lt;/p&gt;
&lt;p&gt;Putting this into production required solving three tough challenges. First, ground-truth labels take a full 365 days to mature, making models vulnerable to sudden market shifts like COVID-19; the team shortened training windows, added fine-grained geospatial features, and migrated to LightGBM. Second, true marketplace incrementality is never directly observable, so they estimate an economic production function modeling how total supply and demand in each local market segment combine to produce bookings—in high-demand, supply-constrained markets, adding a new listing generates far more incremental value. Third, to reduce early prediction uncertainty, the model dynamically updates LTV estimates daily as real booking signals roll in.&lt;/p&gt;
&lt;h2 id="six-jdk-24-features-you-should-know-about"&gt;&lt;a href="https://foojay.io/today/six-jdk-24-features-you-should-know-about/" rel="noopener noreferrer"&gt;Six JDK 24 Features You Should Know About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Ritter (Azul) highlights six standout features in JDK 24, released on March 18, 2025 with 24 JEPs—the largest feature count of any release since Java switched to its six-month release cadence. JEP 483, from Project Leyden, pre-loads and links application classes at build time on top of Application Class Data Sharing so they are ready immediately on JVM startup, cutting warmup time. JEP 485 (Stream Gatherers) finalizes the &lt;code&gt;Gatherer&lt;/code&gt; interface so developers can build custom intermediate &lt;code&gt;Stream&lt;/code&gt; operations, much like &lt;code&gt;Collector&lt;/code&gt; enables custom terminal operations. JEP 491 removes a major virtual-thread footgun: previously, blocking inside a &lt;code&gt;synchronized&lt;/code&gt; block &amp;ldquo;pinned&amp;rdquo; the underlying platform carrier thread because monitors were owned by carrier threads; now, monitors are associated directly with virtual threads.&lt;/p&gt;
&lt;p&gt;The other three JEPs focus on platform cleanup and security modernization. JEP 486 permanently disables the &lt;code&gt;SecurityManager&lt;/code&gt;, which was deprecated in JDK 17 and is rarely used to protect modern server-side code; any legacy applications still relying on it will need architectural changes before upgrading. JEP 498 causes the JVM to emit a runtime warning the first time any memory-access method in &lt;code&gt;sun.misc.Unsafe&lt;/code&gt; is called, nudging libraries toward &lt;code&gt;VarHandle&lt;/code&gt; and the Foreign Function &amp;amp; Memory API. Finally, JEP 501 deprecates the 32-bit x86 port for removal (Linux was the last remaining 32-bit x86 port after Windows 32-bit was removed in JDK 21). It&amp;rsquo;s a handy checklist as teams prepare for JDK 25, the next LTS release.&lt;/p&gt;
&lt;h2 id="javaone-2025-function-and-memory-access-in-pure-java"&gt;&lt;a href="https://www.infoq.com/news/2025/04/foreign-function-minborg/" rel="noopener noreferrer"&gt;JavaOne 2025: Function and Memory Access in Pure Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This InfoQ report covers Per-Åke Minborg&amp;rsquo;s (Oracle) JavaOne 2025 presentation on the Foreign Function &amp;amp; Memory API (FFM, JEP 454), finalized in JDK 22 under Project Panama as a modern replacement for JNI. As Minborg explained, JNI forces developers to stitch Java and C together in a brittle, high-maintenance workflow with clunky data marshaling, support limited to primitives and Java objects, no deterministic off-heap memory deallocation, and a ~2 GB addressing limit on &lt;code&gt;ByteBuffer&lt;/code&gt;. Community alternatives like JNA, JNR, and JavaCPP tried to bridge the gap over the years, but none became a universal standard.&lt;/p&gt;
&lt;p&gt;On the memory side, &lt;code&gt;MemorySegment&lt;/code&gt; models a contiguous region of 64-bit addressable memory with spatial bounds checks, temporal checks against use-after-free, and thread-confinement enforcement. Memory lifecycles are managed deterministically via &lt;code&gt;Arena&lt;/code&gt; across four flavors: Global, Auto, Confined, and Shared. &lt;code&gt;ValueLayout&lt;/code&gt; and &lt;code&gt;MemoryLayout&lt;/code&gt; describe structured off-heap data so you can derive strongly typed &lt;code&gt;VarHandle&lt;/code&gt; accessors instead of calculating raw byte offsets by hand—and declaring those &lt;code&gt;VarHandle&lt;/code&gt; instances &lt;code&gt;static final&lt;/code&gt; is critical for JIT inlining and peak performance. On the function side, the &lt;code&gt;jextract&lt;/code&gt; tool automatically generates Java bindings directly from native C header files, letting Java code call C functions like &lt;code&gt;qsort&lt;/code&gt; directly. In short, FFM delivers safe, high-performance off-heap memory access and native function calls in pure Java without writing or maintaining a single line of C glue code.&lt;/p&gt;
&lt;h2 id="ultimate-guide-to-project-reactor-thread-locals-and-context-propagation"&gt;&lt;a href="https://4comprehension.com/ultimate-guide-to-project-reactor-thread-locals-and-context-propagation/" rel="noopener noreferrer"&gt;Ultimate Guide to Project Reactor, Thread-Locals and Context Propagation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Grzegorz Piwowarek explains why context propagation is notoriously tricky in Project Reactor. A &lt;code&gt;ThreadLocal&amp;lt;X&amp;gt;&lt;/code&gt; is conceptually a &lt;code&gt;Map&amp;lt;Thread, X&amp;gt;&lt;/code&gt;, whereas a reactive pipeline can hop across threads at any &lt;code&gt;publishOn()&lt;/code&gt; or &lt;code&gt;subscribeOn()&lt;/code&gt; boundary, leaving thread-local values behind. Reactor&amp;rsquo;s native solution is its immutable &lt;code&gt;Context&lt;/code&gt;: you write values downstream-to-upstream via &lt;code&gt;contextWrite()&lt;/code&gt; and read them inside the pipeline by replacing &lt;code&gt;map()&lt;/code&gt; with &lt;code&gt;flatMap()&lt;/code&gt; + &lt;code&gt;Mono.deferContextual()&lt;/code&gt;. Piwowarek also points out a simple rule of thumb: if you already have the value before assembling the reactive pipeline, just capture it in a normal lexical variable instead of overcomplicating things with &lt;code&gt;Context&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The harder challenge is integrating with third-party libraries that expect classic &lt;code&gt;ThreadLocal&lt;/code&gt; state, such as SLF4J&amp;rsquo;s &lt;code&gt;MDC&lt;/code&gt; for structured logging: you have to restore the value into &lt;code&gt;MDC&lt;/code&gt; right before each operator lambda executes and clear it afterward, which can be wrapped cleanly using the execute-around pattern in a helper like &lt;code&gt;withMDC()&lt;/code&gt;. For side-effect operators like &lt;code&gt;doOnNext()&lt;/code&gt; that don&amp;rsquo;t expose &lt;code&gt;Context&lt;/code&gt; directly, you can switch to &lt;code&gt;doOnEach()&lt;/code&gt;, filter for &lt;code&gt;onNext&lt;/code&gt; signals, and read the context from the &lt;code&gt;Signal&lt;/code&gt; object. Finally, Reactor supports automatic context propagation: by adding &lt;code&gt;io.micrometer:context-propagation&lt;/code&gt;, calling &lt;code&gt;Hooks.enableAutomaticContextPropagation()&lt;/code&gt;, and registering a &lt;code&gt;ThreadLocalAccessor&lt;/code&gt;, Reactor automatically snapshots and restores thread-local values across operator boundaries. While convenient, this global JVM hook adds runtime overhead to every reactive pipeline in the process, so weigh the trade-off carefully.&lt;/p&gt;
&lt;h2 id="jdk-24-g1parallelserial-gc-changes"&gt;&lt;a href="https://tschatzl.github.io/2025/04/01/jdk24-g1-serial-parallel-gc-changes.html" rel="noopener noreferrer"&gt;JDK 24 G1/Parallel/Serial GC Changes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas Schatzl (Oracle) rounds up the improvements to HotSpot&amp;rsquo;s stop-the-world garbage collectors—G1, Parallel, and Serial—in JDK 24. In Parallel GC, redundant synchronization operations inside the object evacuation loop were removed (JDK-8269870), while Serial GC received ongoing code cleanup and refactoring. The most impactful changes landed in G1: to meet pause-time targets, G1 predicts internal operation costs like object copying and reference updating, but its initial default estimates had been calibrated years ago on an old SPARC machine and were overly conservative, causing G1 to take around 30 GC cycles to adapt to modern hardware. With JDK-8343189, the very first real runtime measurement immediately overrides the static default, allowing G1 to adapt dramatically faster at the slight risk of exceeding pause targets during the first couple of collections. Additionally, G1 now manages the remembered set for the entire young generation as a single unified structure (JDK-8336086), reducing duplication and saving native memory.&lt;/p&gt;
&lt;p&gt;Schatzl also previews the JDK 25 roadmap: merging remembered sets across old-generation regions (JDK-8343782) is already integrated, and G1&amp;rsquo;s write barrier has been redesigned from the ground up, promising up to 10% higher throughput, shorter pauses, and cleaner JIT-compiled code in exchange for a static memory overhead of roughly 0.2% of the heap size. Ongoing discussions also include bringing ZGC-style Automatic Heap Sizing to G1/Parallel/Serial with contributions from Microsoft and Google, as well as making G1 the true default collector even on small-memory containers where HotSpot currently falls back to Serial GC.&lt;/p&gt;
&lt;h2 id="making-makefiles-for-fun-and-profit"&gt;&lt;a href="https://dev.to/aws/making-makefiles-for-fun-and-profit-kl6" rel="noopener noreferrer"&gt;Making Makefiles for fun and profit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Darko Mesaroš (AWS) revisits &lt;code&gt;make&lt;/code&gt;, the 48-year-old build automation tool created by Stuart Feldman so programmers wouldn&amp;rsquo;t keep debugging stale binaries after forgetting to recompile a modified file. Unlike a naive &lt;code&gt;build.sh&lt;/code&gt; script that recompiles everything from scratch, &lt;code&gt;make&lt;/code&gt; tracks file modification timestamps and rebuilds only what changed. Mesaroš dissects a classic C &lt;code&gt;Makefile&lt;/code&gt;: variables (which &lt;code&gt;make&lt;/code&gt; calls macros), the default &lt;code&gt;all&lt;/code&gt; target, link rules using automatic variables like &lt;code&gt;$@&lt;/code&gt; and &lt;code&gt;$^&lt;/code&gt;, pattern rules like &lt;code&gt;%.o: %.c&lt;/code&gt; for compiling individual source files, a &lt;code&gt;clean&lt;/code&gt; target, and &lt;code&gt;.PHONY&lt;/code&gt; declarations so targets still run even if a file of the same name exists in the directory.&lt;/p&gt;
&lt;p&gt;The second half shows how &lt;code&gt;make&lt;/code&gt; shines far beyond C projects: wrapping Terraform workflows with OS detection and interactive confirmation prompts before running &lt;code&gt;terraform destroy&lt;/code&gt;, spinning up local Docker development environments with Postgres and Redis for a Rust service, orchestrating a polyglot TypeScript + Rust AWS CDK project with targets for installing, building, deploying individual stacks, and testing locally against DynamoDB Local, and deploying a Hugo static site to S3 and AWS Amplify. To get past &lt;code&gt;make&lt;/code&gt;&amp;rsquo;s famously arcane syntax, Mesaroš uses the Amazon Q Developer CLI to generate &lt;code&gt;Makefile&lt;/code&gt; rules—even dynamically querying the Amplify App ID via the AWS CLI. It&amp;rsquo;s a fun reminder that battle-tested Unix tools are still worth learning, especially when AI assistants remove the initial syntax friction.&lt;/p&gt;
&lt;h2 id="improving-pinterest-search-relevance-using-large-language-models"&gt;&lt;a href="https://medium.com/pinterest-engineering/improving-pinterest-search-relevance-using-large-language-models-4cd938d4e892" rel="noopener noreferrer"&gt;Improving Pinterest Search Relevance Using Large Language Models&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pinterest&amp;rsquo;s engineering team shares how they used large language models (LLMs) to improve search relevance—measuring how well a Pin actually satisfies a user&amp;rsquo;s search query rather than relying purely on historical click engagement. Their &amp;ldquo;teacher&amp;rdquo; model is a cross-encoder that takes the search query alongside a rich text representation of a Pin, fine-tuned on human-labeled relevance ratings as a multi-class classification task. Because Pins are primarily visual, the team enriches each Pin&amp;rsquo;s text from multiple sources: title and description, synthetic image captions generated by a BLIP vision-language model, top historically engaged search queries, user board titles where the Pin was saved, and linked web page titles. Offline evaluations showed that a fine-tuned Llama-3-8B model (using QLoRA) outperformed multilingual BERT by 12.5% and the production baseline by 19.7% in accuracy.&lt;/p&gt;
&lt;p&gt;Because serving an 8B-parameter LLM directly on every search request is too slow and expensive, Pinterest uses knowledge distillation: the teacher LLM labels billions of query-Pin pairs offline each day to train a lightweight &amp;ldquo;student&amp;rdquo; model that combines precomputed embeddings (SearchSAGE, PinSAGE, visual embeddings) with lexical match features like BM25. Thanks to the multilingual teacher model, the student generalizes well even to languages and countries with zero human-labeled training data. In online A/B tests, the distilled model improved relevance by 2.18% in nDCG@20 and boosted overall search fulfillment rate by over 1.5%. Future work includes direct real-time LLM serving, native vision-language models, and active learning.&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 #21</title><link>https://miti99.com/en/post/2025/05/08/</link><pubDate>Thu, 08 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/08/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #21.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-to-monitor-jvm"&gt;&lt;a href="https://www.baeldung.com/java-jvm-monitor-non-heap-memory-usage" rel="noopener noreferrer"&gt;How to Monitor JVM&amp;rsquo;s Non-Heap Memory Usage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Baeldung article surveys tools for monitoring JVM non-heap memory usage—the memory regions outside the heap such as Metaspace, JIT code cache, GC structures, and direct buffers. The simplest option is &lt;code&gt;jcmd&lt;/code&gt;: once Native Memory Tracking is enabled, running &lt;code&gt;jcmd &amp;lt;pid&amp;gt; VM.native_memory&lt;/code&gt; prints the reserved and committed memory for each region. If you prefer a GUI, &lt;code&gt;jconsole&lt;/code&gt; includes a built-in non-heap chart under the Memory tab, while VisualVM displays Metaspace out of the box and can be extended with the MBeans and Buffer Pools plugins to inspect individual regions and direct buffers.&lt;/p&gt;
&lt;p&gt;For deeper analysis, Java Mission Control (JMC) lets you inspect total non-heap memory via the MBean Browser (note that this figure excludes direct buffers), and starting in Java 20 you can continuously record Native Memory Tracking events via JFR to track consumption by memory category over time. Finally, the JMX Exporter exposes &lt;code&gt;MemoryMXBean&lt;/code&gt; metrics at a Prometheus-compatible &lt;code&gt;/metrics&lt;/code&gt; endpoint, integrating non-heap monitoring into existing observability stacks. The author&amp;rsquo;s rule of thumb: use &lt;code&gt;jcmd&lt;/code&gt; or &lt;code&gt;jconsole&lt;/code&gt; for quick checks, pair JFR with JMC when you need fine-grained detail, and always account for the resource overhead of the monitoring tools themselves.&lt;/p&gt;
&lt;h2 id="unlocking-the-power-of-interfaces-creative-approaches-in-java"&gt;&lt;a href="https://gainjavaknowledge.medium.com/unlocking-the-power-of-interfaces-creative-approaches-in-java-635f390a1e0d" rel="noopener noreferrer"&gt;Unlocking the Power of Interfaces: Creative Approaches in Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Medium post by Real World Java (Gain Java Knowledge) shows that Java interfaces are more than just contracts for classes to implement—they are powerful tools for decoupling components and making code extensible, reusable, and maintainable. The author walks through eight creative uses of interfaces, starting with the Strategy pattern: defining an interface like &lt;code&gt;PaymentStrategy&lt;/code&gt; for a family of algorithms and swapping concrete implementations (credit card, PayPal, etc.) at runtime. Next are callback interfaces that allow called code to invoke caller-supplied logic, functional interfaces paired with Java 8 lambda expressions, and mixin interfaces—where a class combines behavior from multiple interfaces to achieve multiple inheritance of behavior.&lt;/p&gt;
&lt;p&gt;The remaining sections cover dependency injection through interfaces to reduce tight coupling between classes, the Observer pattern, polymorphism when storing heterogeneous objects in a single collection typed to a shared interface, and default methods that add new functionality to interfaces without breaking existing implementations. For newer Java developers, the post serves as a concise collection of examples showing how interfaces underpin many classic design patterns.&lt;/p&gt;
&lt;h2 id="how-java-manages-thread-synchronization-with-locks-and-monitors"&gt;&lt;a href="https://medium.com/@AlexanderObregon/how-java-manages-thread-synchronization-with-locks-and-monitors-541ce7c7a0b2" rel="noopener noreferrer"&gt;How Java Manages Thread Synchronization with Locks and Monitors&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexander Obregon explains how Java handles thread synchronization at the JVM level. Every object is associated with an intrinsic lock and a monitor; when a thread enters a &lt;code&gt;synchronized&lt;/code&gt; method or block, it must acquire ownership of the monitor while other contending threads wait (the JVM may spin briefly or park the thread depending on contention). The monitor tracks which thread holds the lock, which threads are waiting in the entry set, and which threads are waiting for a signal via &lt;code&gt;wait()&lt;/code&gt;, &lt;code&gt;notify()&lt;/code&gt;, or &lt;code&gt;notifyAll()&lt;/code&gt;—methods that may only be called while holding the lock, or else an &lt;code&gt;IllegalMonitorStateException&lt;/code&gt; is thrown. Intrinsic locks are reentrant: a thread that already holds a lock can acquire it again thanks to a recursion counter inside the monitor. To reduce overhead, the JVM uses lightweight locking first and only &amp;ldquo;inflates&amp;rdquo; to a full monitor under sustained contention; biased locking was used historically but has been disabled by default since JDK 15.&lt;/p&gt;
&lt;p&gt;The second half introduces &lt;code&gt;ReentrantLock&lt;/code&gt; in &lt;code&gt;java.util.concurrent.locks&lt;/code&gt;, which offers more flexibility than &lt;code&gt;synchronized&lt;/code&gt; via &lt;code&gt;tryLock()&lt;/code&gt; for non-blocking acquisition attempts, &lt;code&gt;lockInterruptibly()&lt;/code&gt; so waiting threads can respond to interrupts, and multiple &lt;code&gt;Condition&lt;/code&gt; objects to maintain separate wait queues per condition, such as in a bounded producer-consumer buffer. Under the hood sits &lt;code&gt;AbstractQueuedSynchronizer&lt;/code&gt; (AQS), which manages waiting threads using a doubly linked FIFO queue and &lt;code&gt;LockSupport.park()&lt;/code&gt;. The article also notes fair locks, which grant access to the longest-waiting thread at the cost of lower throughput, which is why most systems stick with the non-fair default.&lt;/p&gt;
&lt;h2 id="building-a-custom-spring-boot-starter-for-shared-logic"&gt;&lt;a href="https://medium.com/@AlexanderObregon/building-a-custom-spring-boot-starter-for-shared-logic-9be5699aff18" rel="noopener noreferrer"&gt;Building a Custom Spring Boot Starter for Shared Logic&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alexander Obregon walks through packaging shared cross-cutting logic—such as logging setup, exception handling, or database configuration—into a custom Spring Boot starter instead of copy-pasting it across projects. At the core of a starter is auto-configuration: a class annotated with &lt;code&gt;@AutoConfiguration&lt;/code&gt; declares beans alongside conditional annotations like &lt;code&gt;@ConditionalOnMissingBean&lt;/code&gt; (backing off if the application defines its own bean) or &lt;code&gt;@ConditionalOnClass&lt;/code&gt; (activating only when required classes are on the classpath). Starting in Spring Boot 3, auto-configuration classes are registered in &lt;code&gt;META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports&lt;/code&gt; rather than the legacy &lt;code&gt;spring.factories&lt;/code&gt;, while &lt;code&gt;@ConfigurationProperties&lt;/code&gt; and &lt;code&gt;@EnableConfigurationProperties&lt;/code&gt; let consumers customize behavior via &lt;code&gt;application.properties&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The second half covers packaging and publishing. For third-party starters, Spring&amp;rsquo;s documentation recommends naming modules &lt;code&gt;&amp;lt;name&amp;gt;-spring-boot-starter&lt;/code&gt;, reserving the &lt;code&gt;spring-boot&lt;/code&gt; prefix for official Spring artifacts. The remaining steps include adding &lt;code&gt;spring-boot-autoconfigure&lt;/code&gt; and the configuration metadata annotation processor for IDE autocomplete, running &lt;code&gt;mvn clean install&lt;/code&gt; to test locally, and publishing to an internal or public Maven repository. Obregon also advises keeping starters lean and marking non-essential dependencies as &lt;code&gt;optional&lt;/code&gt; to avoid version conflicts in consuming applications. Once structured properly, Spring Boot automatically wires everything up on startup.&lt;/p&gt;
&lt;h2 id="real-world-garbage-collection-solutions"&gt;&lt;a href="https://dzone.com/articles/real-world-garbage-collection-solutions" rel="noopener noreferrer"&gt;Real-World Garbage Collection Solutions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DZone article presents real-world case studies showing how tuning garbage collection (GC) can deliver major performance gains at minimal cost. First, the author outlines the key metrics to watch: throughput (the percentage of time the application spends doing real work, which should be around 99% for critical systems), GC pause latency, CPU time spent in GC, and overall response time. To gather data, enable GC logging with &lt;code&gt;-Xlog:gc*:file=&amp;lt;path&amp;gt;&lt;/code&gt; (Java 9+) or &lt;code&gt;-XX:+PrintGCDetails -Xloggc:&amp;lt;path&amp;gt;&lt;/code&gt; (Java 8 and earlier) and analyze the logs with a tool like GCeasy.&lt;/p&gt;
&lt;p&gt;Three case studies illustrate the impact. An insurance company suffered back-to-back Full GCs during peak hours; adding memory and resizing the heap boosted throughput by 23% and cut GC CPU usage in half. A warehouse robotics control application running CMS on a 126 GB heap experienced occasional pauses lasting up to 5 minutes; switching to G1 brought the worst-case pause down to about 2 seconds with an average of 198 ms. Finally, a cloud service provider running Parallel GC with a 40 GB heap split evenly between young and old generations shrank the young generation to 1 GB, raising throughput to 99% and dropping average pause time from 12 seconds to 139 ms. Takeaway: when a Java application slows down, GC analysis should be your first stop.&lt;/p&gt;
&lt;h2 id="java-naming-conventions"&gt;&lt;a href="https://www.baeldung.com/java-naming-conventions" rel="noopener noreferrer"&gt;Java Naming Conventions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Baeldung summarizes the foundational Java naming conventions that keep codebases readable, consistent, and easy to collaborate on. Classes use &lt;code&gt;UpperCamelCase&lt;/code&gt; with nouns or noun phrases that clearly describe their role, like &lt;code&gt;CustomerAccount&lt;/code&gt;, avoiding abbreviations or vague names; interfaces also use &lt;code&gt;UpperCamelCase&lt;/code&gt; and express the capability implementing classes commit to, such as &lt;code&gt;Printable&lt;/code&gt;. Variables use &lt;code&gt;lowerCamelCase&lt;/code&gt;, while &lt;code&gt;static final&lt;/code&gt; constants use &lt;code&gt;UPPER_SNAKE_CASE&lt;/code&gt; like &lt;code&gt;MAX_BALANCE&lt;/code&gt;; methods use &lt;code&gt;lowerCamelCase&lt;/code&gt; starting with a verb that describes the action, such as &lt;code&gt;deposit()&lt;/code&gt; or &lt;code&gt;print()&lt;/code&gt;. Variables or methods holding or returning multiple elements should use plural names.&lt;/p&gt;
&lt;p&gt;Packages are written in all lowercase using reverse domain name notation—for example, &lt;code&gt;com.baeldung.namingconventions&lt;/code&gt;—to organize code cleanly and prevent namespace collisions. Enums use &lt;code&gt;UpperCamelCase&lt;/code&gt; for the type name and &lt;code&gt;UPPER_SNAKE_CASE&lt;/code&gt; for their constants (such as &lt;code&gt;DayOfWeek.MONDAY&lt;/code&gt;), and annotations follow &lt;code&gt;UpperCamelCase&lt;/code&gt; just like classes, e.g., &lt;code&gt;@Auditable&lt;/code&gt;. While simple, these conventions are essential habits for new Java developers to build early on.&lt;/p&gt;
&lt;h2 id="vibe-coding-vs-reality"&gt;&lt;a href="https://cendyne.dev/posts/2025-03-19-vibe-coding-vs-reality.html" rel="noopener noreferrer"&gt;Vibe Coding vs Reality&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cendyne pushes back against the &amp;ldquo;vibe coding&amp;rdquo; hype—the viral idea sparked by Andrej Karpathy of &amp;ldquo;giving in to the vibes&amp;rdquo; and forgetting the code exists while letting LLMs write everything. The author admits that AI coding agents like Cursor or GitHub Copilot in agent mode look magical when scaffolding a greenfield project from an empty folder, but that excitement quickly fades once the codebase grows. Working with Claude 3.7 Sonnet, Cendyne catalogs a long list of recurring blunders: duplicating TypeScript interfaces instead of importing them, recreating components that already exist, putting security-sensitive trust logic on the client side, mutating production code to match broken tests instead of fixing the tests, refactoring only one instance of duplicated code while leaving the rest untouched, and degenerating into gibberish once the context window fills up.&lt;/p&gt;
&lt;p&gt;According to the author, the core limitation is that models cannot genuinely learn new project knowledge on the fly, cannot monitor multiple real-time feedback streams simultaneously (such as server logs alongside end-to-end test output), and lack both short- and long-term organizational memory. The &amp;ldquo;Claude Plays Pokémon&amp;rdquo; experiment illustrates how even with handoff notes across context resets, the model keeps repeating the exact same mistakes. The verdict: vibe coding might get you 80% of the way to a prototype, but building reliable, secure software worth paying for still requires experienced humans.&lt;/p&gt;
&lt;h2 id="sell-yourself-sell-your-work"&gt;&lt;a href="https://www.solipsys.co.uk/new/SellYourselfSellYourWork.html" rel="noopener noreferrer"&gt;Sell Yourself, Sell Your Work&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short piece on &lt;code&gt;solipsys.co.uk&lt;/code&gt; reminds engineers that doing great technical work is not enough on its own: if you lock yourself in a room, produce brilliant work, and never tell anyone about it, nobody knows, nobody benefits, and the effort is effectively wasted. The author has met many talented engineers who avoid writing reports because they find it boring, difficult, and beside the point. In reality, writing and presenting clearly and concisely—since typos or sloppy prose are enough to lose a chunk of your audience—is how your work saves other people time and builds your own credibility.&lt;/p&gt;
&lt;p&gt;The post quotes Richard Hamming&amp;rsquo;s famous 1986 talk &amp;ldquo;You and Your Research&amp;rdquo;: finishing a piece of work is not enough—you have to &amp;ldquo;sell&amp;rdquo; it, because everyone is busy with their own problems; you must present it well enough that others are willing to set their own work aside to read yours, honing your skills in writing, formal talks, and informal hallway conversations alike. Even if you start your own company, you still have to sell your products and services. The closing message: let the world benefit from the work you do.&lt;/p&gt;
&lt;h2 id="building-resilient-payment-systems-at-ssense-our-journey-towards-asynchronous-processing"&gt;&lt;a href="https://medium.com/ssense-tech/building-resilient-payment-systems-at-ssense-our-journey-towards-asynchronous-processing-56d46dc2b348" rel="noopener noreferrer"&gt;Building Resilient Payment Systems at SSENSE: Our Journey Towards Asynchronous Processing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The engineering team at fashion e-commerce platform SSENSE shares how they migrated their payment system from synchronous to asynchronous processing. Their legacy architecture tightly coupled payment execution to the order lifecycle: certain payment service providers (PSPs) processed transactions in batches that left payment status unresolved for hours or even days, flash-sale traffic spikes strained the system, and refunds required complex manual intervention. Their solution was decoupling payment confirmation from order placement—moving orders into a pending state so checkout could proceed—while diversifying across multiple PSPs to reduce single-provider risk.&lt;/p&gt;
&lt;p&gt;In the new architecture, the payment service and its cron jobs (written in TypeScript and running on Kubernetes) share a database, receive PSP updates via webhooks, and publish domain events onto an event bus so the order service and financial integration layer can react asynchronously. Every transaction moves through explicit states: &lt;code&gt;Queued&lt;/code&gt;, &lt;code&gt;Pending&lt;/code&gt;, &lt;code&gt;Complete&lt;/code&gt;, &lt;code&gt;Declined&lt;/code&gt;, or &lt;code&gt;Failed&lt;/code&gt;. When an outbound request fails, the system retries immediately a few times before placing the transaction into &lt;code&gt;Queued&lt;/code&gt; for a cron job to replay later, using idempotency keys to prevent duplicate charges. Failed transactions automatically open customer support tickets, and a separate cron job detects transactions stuck in &lt;code&gt;Pending&lt;/code&gt;. The result is a smoother checkout experience, greater resilience during peak sales, and consistent data across downstream systems.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>