<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Machine Learning on miti99</title><link>https://miti99.com/en/tags/machine-learning/</link><description>Recent content in Machine Learning 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/machine-learning/index.xml" rel="self" type="application/rss+xml"/><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 #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></channel></rss>