Newsletter #124
Enjoy Newsletter #124.
Riding Technology Waves
Major technology waves—the internet, cloud computing, mobile, and now AI—arrive faster and hit harder with each cycle, minting massive new winners while wiping out incumbents, even as other hyped waves like 3D printing or VR fizzle out. To orient yourself early without getting swept up in empty hype, Stay SaaSy proposes answering four questions in order: does this technology actually matter (i.e., do real users get sustained value from it)?; how does it work under the hood, at a level you could explain clearly to a smart outsider?; what concrete new capabilities does it unlock, stated as plain facts rather than buzzwords?; and how do those capabilities affect your specific product, cost structure, or customers?
The two classic failure modes sit at opposite extremes. Complacency leads companies to dismiss real signals as a fad, though that mistake usually forces its own correction once the wave becomes undeniable. Far more common in volatile times is FOMO-driven panic: leaders who don’t understand the technology chase the herd, betting the company on unvalidated use cases or blowing up a working roadmap to slap an “AI” label on the product while customers are asking for basic reliability. Blindly pivoting is the default strategic blunder during a hype cycle. Yet the worst mistake of all is missing an obvious wave and then letting ego keep you in denial; when that happens, leadership must admit the miss, take ownership, put their best people and real resources on catching up, and stay hands-on until the course is corrected.
Find a new role
When thinking about changing jobs or transitioning into a new role, Lara Hogan recommends filling out a 2×2 grid of four lists: your non-negotiable “Must Haves”; your “Want to Haves” that matter a lot, though you’d trade off one or two for the right opportunity; things that “Don’t Matter” to you right now, even if they mattered in the past or matter to peers; and a single crisp “Optimizing For” sentence stating the one thing you are prioritizing above everything else in this chapter. Putting those four boxes on paper turns a murky career decision into concrete criteria for sourcing roles, asking interview questions, and weighing offers.
Hogan advises leaving job titles off every list entirely, since the same title can mean wildly different things across companies; evaluate the actual day-to-day scope and responsibilities instead. Keep the “Must Haves” box ruthlessly short: if you would still accept an offer missing a given item, it belongs in “Want to Haves,” and you will almost certainly have to compromise on at least one want-to-have. Anchor your criteria in what you need today rather than what you wanted five years ago or might want in the distant future—sometimes top-of-market compensation gives way to great healthcare, or scope gives way to work-life balance. Your single “Optimizing For” statement is the sharpest tool of all: tape it next to your monitor, share it with trusted friends who can hold you accountable, and use it to ask which opportunity moves you closest to that specific goal. Re-run the exercise whenever your life circumstances shift.
I Stored a Website in a Favicon
After previously hiding two bytes of state inside a custom mouse cursor, Tim Wehrle decided to see if he could pack an entire web page inside a favicon.ico/PNG image. The encoding is delightfully direct: a favicon is an image, an image is a grid of pixels, and each RGB pixel gives you three color channels—red, green, and blue—worth one byte each. Wehrle encodes an HTML snippet into UTF-8 bytes using TextEncoder, prepends a 4-byte length header so the decoder knows exactly where the payload ends (ignoring any trailing padding pixels in the grid), and writes three bytes into each pixel’s RGB values. A 208-byte HTML payload plus the 4-byte header totals 212 bytes, fitting into 71 pixels inside a tiny 9×9 PNG at 87% capacity—producing an icon that looks like colorful static.
To reconstruct the page, a tiny bootstrap page loads the favicon onto an HTML <canvas>, reads back the pixel array via getImageData(), extracts the RGB bytes up to the 4-byte length prefix, decodes the UTF-8 string with TextDecoder, and replaces the current document with the recovered HTML. Crucially, a PNG favicon is inert data and cannot execute itself on its own—you still need that small loader script to unpack and render it. Wehrle readily admits the experiment has zero practical utility given the tiny storage budget and the existence of normal HTTP responses, but it is a fun reminder that every file format is ultimately just bytes that can be repurposed in unexpected ways. He closes by noting alternative steganographic tricks like embedding markup inside an SVG favicon, stuffing text into PNG tEXt chunks, or packing multiple resolutions into an .ico container.
AntiPatterns Never Left, We Just Stopped Calling Them by Name
Back in 1998, the book AntiPatterns cataloged recurring software failure modes—giving each one a memorable name, symptoms, root causes, and a refactoring path out. Leon Pennings argues that those exact failure modes are still everywhere today; we just rebranded them as modern best practices and stopped recognizing them because the system still compiles and passes tests. Short-term delivery creates survivorship bias where teams assume their architectural choices succeeded, since nobody builds the simpler alternative alongside it for comparison. Industry popularity doesn’t prove an approach fits your context, and naming anti-patterns explicitly helps teams see water they’ve been swimming in for years.
Pennings groups modern anti-patterns into four recurring themes. First is organizing code around technical layers (controllers/, services/, repositories/) instead of business capabilities, scattering domain concepts across folders, producing anemic domain models, and coupling business logic tightly to frameworks. Second is cargo-culting Resume-Driven Development—reaching for Kubernetes or Kafka as a golden hammer regardless of scale. Third is when the cure recreates the disease: turning a monolithic Big Ball of Mud into a distributed microservices ball of mud where complexity simply moves across network boundaries, or standing up a platform team that becomes just another ticket-driven silo. Fourth is separating decision-makers from the consequences of their decisions, such as Scrum intermediaries insulating developers from real users. Sometimes writing fifty lines of plain code is far cheaper over five years than pulling in a massive dependency; the goal isn’t rejecting frameworks, microservices, or Scrum wholesale, but evaluating every trade-off against your actual problem.
5 More Advanced Java Tips That Senior Engineers Actually Use
This article walks through five modern Java capabilities, though it is worth noting upfront that they did not all land as final, stable APIs in Java 21: Record Patterns and Sequenced Collections were finalized in JDK 21, the Foreign Function and Memory (FFM) API was finalized in JDK 22, and Stream Gatherers became final in JDK 24, while Structured Concurrency remains a preview feature in the JDK 24 release referenced by the examples—so check your target JDK version before adopting. Structured Concurrency (StructuredTaskScope) groups related concurrent subtasks into a single lexical lifetime: using a policy like ShutdownOnFailure, if one subtask fails the remaining siblings are cancelled automatically (assuming they respect thread interruption), and once the try-with-resources block exits no orphan threads are left running in the background—a major upgrade over manually juggling independent CompletableFuture chains. Record Patterns let you destructure nested records directly inside switch expressions; paired with sealed interfaces, the compiler enforces exhaustiveness so adding a new subtype immediately flags every unhandled switch at compile time.
Sequenced Collections (SequencedCollection, SequencedSet, SequencedMap) unify access to first/last elements and reverse-order iteration across ordered collections; calling .reversed() returns a lightweight view rather than copying the underlying list, which is handy when scanning chronological event logs backward. The Foreign Function and Memory API (Project Panama) replaces brittle sun.misc.Unsafe and JNI boilerplate with a pure-Java API for allocating off-heap memory and calling native C libraries, complete with bounds checking and deterministic deallocation via Arena lifetimes (though the underlying native code itself must still be trusted). Finally, Stream Gatherers (Stream::gather) fill a long-standing gap in the Stream API: just as Collector lets you customize terminal operations, Gatherer lets you write custom stateful intermediate operations—such as fixed batching, sliding windows, deduplicating adjacent elements, or running averages—while keeping pipelines readable.
Go’s Type System — Structs, Interfaces, and Life Without Inheritance
Coming to Go after six years of Java and Kotlin, Mihir Mohapatra reflects that the biggest mental shift in Go’s type system is the complete absence of class inheritance. A struct holds only data fields—there are no constructors or implements keywords; a factory function like NewOrder is just a naming convention, and callers can still instantiate the zero-valued struct directly unless the type is unexported. Methods are declared separately with explicit value receivers (which operate on a copy) or pointer receivers (which can mutate the caller’s struct); reassigning a struct field requires a pointer receiver, though a value copy containing a map, slice, or pointer still shares the underlying referenced storage. Instead of inheritance, Go uses struct embedding: fields and methods of an embedded inner struct are promoted to the outer struct, modeling a “has-a” composition relationship rather than an “is-a” subtype hierarchy.
The biggest design departure is that Go interfaces are satisfied implicitly: any type that implements the required method signatures automatically satisfies the interface, even types from third-party packages you don’t control. That flips interface design on its head: instead of defining massive upfront contracts in a central package that every implementation must explicitly import and declare, Go interfaces are typically small—often one or two methods like io.Reader and io.Writer—and defined by the consumer right where the behavior is needed. Types stay decoupled and brittle base-class hierarchies disappear. Mohapatra also notes the trade-offs newcomers bump into: finding every type that satisfies an interface requires IDE tooling rather than grepping for implements, struct embedding doesn’t give you subclass polymorphism, and Go’s zero values mean an uninitialized struct compiles cleanly and can look valid unless you validate required fields explicitly.
Conduit: The Gateway I Built to Forget About
Adam built an internal Go API gateway sitting in front of three backend services with two authentication schemes: a custom HMAC-signed session token for end-user and chat routes, and JWTs for admin endpoints. While the Go proxy was fast and rock-solid, every new public-route exception or header tweak meant adding another if branch in Go, recompiling, and redeploying the binary. Conduit solves this by splitting what rarely changes from what changes constantly: a core Go binary handles HTTP ingress, routing, reverse proxying, CORS, and SSRF protection, while an isolated Deno subprocess executes TypeScript policy modules for auth, logging, and request mutation—letting operators edit a .ts file and reload policies without recompiling Go.
The two processes communicate over a Unix domain socket using a strict snapshot-and-patch contract. Go sends a serializable JSON snapshot of the incoming request metadata; the TypeScript policy modules return only a minimal patch describing headers to add/remove or whether to short-circuit the request, rather than owning or mutating the live request object directly, while request bodies larger than 64 KiB stay inside Go and are referenced by handle ID. Failure modes are explicitly separated too: if an individual policy module times out, Conduit logs a warning and moves on, whereas if the entire Deno sidecar crashes, each route follows its configured failure policy—either failing closed with 503 Service Unavailable or failing open by proxying directly to the upstream. Simplicity comes from crisp responsibility boundaries rather than raw line count; Conduit isn’t trying to replace Envoy or Kong at massive scale, just stay out of the way in front of a handful of services whose edge policies evolve often.
The Reflect Package
Go compiles ahead of time to native machine code, yet the standard library’s reflect package can inspect struct field names, types, and struct tags at runtime. This post dives into how the Go compiler embeds static type metadata inside the compiled binary so reflect can read it (while noting that other reflect APIs can still allocate or construct types dynamically at runtime). Under the hood, an empty interface value (any / interface{}) is a two-word struct holding two pointers: one pointing to the underlying data and one pointing to a runtime type descriptor (abi.Type), whose address is a compile-time constant known to the linker. Calling reflect.TypeOf therefore just reads that type pointer—no hash table lookup, no heap allocation.
During compilation, the compiler’s reflectdata pass serializes a descriptor for every needed type as a linker symbol named type:<typename>, and the linker packs those symbols into a read-only data section of the binary—which is why running strings on a Go executable reveals your struct tags in plain text. Every descriptor starts with a fixed 48-byte common header (abi.Type) recording byte size, alignment, kind (Struct, Slice, Int, etc.), type hash, garbage-collector pointer bitmap, equality function pointer, and name offset; immediately following that header in memory sit kind-specific fields—for a struct (abi.StructType), a slice of StructField entries holding each field’s name, type pointer, and byte offset within the struct, followed by method table metadata. Field names and tags are deduplicated in a shared read-only string pool to save binary size. When you use reflect.Value, it pairs the type descriptor with the data pointer and adds the stored byte offset to jump straight to a field’s memory address. Reading works fine on a value copy, but mutating via reflection requires passing a pointer into any—otherwise reflect is only looking at a copy of your struct.
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