Newsletter #9
Enjoy Newsletter #9.
To avoid being replaced by LLMs, do what they can’t
Sean Goedecke offers career advice for software engineers facing a future where large language models (LLMs) keep getting better at writing code, broken down across three time horizons. In the short term, lean heavily into AI tools, understand how language models work under the hood so you can get staffed on AI projects, and push for promotion—since junior roles are the most likely to be automated first. The author expects this phase to last at least five years, because large enterprises simply don’t move that fast.
In the medium term, he advises diving into sprawling legacy codebases inside large organizations. LLMs currently shine at competitive programming, where problems are self-contained, well-specified, easy to verify, and only a few hundred lines long; building features inside a decade-old enterprise system is the exact opposite: ambiguous requirements, messy verification, and millions of lines of code. Conquering that will require solving massive-context reasoning and building better evals against proprietary data locked inside company firewalls. Over the long run, the one thing LLMs cannot replace is accountability: engineers are trusted because they have skin in the game when things go wrong, whereas an LLM has nothing to lose. Companies will always need at least one human engineer in the loop to supervise the models and turn their plans into commitments the business can rely on.
How Instagram Scaled Its Infrastructure To Support a Billion Users
This ByteByteGo article traces how Instagram scaled its infrastructure from a 13-person photo-sharing app running on AWS to a platform serving over a billion users. In the early days, the team had to manually spin up extra servers before every weekend, the database was constantly overwhelmed, and neither monitoring nor load balancing was automated. After being acquired by Facebook, Instagram migrated into Facebook’s data centers and scaled along three axes: scaling horizontally (adding servers and data centers), squeezing more performance out of each machine (batching queries, aggressive caching, and rewriting CPU-heavy Python functions in C++), and scaling the engineering organization through continuous deployment exceeding 40 production pushes a day.
Architecturally, Django handles web requests, RabbitMQ and Celery process asynchronous background jobs like push notifications, PostgreSQL stores structured relational data requiring strong consistency, Cassandra handles distributed workloads like feeds and activity logs, Memcached serves as the caching tier, and Facebook’s Haystack stores photos and videos. One notable technique is the Memcache Lease mechanism to prevent thundering herds: when a cached item expires, only the first app server granted a “lease” token is allowed to query the database, while other servers wait briefly or serve slightly stale data. Their deployment pipeline combines code review, automated tests, canary rollouts on a small subset of machines, and per-function CPU profiling in production.
The State of Scala & Clojure Surveys
Artur Skowronski (JVM Weekly) examines two recent community surveys covering Scala and Clojure. VirtusLab’s late-2024 Scala Survey of 232 respondents found that while 93.1% like or love Scala, the average project age is now seven years—meaning most Scala work happens on legacy systems. The most popular ecosystems are Typelevel (41.8%), Akka (35.3%), and ZIO (23.3%), with 53% of projects mixing multiple stacks, and only 22.4% of commercial codebases have migrated fully to Scala 3. The top three pain points are slow compile times, ecosystem fragmentation complicating the Scala 3 upgrade, and a shortage of resources to maintain older libraries. Hiring is another sore spot: 56.5% don’t know where to find Scala developers and 23.2% of companies are considering migrating to Kotlin, Rust, or Go—even though 88.4% of respondents would still pick Scala for a greenfield project.
On the Clojure side, the 2024 State of Clojure survey shows 73% of respondents using the language professionally, primarily for web development and enterprise backends; 58% have upgraded to Clojure 1.12 and 54% run on Java 21 LTS. A highlight this year is the growing ecosystem of Clojure dialects: Babashka is widely loved for fast scripting without JVM startup overhead, and ClojureDart brings Clojure to the Dart/Flutter ecosystem for web and mobile, alongside experimental compilers like Squint, Jank, and Cherry. For newcomers, the steepest learning curve remains grokking macros and homoiconicity.
LinkedIn Integrates Protocol Buffers With Rest.li for Improved Microservices Performance
Karthik Ramgopal and Aman Gupta share how LinkedIn replaced JSON with Protocol Buffers (Protobuf) as the default serialization format for Rest.li, their open-source REST framework powering over 50,000 production API endpoints. While JSON is human-readable and universally supported, its text-based representation produces bulky payloads that consume extra bandwidth and make serialization and deserialization a major CPU bottleneck. After benchmarking alternatives including FlatBuffers, Cap’n Proto, MessagePack, CBOR, and Kryo, the team chose Protobuf for the best overall balance of compact payload size, serialization speed, and broad language support across LinkedIn’s stack.
The catch was that Rest.li’s PDL schema language lacks the explicit numeric field tags that Protobuf requires. The team solved this with a bidirectional symbol table mapping field names to integer IDs: services generate their symbol table at startup and clients fetch and cache it dynamically, while for web and mobile clients the table is generated at build time in an append-only manner. Rollout was controlled incrementally via client-side configuration. Across production, average throughput improved by 6.25% for responses and 1.77% for requests, latency dropped by up to 60% for services with large payloads, and no service saw a meaningful regression. LinkedIn’s next step is gradually migrating from Rest.li to gRPC.
Story: Redis and its creator antirez
This Brachiosoft profile traces the journey of Salvatore Sanfilippo (antirez), the creator of Redis. Growing up in Sicily, antirez got his start on a TI-99/4A home computer at age six, learning BASIC alongside his father. After setting programming aside during his teenage years, he returned to it around age 18–19, taught himself C, and discovered a security flaw in the ping utility. His post on the Bugtraq mailing list landed him a job offer at Milan security firm SECLAB, where he invented the Idle Scan port-scanning technique and wrote the hping tool before moving back to Sicily six months later.
Redis grew out of LLOOGG, a real-time web analytics tool antirez launched in 2007. Because MySQL couldn’t keep up with the disk I/O of real-time per-visit list updates, he prototyped an in-memory list database in Tcl called LMDB, rewrote it in C, and released Redis in 2009. The initial reception on Hacker News was lukewarm, but Redis quickly won pivotal early adopters: GitHub used it to build the Resque background job queue, Instagram built its early storage layer almost entirely on Redis, and Twitter repeatedly flew antirez out to their headquarters to help architect their timeline cache. VMware later hired him to work on Redis full-time, followed by stints at Pivotal and Redis Labs. In 2020, after more than a decade at the helm, antirez stepped down as maintainer, worn out by the constant tension between keeping the codebase crafted like a work of art and meeting the practical demands of a massive global user base.
Tracing: structured logging, but better in every way
Andy Dote explains why he believes distributed tracing beats structured logging in every way, and shows how to migrate incrementally from logs to traces. Log levels (debug, info, warning…), he argues, are largely meaningless; free-text messages force slow full-text searches; log output gets interleaved with stdout; individual log lines lack causal relationships; and timing measurements have to be wired up manually and inconsistently. Traces solve all of these: every span automatically records a start time, end time, and duration, maintains parent-child hierarchy, propagates across service boundaries for distributed tracing, and makes it trivial to plot latency distributions or answer negative queries like “which requests did not find the user in the cache?”
The hands-on walkthrough takes a small Go service using OpenTelemetry through three steps: adding a tracer and opening a span in each function, wrapping errors so status codes and error events are recorded on the active span, and replacing log lines with filterable span attributes—turning "found user in cache" into user_in_cache: true. The resulting code is only a few lines longer while capturing far richer telemetry. For loops, the author recommends extracting the loop body into a helper function with its own child span or recording aggregate counts after the loop to avoid overwriting span attributes, adopting Observability-Driven Development, and viewing traces in tools like Honeycomb or Lightstep.
Software engineering job openings hit five-year low?
Gergely Orosz analyzes Indeed job-posting data showing that US software engineering openings currently sit at just 65% of their January 2020 baseline—down 3.5x from their mid-2022 peak and 8% lower than a year ago. Similar drops appear across Canada, the UK, France, and Germany, with Australia the lone market still above 2020 levels. Even more striking, while total job postings across all sectors on Indeed are up 10% compared to 2020, software development postings have fallen 34%—a much steeper drop than marketing (-19%), sales (-8%), or banking and finance (-7%).
The author points to several overlapping drivers: rising interest rates ending the zero-interest-rate policy (ZIRP) era and drying up venture capital; companies still digesting the overhiring binge of 2021–2022; enterprises taking a “wait and see” approach to headcount while evaluating GenAI productivity gains (such as Salesforce freezing engineering hiring after reporting a 30% AI productivity boost); and lean teams proving how much a small group can ship—like Linear with 25 engineers or Bluesky with 13. He notes that Indeed skews toward traditional enterprises and may undercount startups and Big Tech. Looking ahead, he sketches a few scenarios: smaller, higher-leverage teams spawning a wave of new startups; platforms that turn plain-English specs into working apps; or a surge of AI-generated apps built by non-programmers eventually creating more demand for professional engineers to scale and maintain them.
We switched from Java to Go and don’t regret it
Philip Miglinci from Glasskube shares why his team switched from Java/Kotlin to Go. Despite years of experience with Java and Spring, while building Kubernetes tooling they noticed that other Kubernetes operators—mostly written in Go—used next to no resources, whereas their Kotlin-based operator and its supporting stack consumed over 2 GB of RAM even when completely idle. That prompted them to rewrite their open-source package manager in Go, and later choose Go for Distr, their open-source software distribution platform and first full Go web application.
The post compares the two ecosystems across several dimensions. Java relies on JIT compilation and supports incremental builds and hot reloading, but Gradle and Maven are memory-hungry; Go compiles AOT into a single static binary, with a lightweight Spring Boot app taking roughly 8.2 seconds to start compared to under 100 milliseconds for a Go server. Java favors batteries-included frameworks like Spring or Quarkus, whereas Go prefers small, composable libraries with less “black magic,” eschewing Spring-style annotation-driven dependency injection in favor of explicit constructor or function arguments (keeping context.Context strictly for deadlines, cancellation signals, and request-scoped values). Debugging and IDE support are roughly on par—though Java stack traces are easier to follow—and GoReleaser shines for release automation. The author concludes that Go is a natural fit for cloud-native and Kubernetes tooling, even if Java remains a strong choice for other domains.
Secure Java applications: A deep look into 3 different issues
Martin Balao Alonso (Red Hat) examines three classes of vulnerabilities that can compromise data confidentiality, integrity, or availability in Java applications. The first is integer overflow: byte, short, int, and long use signed two’s-complement representation. While javac catches certain out-of-range literal assignments without an explicit cast, arithmetic operations silently wrap around according to the language specification. Using Math::xxxExact methods or BigInteger helps detect overflow immediately or compute with arbitrary-precision integers.
The second issue is untrusted input driving resource allocation: if a server pre-allocates a buffer based directly on a length field declared in an incoming message header, an attacker can trigger an OutOfMemoryError at almost zero cost; defenses include allocating memory incrementally as bytes arrive and capping concurrent connections per client. The third is timing attacks involving the JVM interpreter and JIT compiler: security-sensitive code must run in constant time regardless of secret values, yet even a simple byte-by-byte array comparison takes different execution paths depending on where a mismatch occurs—and an attacker can even manipulate the C2 JIT compiler’s branch profiling statistics to trigger a deoptimization trap that leaks secret information through timing differences. The author recommends constant-time bitwise operations like XOR for secret comparisons and carefully inspecting the native machine code emitted by the JIT.
Java Devs Rejoice! This Open-Source Secret Weapon Will Cut Your Coding Time in Half
Brett Hoffman introduces esProc SPL, an open-source data processing language written entirely in Java. The post opens with a familiar dilemma: writing structured data manipulation logic in plain Java is verbose (even grouping and aggregating by two fields takes dozens of lines of boilerplate), while SQL is concise but tightly coupled to a relational database, making it hard to scale independently or run outside the DB. Java 8 Streams, Kotlin, and Scala tried to bridge the gap but still fall short of SQL’s expressiveness—and because Java is compiled, every logic change requires a full rebuild and redeploy.
According to the author, SPL solves both problems: its syntax is as concise as SQL—and often shorter for complex order-dependent calculations, like computing the longest streak of consecutive price increases for a stock in a single line—while running independently of any database; it comes with a dedicated IDE supporting step-by-step debugging and visual data inspection; it handles both in-memory and out-of-core datasets larger than RAM, enabling parallel execution simply by adding an @m flag. SPL embeds directly into Java applications via a standard JDBC driver, is lightweight enough to run on Android or act as a compute engine inside microservices, joins data seamlessly across heterogeneous sources (databases, REST APIs, CSVs, JSON), and—because it is interpreted—supports hot-swapping business logic on the fly without restarting the service.
Bonus: Interesting videos from Inside Java
Garbage Collection in Java - The progress since JDK 8
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