Newsletter #19
Enjoy Newsletter #19.
A love letter to the CSV format
The author of xan (a command-line CSV processing tool developed by medialab) wrote this “love letter” 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.
Beyond that, CSV is dynamically typed, leaving each language free to decide how to parse values (both flexible and error-prone if you’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.
The role of developer skills in agentic coding
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 “blast radii”: slowing down completion of a single commit (broken code or misdiagnosed problems, like blaming Docker’s architecture settings when the real issue was node_modules 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.
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 “good enough” 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.
CI/CD DevOps Pipeline Project: Deployment of Java Application on Kubernetes
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.
At the heart of the guide is the Jenkinsfile: 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.
Road to JDK 25: Over-Engineering Tic-Tac-Toe (Java 24)
In his “Road to JDK 25” 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 Stream::gather(Gatherer), 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 fold, scan, windowFixed, and windowSliding. The ZGC garbage collector is now exclusively generational, collecting short-lived objects more frequently and efficiently.
Other highlights include a standard Class-File API for reading, generating, and transforming .class files (foundational for bytecode tooling), Ahead-of-Time Class Loading & 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.
Oracle reveals five new features coming to Java
Right on the heels of JDK 24’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 final 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 null for denser storage.
Derived record creation provides concise syntax for creating a new record from an existing one without writing boilerplate “wither” 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 final-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.
Java bytecode hacking for fun and profit
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 iload_0 and iload #5 each cost one instruction.
By inspecting decompiled bytecode, the author demonstrates several concrete tricks: rewriting enhanced for-each 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 break/continue statements to force the compiler to emit direct goto 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’s a fun way to see how Java actually executes under the hood.
How to Write Blog Posts that Developers Read
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 “think one level broader”: 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.
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’s eyes. Every principle is backed by examples from his own blog and applies just as well to internal design docs and workplace emails.
The New Look and Feel of Apache Kafka 4.0
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’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.
In addition, KIP-848 introduces a new consumer group protocol that eliminates stop-the-world rebalances; in Kafka 4.0, clients opt in via group.protocol=consumer. 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.
Five Things AI Will Not Change
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’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 “ants” to AI, because AI is trained on human culture and will converse directly with us on every subject.
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’s, pandemics, and poverty, and AI holds real promise for helping solve them. In the author’s view, both the AI doomers and the utopians are wrong; the future will be messy and occasionally dark, but also beautiful and inspiring.
Bonus: Interesting images from ByteByteGo

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.
Comments