<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Kubernetes on miti99</title><link>https://miti99.com/en/tags/kubernetes/</link><description>Recent content in Kubernetes 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/kubernetes/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #112</title><link>https://miti99.com/en/post/2026/06/23/</link><pubDate>Tue, 23 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/23/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #112.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-few-interesting-modern-pixel-fonts"&gt;&lt;a href="https://unsung.aresluna.org/a-few-interesting-modern-pixel-fonts/" rel="noopener noreferrer"&gt;A few interesting modern pixel fonts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marcin Wichary surveys a few modern pixel fonts built around interesting ideas. Andrew Gleeson&amp;rsquo;s Analog Mono &amp;ldquo;atones for the sins&amp;rdquo; of VCR OSD Mono, the classic pixel font seen across 1990s VCRs, TVs, and camcorders whose baseline sat so low that every character with a descender was pulled upward. Kumiko Yoshida&amp;rsquo;s Coral Pixels is a color font that deliberately preserves the characteristic color fringing of 1990s–2000s subpixel rendering: what used to be a technical artifact is now nostalgic material and an intentional visual element. Joseph Fatula&amp;rsquo;s Two Slice pushes minimalism to the extreme at just 2 pixels tall while remaining &amp;ldquo;barely readable.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The author notes that all of these are vector fonts masquerading as pixels so they can be installed on modern operating systems, which leads to Vercel&amp;rsquo;s Geist Pixel. Although its marketing pitch is slightly grandiose, it hits on an important problem: pixel fonts often break when put into real products because they don&amp;rsquo;t scale well across screen sizes, their metrics clash with existing typography systems, or they are purely decorative. According to the author, the Achilles&amp;rsquo; heel of many fonts lies not in the letterforms themselves, but in the &amp;ldquo;invisible&amp;rdquo; work around them such as kerning, metadata, extended character sets, and vertical metrics. The lesson for UI designers is that nostalgia can be a starting point, but integration stability is what determines whether a font is actually usable in a product.&lt;/p&gt;
&lt;h2 id="the-best-engineers-write-less-code"&gt;&lt;a href="https://shvetsm.github.io/posts/the-best-engineers-write-less-code/" rel="noopener noreferrer"&gt;The Best Engineers Write Less Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author pushes back against the idea that we no longer need to write good software because LLMs can generate code. Bad software is still bad software, whether written by Claude Code or an inexperienced developer: latency, complexity, and maintenance costs remain real, and there will be plenty of work cleaning up the low-quality code currently being pushed to production. Businesses measure everything in time, because time is money; that is also why they are excited about AI—it is faster and cheaper.&lt;/p&gt;
&lt;p&gt;According to the author, the best thing an engineer can do for stakeholders is avoid building unnecessary things, since every feature carries long-term costs in maintenance, debugging, infrastructure, support, migrations, and cognitive load. On the path to becoming a senior engineer, you shift from &amp;ldquo;I can build that, it&amp;rsquo;ll take a few days&amp;rdquo; to &amp;ldquo;Why are we building this?&amp;rdquo;, and the second question is critical: code is a liability unless it solves the right problem. The worst outcome is building the wrong thing. The way to reduce risk is genuine Agile in spirit rather than ceremony: align on why the work is needed, adjust requirements to deliver value faster, and work in short intervals to show progress and gather feedback. Great engineers are measured not by the volume of code they produce, but by the value they deliver relative to the complexity they leave behind—and the best use of spare time is deleting code.&lt;/p&gt;
&lt;h2 id="fast-is-better-than-slow"&gt;&lt;a href="https://dubroy.com/blog/fast-is-better-than-slow/" rel="noopener noreferrer"&gt;Fast is better than slow&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Patrick Dubroy noticed that the best programmers he has ever worked with all share one trait: they are fast, often turning up with a patch or prototype an hour or two after discussing a problem. He argues that they aren&amp;rsquo;t fast because they&amp;rsquo;re good, they&amp;rsquo;re good because they&amp;rsquo;re fast: moving quickly gets you data sooner, leads to better decisions, compounds learning over time, and lets you try multiple approaches before picking the best one. This does not mean hustle culture or working overtime; there are many ways to speed up without putting in extra hours.&lt;/p&gt;
&lt;p&gt;His advice has more to do with day-to-day software engineering habits than raw coding skill. Don&amp;rsquo;t procrastinate just because you aren&amp;rsquo;t sure where to start, as waiting rarely makes the task easier. Make use of small pockets of time instead of waiting for long uninterrupted blocks, since fragmentation can eat up 25–35% of your day. Don&amp;rsquo;t be afraid to look silly: share work early using the &amp;ldquo;70% rule,&amp;rdquo; open a PR right away and welcome feedback instead of polishing endlessly, and proactively ask coworkers for help because software development is a team sport. Pick your battles: in code review, most disagreements are small enough that making the requested change is faster than arguing, and Dubroy himself often approves with &amp;ldquo;LGTM with comments.&amp;rdquo; Finally, build only what was asked for—trying to &amp;ldquo;overdeliver&amp;rdquo; usually means guessing at future requirements, and the less experience you have, the more likely you are to guess wrong.&lt;/p&gt;
&lt;h2 id="java-cheat-sheet"&gt;&lt;a href="https://tms-outsource.com/cs/java-cheat-sheet/" rel="noopener noreferrer"&gt;Java Cheat Sheet&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a quick Java reference by Bogdan Sandu focused on syntax, common patterns, and immediately applicable idioms. The material is organized into sections: data types and casting, operators, control flow, arrays, strings and &lt;code&gt;StringBuilder&lt;/code&gt;, classes and objects, OOP concepts, access modifiers, the Collections Framework, exception handling, streams and lambdas, concurrency, I/O, and modern Java features. Helpfully, it doesn&amp;rsquo;t just list syntax—it also calls out classic beginner pitfalls like comparing &lt;code&gt;String&lt;/code&gt; instances with &lt;code&gt;==&lt;/code&gt;, confusing array &lt;code&gt;.length&lt;/code&gt; with string &lt;code&gt;.length()&lt;/code&gt;, handling &lt;code&gt;null&lt;/code&gt;, going out of array bounds, or concatenating strings in a loop instead of using &lt;code&gt;StringBuilder&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For junior developers, a cheat sheet like this is well suited for a quick refresher when switching to Java from another language, or when recalling a standard API without wading through long documentation. Even so, it should be treated as an initial lookup map: it does not replace official docs, a deep understanding of the JVM, OOP, collections, and concurrency, or hands-on experience writing production code.&lt;/p&gt;
&lt;h2 id="swapping-go-for-rust-10x-cheaper-k8s-ingress"&gt;&lt;a href="https://dev.to/syedahmershah/swapping-go-for-rust-10x-cheaper-k8s-ingress-2b4p" rel="noopener noreferrer"&gt;Swapping Go for Rust: 10x Cheaper K8s Ingress&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Syed Ahmer Shah recounts cutting the AWS bill for a Kubernetes ingress layer from roughly $4,200 to about $390 per month. The original setup ran Traefik across 3 pods, averaging around 380MB RSS per pod (roughly 180MB idle, over 400MB under load), requiring &lt;code&gt;t3.large&lt;/code&gt; nodes for headroom. The author attributes this to Go&amp;rsquo;s garbage collector, which optimizes for latency rather than memory footprint: in a proxy, every request allocates headers, buffers, and connection state, so under sustained load the GC rarely gets a &amp;ldquo;good moment&amp;rdquo; to clean up, whereas Rust frees memory deterministically as soon as values go out of scope. It is worth noting that this changed both the architecture and infrastructure (Envoy, smaller nodes), so it cannot be treated as an isolated benchmark of swapping languages alone.&lt;/p&gt;
&lt;p&gt;Rather than rewriting Traefik, the team moved core proxying to Envoy (C++) alongside a small Rust service that took over custom routing logic previously living in middleware. The first week hit three incidents—not because of Rust, but because Envoy&amp;rsquo;s explicit configuration model differed sharply from Traefik&amp;rsquo;s annotation &amp;ldquo;magic.&amp;rdquo; After about three weeks, the ingress layer dropped from 3 Traefik pods at ~380MB RSS each to 2 Envoy pods plus the Rust layer at ~40MB per pod; node costs fell from roughly $340 to $30 per month. The takeaway isn&amp;rsquo;t &amp;ldquo;replace Go with Rust&amp;rdquo;: Go remains a great fit for APIs, CLIs, and standard microservices, while Rust is worth considering for high-performance data planes. The migration took two engineers about three weeks, so if Traefik is working fine and the bill isn&amp;rsquo;t hurting, leave it alone.&lt;/p&gt;
&lt;h2 id="persistent-multiplayer-state-without-chaos"&gt;&lt;a href="https://packagemain.tech/p/persistent-multiplayer-state-without" rel="noopener noreferrer"&gt;Persistent multiplayer state without chaos&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julien Singler shares an architecture for maintaining consistent state in a live multiplayer game, where PostgreSQL holds the canonical data and Redis handles speed-critical operations. In a single-player game, state is relatively straightforward; but when multiple players can act on the same target simultaneously, scheduled jobs must finish on time regardless of who is online, and players returning days later expect their progress intact, state becomes the hardest problem. Keeping critical data only in memory or flushing to disk only on logout easily leads to lost progress or economy bugs.&lt;/p&gt;
&lt;p&gt;The Go backend is structured into handler, service, and repository layers. Every critical state change goes through a PostgreSQL transaction as the single source of truth. Read-heavy data is fetched from Redis first, falling back to PostgreSQL on a cache miss, and the cache is invalidated on writes before returning success so players never see stale state. Redis holds only rebuildable state such as caches, online presence, and short-lived locks: distributed locks via &lt;code&gt;SetNX&lt;/code&gt; ensure periodic jobs run only once across multiple backend instances (though bare &lt;code&gt;SetNX&lt;/code&gt; alone does not guarantee exactly-once processing if a crash or lock expiration occurs). Scheduled jobs rely on an indexed &lt;code&gt;finishes_at&lt;/code&gt; column rather than scanning every player every minute, and per-player mutations use &lt;code&gt;SELECT ... FOR UPDATE&lt;/code&gt; inside transactions instead of a custom lock manager.&lt;/p&gt;
&lt;h2 id="we"&gt;&lt;a href="https://plc.vc/cdx" rel="noopener noreferrer"&gt;We&amp;rsquo;re in the Over-engineering Game Now&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Clark writes that he spent his entire career priding himself on scoping projects to minimize engineering effort while maximizing flexibility, since engineering time is a software company&amp;rsquo;s scarcest resource. Yet he also loves product design and polished details, leaving him constantly torn between wanting to craft things more carefully and worrying about wasting resources. Now, using Claude and Codex on personal projects, he happily &amp;ldquo;over-engineers&amp;rdquo;: his blog has a dynamic changelog, a &amp;ldquo;vibe meter,&amp;rdquo; an MCP that generates weekly roundups, and hundreds of other ideas he tried and threw away.&lt;/p&gt;
&lt;p&gt;His central thesis is that AI coding blurs the line between over-engineering and simply finishing a product well. His iOS app no longer starts as a bare-bones MVP, but launches feature-complete with built-in feedback loops that trigger agentic workflows. Improvements that used to languish forever in the backlog because they were never high enough priority—or too small to even file a ticket for—can now be iterated on and polished continuously. He argues this shift will raise user expectations: when building good software becomes nearly free, clunky products will be much harder to excuse. Rather than merely an era of vibe coding or apps for an audience of one, he believes we are entering a phase where product vision is no longer bottlenecked by engineering resources, leaving only one question: what do you actually want to build?&lt;/p&gt;
&lt;h2 id="package-managers-that-package-package-managers"&gt;&lt;a href="https://nesbitt.io/2026/05/28/package-managers-that-package-package-managers.html" rel="noopener noreferrer"&gt;Package managers that package package managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Andrew Nesbitt built a matrix mapping which package managers can install which other package managers. The idea started from a strange loop: PyPI has a package containing the Node binary, and npm has a package containing a portable CPython build, meaning &lt;code&gt;pip install&lt;/code&gt; and &lt;code&gt;npm install&lt;/code&gt; can hand control back and forth indefinitely. Covering 42 clients using data from ecosyste.ms for language registries and Repology for Linux distributions, the densest rows belong to system package managers like AUR (40/42), nixpkgs, Homebrew, DNF, and Debian, since packaging arbitrary binaries is their job; as columns, however, they are nearly empty because nobody needs to redistribute &lt;code&gt;apt&lt;/code&gt; or DNF when they ship with the OS. Conda sits between the two worlds, while PyPI is the most prolific language registry because cross-language tools like Conan and Meson are written in Python.&lt;/p&gt;
&lt;p&gt;The post also highlights notable software supply chain implications. Twenty-five of the 42 tools publish themselves through their own registry. A CVE in pip might be tracked under &lt;code&gt;pkg:pypi/pip&lt;/code&gt; or &lt;code&gt;pkg:deb/python3-pip&lt;/code&gt;, but copies of pip inside Homebrew, conda-forge, nixpkgs, or Spack carry the same vulnerability and each ecosystem must map advisories on its own, making upstream vulnerability tracing much harder. Searching by package name is also unreliable because short names on flat-namespace registries are often squatted by unrelated projects, whereas reverse-linking to the source repository yields cleaner matches. Finally, the author constructs a 14-step installation chain stretching from an Arch Linux machine to the Elm compiler.&lt;/p&gt;
&lt;h2 id="beyond-the-prompt-claude-code"&gt;&lt;a href="https://arps18.github.io/posts/claude-code-mastery/" rel="noopener noreferrer"&gt;Beyond the Prompt: Claude Code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arpan Patel writes an extensive guide to using Claude Code as a workflow-driven agent rather than a prompt-in, code-out chatbot. The core focus is building feedback loops so Claude can verify its own work: reading code, planning, editing, running tests, reviewing, and updating its rules whenever it makes a mistake. The author recommends exploring before coding, using plan mode for multi-file changes, pointing directly to files or logs instead of giving vague descriptions, and delegating tasks the way you would to an engineer rather than micromanaging every small step.&lt;/p&gt;
&lt;p&gt;A standout section covers organizing the &lt;code&gt;.claude&lt;/code&gt; directory: &lt;code&gt;CLAUDE.md&lt;/code&gt; for shared project rules, &lt;code&gt;CLAUDE.local.md&lt;/code&gt; for personal notes, alongside settings, MCP servers, skills, commands, rules, and subagents. &lt;code&gt;CLAUDE.md&lt;/code&gt; should stay concise like a guardrail—containing only rules that genuinely prevent mistakes rather than documenting the entire codebase—while recurring workflows should be turned into reusable skills, commands, or subagents in the repo. For larger teams, plugins, MCPs, and subagents help isolate context, run independent reviews, and execute parallel streams of work, delivering the most value when baked into shared onboarding rather than kept as personal tweaks.&lt;/p&gt;
&lt;h2 id="how"&gt;&lt;a href="https://performance.dev/how-is-linear-so-fast-a-technical-breakdown" rel="noopener noreferrer"&gt;How&amp;rsquo;s Linear so fast? A technical breakdown&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dennis Brotzky breaks down why Linear feels instantaneous despite being a client-side web application. The core idea is that Linear removes network latency from the primary interaction path. The data the UI reads is already in the browser, primarily via IndexedDB and an in-memory object pool; mutations are applied optimistically locally first, written to a persistent transaction queue, and then synced to the server. The server acts as an arbiter that acknowledges changes and broadcasts deltas back, rather than something the UI waits on before responding to the user. At runtime, MobX enables fine-grained updates so each delta re-renders only the specific fields and components affected rather than an entire list.&lt;/p&gt;
&lt;p&gt;The post also dives into initial load performance, where speed comes from compounding small details: trimming JavaScript and CSS payloads, targeting only modern browsers, aggressive code splitting, preloading modules to avoid waterfall requests, service worker caching, preloading fonts with the proper &lt;code&gt;crossorigin&lt;/code&gt; attribute, embedding an app shell, and rendering local data before background authentication finishes. Beyond engineering, speed comes from product design: every action has a keyboard shortcut, the command palette is always one keystroke away and runs against local data, and animations are brief and stick to cheap properties like &lt;code&gt;transform&lt;/code&gt; and &lt;code&gt;opacity&lt;/code&gt;. Performance is thus as much about user perception as it is about raw engineering.&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 #19</title><link>https://miti99.com/en/post/2025/05/06/</link><pubDate>Tue, 06 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #19.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-love-letter-to-the-csv-format"&gt;&lt;a href="https://github.com/medialab/xan/blob/master/docs/LOVE_LETTER.md" rel="noopener noreferrer"&gt;A love letter to the CSV format&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author of &lt;code&gt;xan&lt;/code&gt; (a command-line CSV processing tool developed by medialab) wrote this &amp;ldquo;love letter&amp;rdquo; to push back against articles constantly declaring CSV obsolete in the face of Parquet, newline-delimited JSON, or MessagePack. CSV is no silver bullet, the author admits, but it has strengths that are routinely overlooked: a specification simple enough to explain in seconds (commas separate values, newlines separate rows, special values go in quotes), no corporate owner, and plain-text representation that humans can read and edit directly. CSV can also be streamed row by row with minimal memory and supports efficient append-only writes at the end of a file—things columnar formats like Parquet handle much worse, even if columnar formats excel when querying only a few columns.&lt;/p&gt;
&lt;p&gt;Beyond that, CSV is dynamically typed, leaving each language free to decide how to parse values (both flexible and error-prone if you&amp;rsquo;re careless), and remarkably compact since column names appear only once in the header rather than repeating keys on every record like JSON or XML. Even more uniquely, because escaping double quotes by doubling them is symmetrical, a CSV file reversed byte-for-byte is still valid CSV; this makes it possible to quickly read the last few rows of a massive file from the end, which is handy when resuming an interrupted job. The author jokes in closing that Excel hates CSV, which is probably a sign CSV is doing something right. For newer developers, the piece is a good reminder to pick data formats based on the actual problem rather than chasing trends.&lt;/p&gt;
&lt;h2 id="the-role-of-developer-skills-in-agentic-coding"&gt;&lt;a href="https://martinfowler.com/articles/exploring-gen-ai/13-role-of-developer-skills.html" rel="noopener noreferrer"&gt;The role of developer skills in agentic coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Birgitta Böckeler (Thoughtworks) reflects on months of using the agent modes of Cursor, Windsurf, and Cline to modify existing codebases. She appreciates how these tools can automatically run tests, fix compiler errors, and search the web, but notes that even in her most successful sessions, she constantly had to step in and steer. She categorizes AI mistakes into three &amp;ldquo;blast radii&amp;rdquo;: slowing down completion of a single commit (broken code or misdiagnosed problems, like blaming Docker&amp;rsquo;s architecture settings when the real issue was &lt;code&gt;node_modules&lt;/code&gt; built for the wrong architecture); creating friction for the team across development iterations (tackling too much at once instead of working in small vertical slices, treating symptoms by bumping memory limits instead of finding the root cause, or making the dev workflow messier); and most dangerously, degrading long-term maintainability (redundant tests, poor reuse, unnecessary verbosity). The wider the blast radius, the longer the feedback loop to catch the problem.&lt;/p&gt;
&lt;p&gt;In her view, we are nowhere near AI autonomously writing 90% of code within a year; right now, AI assists her roughly 80% of the time on a small ~15k-line project. To mitigate risks, individual developers should carefully review AI-generated code, stop sessions when cognitive load gets too high, stay wary of &amp;ldquo;good enough&amp;rdquo; solutions that appear too quickly, and practice pair programming. At the team level, she recommends maintaining code quality monitors like SonarQube or CodeScene, running checks in pre-commit hooks, curating custom rule files for AI assistants, and fostering a culture of trust and openness so nobody feels pressured to cut corners just to ship faster. For junior developers, the article clearly highlights the engineering skills that still matter in the AI era.&lt;/p&gt;
&lt;h2 id="cicd-devops-pipeline-project-deployment-of-java-application-on-kubernetes"&gt;&lt;a href="https://dev.to/prodevopsguytech/cicd-devops-pipeline-project-deployment-of-java-application-on-kubernetes-4fi2" rel="noopener noreferrer"&gt;CI/CD DevOps Pipeline Project: Deployment of Java Application on Kubernetes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DEV Community tutorial walks through building an end-to-end CI/CD pipeline from scratch to deploy a Java application onto Kubernetes, aiming to automate the entire software delivery lifecycle with minimal manual intervention. The infrastructure spans AWS EC2 instances for the Kubernetes master, worker nodes, Jenkins, SonarQube, Nexus, and a monitoring server. The author details setting up the cluster with Kubeadm (disabling swap, installing the CRI-O runtime and Kubernetes packages, initializing the control plane, and joining worker nodes), installing Jenkins, Docker, and Nexus, and setting up a private Git repository with a personal access token.&lt;/p&gt;
&lt;p&gt;At the heart of the guide is the &lt;code&gt;Jenkinsfile&lt;/code&gt;: the pipeline checks out the source code, compiles and runs tests with Maven, scans for vulnerabilities with Trivy, analyzes code quality via SonarQube, packages and uploads artifacts to Nexus, builds and pushes the Docker image, deploys to Kubernetes, and sends status notifications. The final section sets up real-time observability using Prometheus, Blackbox Exporter, and Grafana. It makes a solid hands-on project for developers who want to see how common DevOps tools fit together into a single cohesive workflow.&lt;/p&gt;
&lt;h2 id="road-to-jdk-25-over-engineering-tic-tac-toe-java-24"&gt;&lt;a href="https://briancorbinxyz.medium.com/road-to-jdk-25-over-engineering-tic-tac-toe-java-24-565c7f9b06d0" rel="noopener noreferrer"&gt;Road to JDK 25: Over-Engineering Tic-Tac-Toe (Java 24)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In his &amp;ldquo;Road to JDK 25&amp;rdquo; series, Brian Corbin explores new Java features by deliberately over-engineering a simple tic-tac-toe game. This installment covers JDK 24—which includes 24 JEPs—focusing on finalized, non-preview features. The standout addition is Stream Gatherers: using &lt;code&gt;Stream::gather(Gatherer)&lt;/code&gt;, developers can define custom stateful or stateless intermediate Stream operations with one-to-one, one-to-many, many-to-one, or many-to-many semantics, alongside built-in gatherers like &lt;code&gt;fold&lt;/code&gt;, &lt;code&gt;scan&lt;/code&gt;, &lt;code&gt;windowFixed&lt;/code&gt;, and &lt;code&gt;windowSliding&lt;/code&gt;. The ZGC garbage collector is now exclusively generational, collecting short-lived objects more frequently and efficiently.&lt;/p&gt;
&lt;p&gt;Other highlights include a standard Class-File API for reading, generating, and transforming &lt;code&gt;.class&lt;/code&gt; files (foundational for bytecode tooling), Ahead-of-Time Class Loading &amp;amp; Linking to cut startup times, and two quantum-resistant lattice-based cryptographic algorithms for key encapsulation and digital signatures. Each feature is demonstrated directly inside the tic-tac-toe codebase, and Corbin notes that JDK 25, the next LTS release, arrives in September 2025.&lt;/p&gt;
&lt;h2 id="oracle-reveals-five-new-features-coming-to-java"&gt;&lt;a href="https://www.infoworld.com/article/3848288/oracle-reveals-five-new-features-coming-to-java.html" rel="noopener noreferrer"&gt;Oracle reveals five new features coming to Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Right on the heels of JDK 24&amp;rsquo;s general availability, Oracle previewed five features in the pipeline for upcoming Java releases; all have JEPs, though none are finalized yet (for instance, JEP 402 is still a Draft and JEP 468 is a Candidate). Enhanced primitive boxing makes primitive types behave more like reference types, such as calling methods directly on primitive values or using primitives as type arguments. Value classes and objects introduce identity-free objects with only &lt;code&gt;final&lt;/code&gt; fields, distinguished purely by their field values so the JVM can optimize memory layout, locality, and garbage collection. Paired with this are null-restricted value class types, allowing variables of value types to forbid &lt;code&gt;null&lt;/code&gt; for denser storage.&lt;/p&gt;
&lt;p&gt;Derived record creation provides concise syntax for creating a new record from an existing one without writing boilerplate &amp;ldquo;wither&amp;rdquo; methods (the immutable equivalent of setters). Finally, Stable Values—confirmed as a preview feature in JDK 25 (September 2025)—are objects holding immutable data that the JVM treats as constants, delivering &lt;code&gt;final&lt;/code&gt;-like performance optimizations with more flexible initialization timing to improve application startup. Together, these proposals show Java steadily modernizing both its object model and its runtime performance.&lt;/p&gt;
&lt;h2 id="java-bytecode-hacking-for-fun-and-profit"&gt;&lt;a href="https://cory.li/bytecode-hacking/" rel="noopener noreferrer"&gt;Java bytecode hacking for fun and profit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author shares Java bytecode optimization techniques learned from Battlecode, a programming competition where AI bots control virtual robots and each turn is capped by a strict bytecode execution limit (roughly 6,000–10,000 bytecodes) rather than wall-clock CPU time. While manual bytecode golfing has been rare in everyday Java ever since JIT compilers matured, it can decide wins and losses in Battlecode. The post explains that the JVM is a stack-based virtual machine where each bytecode is an atomic instruction akin to assembly, and Battlecode counts instructions regardless of byte width—so &lt;code&gt;iload_0&lt;/code&gt; and &lt;code&gt;iload #5&lt;/code&gt; each cost one instruction.&lt;/p&gt;
&lt;p&gt;By inspecting decompiled bytecode, the author demonstrates several concrete tricks: rewriting enhanced &lt;code&gt;for-each&lt;/code&gt; loops manually to shave a few instructions per iteration, copying instance fields into local variables because every field access costs an extra instruction, comparing against zero wherever possible since the JVM has dedicated zero-comparison opcodes, and using labeled &lt;code&gt;break&lt;/code&gt;/&lt;code&gt;continue&lt;/code&gt; statements to force the compiler to emit direct &lt;code&gt;goto&lt;/code&gt; jumps that skip unnecessary loop tails. The author stresses that you should only optimize at this level after finalizing your core AI framework and algorithms, as correctness and algorithmic efficiency always come first. Even if you rarely need this at work, it&amp;rsquo;s a fun way to see how Java actually executes under the hood.&lt;/p&gt;
&lt;h2 id="how-to-write-blog-posts-that-developers-read"&gt;&lt;a href="https://refactoringenglish.com/chapters/write-blog-posts-developers-read/" rel="noopener noreferrer"&gt;How to Write Blog Posts that Developers Read&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lynch, who has written a software blog for nine years reaching 300,000–500,000 readers annually, shares principles for writing technical blog posts developers actually read; the piece is a sample chapter from his upcoming book on writing for software developers. His first rule is to get straight to the point: your title and opening sentences should immediately tell readers who the post is for and what they will get out of it. Next is &amp;ldquo;think one level broader&amp;rdquo;: adding just a couple of sentences explaining background concepts or swapping niche jargon for plain language can open the article to a vastly larger audience. He also emphasizes having a realistic distribution path—such as Hacker News, Reddit, or Google search—rather than simply writing something good and hoping people find it.&lt;/p&gt;
&lt;p&gt;The remaining two rules focus on presentation. Adding visuals is the single highest-leverage improvement: screenshots, charts, diagrams—even a clumsy MS Paint drawing is far more engaging than AI-generated art. Finally, cater to skimmers, since many readers scan headings and images before deciding whether to read word for word; Lynch even provides a bookmarklet that blurs body text so you can preview your post through a skimmer&amp;rsquo;s eyes. Every principle is backed by examples from his own blog and applies just as well to internal design docs and workplace emails.&lt;/p&gt;
&lt;h2 id="the-new-look-and-feel-of-apache-kafka-40"&gt;&lt;a href="https://thenewstack.io/the-new-look-and-feel-of-apache-kafka-4-0/" rel="noopener noreferrer"&gt;The New Look and Feel of Apache Kafka 4.0&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Apache Kafka 4.0 brings upgrades across nearly every component of the distributed event streaming platform, but the headline change is running exclusively in KRaft (Raft-based) mode and removing ZooKeeper mode entirely. As Sandon Jacobs (Confluent) explains, this transition was prepared across multiple releases; operations teams no longer need to provision and manage a separate ZooKeeper cluster, configure TLS between two systems, or allocate dedicated compute for it—one less component means one less point of failure. The release also includes early access to Queues for Kafka (KIP-932), allowing the number of consumers to exceed a topic&amp;rsquo;s partition count so it behaves like traditional message queues such as Amazon SQS; the trade-off is that message ordering is not guaranteed, so ordered workloads should stick with traditional consumer groups.&lt;/p&gt;
&lt;p&gt;In addition, KIP-848 introduces a new consumer group protocol that eliminates stop-the-world rebalances; in Kafka 4.0, clients opt in via &lt;code&gt;group.protocol=consumer&lt;/code&gt;. KIP-1112 lets developers declare a processor wrapper applied across every processor in a Kafka Streams topology instead of manually duplicating cross-cutting logic like audit logging everywhere. Finally, KIP-1076 and KIP-1091 expand client and broker metrics that can be pushed over OpenTelemetry to observability tools like Datadog. For developers working with streaming data, Kafka 4.0 makes operations substantially simpler.&lt;/p&gt;
&lt;h2 id="five-things-ai-will-not-change"&gt;&lt;a href="https://metastable.org/five/" rel="noopener noreferrer"&gt;Five Things AI Will Not Change&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Inspired by how Jeff Bezos built Amazon around things customers will always want (low prices, fast delivery, vast selection) rather than trying to predict the future of the internet, the author outlines five things that won&amp;rsquo;t change even with powerful AI. First, there will be many AIs rather than a single superintelligence, because fierce competition prevents any one lab from holding a monopoly for long. Second, rogue or malicious AIs will always exist, created intentionally or accidentally by humans, much like the social media manipulation campaigns seen in the 2016 US election. Third, abundance will not be distributed equally: AI cannot manufacture more land or scarce physical resources, so money will still be needed to allocate them. Fourth, politics will remain deeply divided, because many disagreements stem from conflicting values rather than a lack of information. Fifth, humans will not become &amp;ldquo;ants&amp;rdquo; to AI, because AI is trained on human culture and will converse directly with us on every subject.&lt;/p&gt;
&lt;p&gt;In the closing section, the author explains why the 2023 open letter calling for a pause on giant AI experiments was never going to succeed: humanity is still fighting cancer, Alzheimer&amp;rsquo;s, pandemics, and poverty, and AI holds real promise for helping solve them. In the author&amp;rsquo;s view, both the AI doomers and the utopians are wrong; the future will be messy and occasionally dark, but also beautiful and inspiring.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/5321bec2-0079-47e2-92e9-1cd9950227c8_2250x2624.png" alt="Object Oriented Programming Fundamentals"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>