<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Career Development on miti99</title><link>https://miti99.com/en/tags/career-development/</link><description>Recent content in Career Development 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/career-development/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #124</title><link>https://miti99.com/en/post/2026/07/12/</link><pubDate>Sun, 12 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #124.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="riding-technology-waves"&gt;&lt;a href="https://staysaasy.com/strategy/2026/06/22/riding-technology-waves.html" rel="noopener noreferrer"&gt;Riding Technology Waves&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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?&lt;/p&gt;
&lt;p&gt;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&amp;rsquo;t understand the technology chase the herd, betting the company on unvalidated use cases or blowing up a working roadmap to slap an &amp;ldquo;AI&amp;rdquo; 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.&lt;/p&gt;
&lt;h2 id="find-a-new-role"&gt;&lt;a href="https://larahogan.me/blog/identify-new-role/" rel="noopener noreferrer"&gt;Find a new role&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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 &amp;ldquo;Must Haves&amp;rdquo;; your &amp;ldquo;Want to Haves&amp;rdquo; that matter a lot, though you&amp;rsquo;d trade off one or two for the right opportunity; things that &amp;ldquo;Don&amp;rsquo;t Matter&amp;rdquo; to you right now, even if they mattered in the past or matter to peers; and a single crisp &amp;ldquo;Optimizing For&amp;rdquo; 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.&lt;/p&gt;
&lt;p&gt;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 &amp;ldquo;Must Haves&amp;rdquo; box ruthlessly short: if you would still accept an offer missing a given item, it belongs in &amp;ldquo;Want to Haves,&amp;rdquo; and you will almost certainly have to compromise on at least one want-to-have. Anchor your criteria in what you need &lt;em&gt;today&lt;/em&gt; 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 &amp;ldquo;Optimizing For&amp;rdquo; 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.&lt;/p&gt;
&lt;h2 id="i-stored-a-website-in-a-favicon"&gt;&lt;a href="https://www.timwehrle.de/blog/i-stored-a-website-in-a-favicon" rel="noopener noreferrer"&gt;I Stored a Website in a Favicon&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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 &lt;code&gt;favicon.ico&lt;/code&gt;/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 &lt;code&gt;TextEncoder&lt;/code&gt;, 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&amp;rsquo;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.&lt;/p&gt;
&lt;p&gt;To reconstruct the page, a tiny bootstrap page loads the favicon onto an HTML &lt;code&gt;&amp;lt;canvas&amp;gt;&lt;/code&gt;, reads back the pixel array via &lt;code&gt;getImageData()&lt;/code&gt;, extracts the RGB bytes up to the 4-byte length prefix, decodes the UTF-8 string with &lt;code&gt;TextDecoder&lt;/code&gt;, 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 &lt;code&gt;tEXt&lt;/code&gt; chunks, or packing multiple resolutions into an &lt;code&gt;.ico&lt;/code&gt; container.&lt;/p&gt;
&lt;h2 id="antipatterns-never-left-we-just-stopped-calling-them-by-name"&gt;&lt;a href="https://dev.to/leonpennings/antipatterns-never-left-we-just-stopped-calling-them-by-name-969" rel="noopener noreferrer"&gt;AntiPatterns Never Left, We Just Stopped Calling Them by Name&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back in 1998, the book &lt;em&gt;AntiPatterns&lt;/em&gt; 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&amp;rsquo;t prove an approach fits your context, and naming anti-patterns explicitly helps teams see water they&amp;rsquo;ve been swimming in for years.&lt;/p&gt;
&lt;p&gt;Pennings groups modern anti-patterns into four recurring themes. First is organizing code around technical layers (&lt;code&gt;controllers/&lt;/code&gt;, &lt;code&gt;services/&lt;/code&gt;, &lt;code&gt;repositories/&lt;/code&gt;) 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&amp;rsquo;t rejecting frameworks, microservices, or Scrum wholesale, but evaluating every trade-off against your actual problem.&lt;/p&gt;
&lt;h2 id="5-more-advanced-java-tips-that-senior-engineers-actually-use"&gt;&lt;a href="https://dev.to/cyclopt_dimitrisk/5-more-advanced-java-tips-that-senior-engineers-actually-use-bbp" rel="noopener noreferrer"&gt;5 More Advanced Java Tips That Senior Engineers Actually Use&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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 (&lt;code&gt;StructuredTaskScope&lt;/code&gt;) groups related concurrent subtasks into a single lexical lifetime: using a policy like &lt;code&gt;ShutdownOnFailure&lt;/code&gt;, if one subtask fails the remaining siblings are cancelled automatically (assuming they respect thread interruption), and once the &lt;code&gt;try-with-resources&lt;/code&gt; block exits no orphan threads are left running in the background—a major upgrade over manually juggling independent &lt;code&gt;CompletableFuture&lt;/code&gt; chains. Record Patterns let you destructure nested records directly inside &lt;code&gt;switch&lt;/code&gt; expressions; paired with &lt;code&gt;sealed&lt;/code&gt; interfaces, the compiler enforces exhaustiveness so adding a new subtype immediately flags every unhandled &lt;code&gt;switch&lt;/code&gt; at compile time.&lt;/p&gt;
&lt;p&gt;Sequenced Collections (&lt;code&gt;SequencedCollection&lt;/code&gt;, &lt;code&gt;SequencedSet&lt;/code&gt;, &lt;code&gt;SequencedMap&lt;/code&gt;) unify access to first/last elements and reverse-order iteration across ordered collections; calling &lt;code&gt;.reversed()&lt;/code&gt; 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 &lt;code&gt;sun.misc.Unsafe&lt;/code&gt; 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 &lt;code&gt;Arena&lt;/code&gt; lifetimes (though the underlying native code itself must still be trusted). Finally, Stream Gatherers (&lt;code&gt;Stream::gather&lt;/code&gt;) fill a long-standing gap in the Stream API: just as &lt;code&gt;Collector&lt;/code&gt; lets you customize terminal operations, &lt;code&gt;Gatherer&lt;/code&gt; lets you write custom stateful intermediate operations—such as fixed batching, sliding windows, deduplicating adjacent elements, or running averages—while keeping pipelines readable.&lt;/p&gt;
&lt;h2 id="go"&gt;&lt;a href="https://dev.to/mihirmohapatra/gos-type-system-structs-interfaces-and-life-without-inheritance-2lb7" rel="noopener noreferrer"&gt;Go&amp;rsquo;s Type System — Structs, Interfaces, and Life Without Inheritance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Coming to Go after six years of Java and Kotlin, Mihir Mohapatra reflects that the biggest mental shift in Go&amp;rsquo;s type system is the complete absence of class inheritance. A &lt;code&gt;struct&lt;/code&gt; holds only data fields—there are no constructors or &lt;code&gt;implements&lt;/code&gt; keywords; a factory function like &lt;code&gt;NewOrder&lt;/code&gt; 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&amp;rsquo;s struct); reassigning a struct field requires a pointer receiver, though a value copy containing a &lt;code&gt;map&lt;/code&gt;, &lt;code&gt;slice&lt;/code&gt;, 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 &amp;ldquo;has-a&amp;rdquo; composition relationship rather than an &amp;ldquo;is-a&amp;rdquo; subtype hierarchy.&lt;/p&gt;
&lt;p&gt;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&amp;rsquo;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 &lt;code&gt;io.Reader&lt;/code&gt; and &lt;code&gt;io.Writer&lt;/code&gt;—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 &lt;code&gt;implements&lt;/code&gt;, struct embedding doesn&amp;rsquo;t give you subclass polymorphism, and Go&amp;rsquo;s zero values mean an uninitialized struct compiles cleanly and can look valid unless you validate required fields explicitly.&lt;/p&gt;
&lt;h2 id="conduit-the-gateway-i-built-to-forget-about"&gt;&lt;a href="https://dev.to/adamthedeveloper/conduit-the-gateway-i-built-to-forget-about-2ann" rel="noopener noreferrer"&gt;Conduit: The Gateway I Built to Forget About&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;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 &lt;code&gt;if&lt;/code&gt; 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 &lt;code&gt;.ts&lt;/code&gt; file and reload policies without recompiling Go.&lt;/p&gt;
&lt;p&gt;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 &lt;code&gt;503 Service Unavailable&lt;/code&gt; or failing open by proxying directly to the upstream. Simplicity comes from crisp responsibility boundaries rather than raw line count; Conduit isn&amp;rsquo;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.&lt;/p&gt;
&lt;h2 id="the-reflect-package"&gt;&lt;a href="https://internals-for-interns.com/posts/go-runtime-reflect" rel="noopener noreferrer"&gt;The Reflect Package&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Go compiles ahead of time to native machine code, yet the standard library&amp;rsquo;s &lt;code&gt;reflect&lt;/code&gt; 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 &lt;code&gt;reflect&lt;/code&gt; can read it (while noting that other &lt;code&gt;reflect&lt;/code&gt; APIs can still allocate or construct types dynamically at runtime). Under the hood, an empty interface value (&lt;code&gt;any&lt;/code&gt; / &lt;code&gt;interface{}&lt;/code&gt;) is a two-word struct holding two pointers: one pointing to the underlying data and one pointing to a runtime type descriptor (&lt;code&gt;abi.Type&lt;/code&gt;), whose address is a compile-time constant known to the linker. Calling &lt;code&gt;reflect.TypeOf&lt;/code&gt; therefore just reads that type pointer—no hash table lookup, no heap allocation.&lt;/p&gt;
&lt;p&gt;During compilation, the compiler&amp;rsquo;s &lt;code&gt;reflectdata&lt;/code&gt; pass serializes a descriptor for every needed type as a linker symbol named &lt;code&gt;type:&amp;lt;typename&amp;gt;&lt;/code&gt;, and the linker packs those symbols into a read-only data section of the binary—which is why running &lt;code&gt;strings&lt;/code&gt; on a Go executable reveals your struct tags in plain text. Every descriptor starts with a fixed 48-byte common header (&lt;code&gt;abi.Type&lt;/code&gt;) recording byte size, alignment, kind (&lt;code&gt;Struct&lt;/code&gt;, &lt;code&gt;Slice&lt;/code&gt;, &lt;code&gt;Int&lt;/code&gt;, 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 (&lt;code&gt;abi.StructType&lt;/code&gt;), a slice of &lt;code&gt;StructField&lt;/code&gt; entries holding each field&amp;rsquo;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 &lt;code&gt;reflect.Value&lt;/code&gt;, it pairs the type descriptor with the data pointer and adds the stored byte offset to jump straight to a field&amp;rsquo;s memory address. Reading works fine on a value copy, but mutating via reflection requires passing a pointer into &lt;code&gt;any&lt;/code&gt;—otherwise &lt;code&gt;reflect&lt;/code&gt; is only looking at a copy of your struct.&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 #123</title><link>https://miti99.com/en/post/2026/07/11/</link><pubDate>Sat, 11 Jul 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/07/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #123.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="our-collective-bike-shed-moment"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2026/06/our-collective-bike-shed-moment.html" rel="noopener noreferrer"&gt;Our Collective Bike Shed Moment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post borrows Parkinson&amp;rsquo;s &amp;ldquo;Law of Triviality&amp;rdquo;: a fictional committee approves a nuclear reactor design in ten minutes because the topic is too complex for anyone to debate, then spends forty-five minutes arguing over what color to paint the bike shed. The author argues that society is re-enacting that exact meeting in the face of AI. LLMs have blown past one supposed ceiling after another—from &amp;ldquo;they can&amp;rsquo;t write real code&amp;rdquo; to hallucinations—while growing steadily stronger at formal methods and multi-step reasoning, yet critics keep moving the goalposts while the broader public carries on as if nothing fundamental has changed.&lt;/p&gt;
&lt;p&gt;Demirbas attributes this collective shrug to normalcy bias—our default assumption that tomorrow will look mostly like yesterday—and Douglas Adams&amp;rsquo;s &amp;ldquo;Somebody Else&amp;rsquo;s Problem&amp;rdquo; field, where something colossal is ignored precisely because it is too big to process. Learning new AI tools to stay employable over the next few years is a sensible personal strategy, but it doesn&amp;rsquo;t answer what happens over the coming decades. What worries the author is that even the people who should be leading the serious conversation—technologists, researchers, economists, policymakers, ethicists, defense planners, and educators—still aren&amp;rsquo;t grappling with the long-term societal transformation at the depth required, while public attention remains fixated on surface-level bike-shedding.&lt;/p&gt;
&lt;h2 id="p99-0ms"&gt;&lt;a href="https://ruurtjan.com/articles/p99-0ms-autocomplete-for-240-million-domain-names" rel="noopener noreferrer"&gt;p99 0 ms* autocomplete for 240 million domain names&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ruurtjan Pul explains how Wirewiki achieves instantaneous-feeling autocomplete across a dataset of 240 million domain names. The trick starts in the browser: on &lt;code&gt;keydown&lt;/code&gt;, the client prefetches autocomplete results not only for the current prefix, but for every valid character the user might type next; by the time the next &lt;code&gt;keyup&lt;/code&gt; fires, the suggestions are already sitting in browser memory ready to render. Because domain names use a tiny character set (38 characters), a single response bundling top suggestions for all possible next keystrokes contains at most 312 domain names—roughly 2.5 kB compressed. According to the author&amp;rsquo;s measurements, 99% of keystrokes have at least a 121 ms budget before release, so &amp;ldquo;p99 0 ms&amp;rdquo; means the result is already local before &lt;code&gt;keyup&lt;/code&gt;, not that network packets travel faster than light.&lt;/p&gt;
&lt;p&gt;On the server side, the dataset is split into two tiers. An in-memory prefix tree (trie) holds the top eight suggestions for every prefix drawn from the Tranco top one million domains. The remaining 240 million domains from ICANN&amp;rsquo;s CZDS are sorted, front-coded (prefix-compressed), and packed into fixed-size blocks on SSD; a 27 MB in-memory index locates the right block in one hop while the OS page cache keeps hot blocks in RAM. The Go API typically responds in ~2 ms, and under 1,600 requests/sec Nginx plus the API still maintain a ~15 ms p99. Once the origin server is that fast, network round-trip time through Cloudflare dominates perceived latency—hence the asterisk in the title: a single European server still can&amp;rsquo;t beat the 121 ms budget for users halfway across the globe. The takeaway is to measure latency from the user&amp;rsquo;s physical interaction rather than just server processing time.&lt;/p&gt;
&lt;h2 id="building-reliable-agentic-ai-systems"&gt;&lt;a href="https://martinfowler.com/articles/reliable-llm-bayer.html" rel="noopener noreferrer"&gt;Building Reliable Agentic AI Systems&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article on Martin Fowler&amp;rsquo;s site chronicles how Bayer built PRINCE, an agentic AI platform that helps pharmaceutical researchers query decades of preclinical toxicology data locked inside thousands of PDF study reports. The architecture evolved through three stages: structured metadata search, basic RAG question-answering, and finally a multi-agent workflow for complex cross-study questions. Orchestrated with LangGraph, the system steps through intent clarification, planning, research execution, evidence sufficiency checks, and report synthesis. Specialized research agents combine OpenSearch-backed RAG over unstructured PDF narratives with Athena Text-to-SQL for filtering, aggregating, and comparing structured study tables, while dedicated reflection nodes audit progress, data completeness, and draft quality.&lt;/p&gt;
&lt;p&gt;Reliability comes from the engineering harness around the models rather than clever prompting or waiting for a smarter foundation model. Each graph node receives only the narrow slice of context it needs; workflow state is checkpointed after every node so failures resume from the last completed step instead of restarting from scratch; and bounded retries operate at both the individual model-call level and the graph-node level, failing over to backup models or cloud regions when needed. In a heavily regulated pharmaceutical environment, user trust also depends on surfacing intermediate reasoning steps, linking every claim directly to source PDF pages and paragraphs, running continuous evaluations against both golden datasets and production traffic, and keeping domain scientists in the loop. Breaking a monolith prompt into an observable, checkpointed graph made the system dramatically easier to test, recover, and improve.&lt;/p&gt;
&lt;h2 id="growing-as-an-engineer-in-a-world-of-ai"&gt;&lt;a href="https://nlopes.dev/writing/growing-as-an-engineer-in-a-world-of-ai" rel="noopener noreferrer"&gt;Growing as an engineer in a world of AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Norberto Lopes argues that the biggest risk AI poses to early-career engineers isn&amp;rsquo;t replacing their jobs—it&amp;rsquo;s short-circuiting their growth by removing the very friction that produces deep learning. Reading documentation, experimenting, failing, debugging, and piecing together your own mental model builds durable knowledge through &amp;ldquo;desirable difficulty&amp;rdquo; and the generation effect. Getting an instant answer is not the same as understanding the problem: if an engineer simply accepts generated code and moves on to the next ticket, they can ship working features while remaining unable to explain the design choices, trade-offs, or failure modes. That &amp;ldquo;cognitive debt&amp;rdquo; stays hidden until production breaks in a way the AI can&amp;rsquo;t immediately fix.&lt;/p&gt;
&lt;p&gt;Lopes doesn&amp;rsquo;t advocate shunning AI; instead, he recommends using it deliberately as a learning amplifier: ask &lt;em&gt;why&lt;/em&gt; an approach works, ask for alternative designs and failure scenarios, read the code and sketch your own mental model before asking the LLM to explain it, type out critical sections yourself instead of copy-pasting, and treat code review and technical writing as active thinking exercises. Foundational depth still comes from books, Unix fundamentals, primary specifications, architecture debates, and postmortems—and the time saved by AI should be reinvested into harder engineering thinking. Developing junior engineers is also an organizational responsibility: managers must protect space for learning, evaluate judgment and system understanding rather than raw ticket velocity, and keep hiring and mentoring the next generation.&lt;/p&gt;
&lt;h2 id="note-to-my-younger-self"&gt;&lt;a href="https://yewjin.substack.com/p/note-to-my-younger-self" rel="noopener noreferrer"&gt;Note To My Younger Self&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Reflecting on two decades at major tech companies, Yew Jin Lim distills eight career principles that sound simple on paper but take discipline to practice. Fall in love with the actual craft rather than chasing titles, and treat your first job as a laboratory for learning how to solve problems; keep asking &amp;ldquo;why&amp;rdquo; until you reach root causes; build genuine relationships by helping people without keeping score while maintaining healthy boundaries; bring energy and joy to the team around you; listen carefully, tailor explanations to your audience, and know when to stay quiet; write down your impact every single week and proactively ask for specific feedback—then act on it visibly—so you have a concrete record of growth and course-correct early; and whenever you have a choice, optimize for a manager who will invest in your growth over a flashier title, because a great manager shapes how you think for the rest of your career.&lt;/p&gt;
&lt;p&gt;Lim candidly acknowledges survivorship bias and notes that none of these rules are absolute. When good work, a supportive manager, kindness, visibility, and mental health come into conflict, the right trade-off depends on your career stage, the skills you still need to build, personal circumstances, and how long a situation will last. When torn between options, a clarifying question is: what will still matter five years from now? Individual projects are almost always forgotten, whereas skills, mental models, and strong relationships keep compounding for decades.&lt;/p&gt;
&lt;h2 id="google-hits-50-ipv6"&gt;&lt;a href="https://blog.apnic.net/2026/04/28/google-hits-50-ipv6/" rel="noopener noreferrer"&gt;Google hits 50% IPv6&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In April 2026, Google&amp;rsquo;s public telemetry crossed the milestone of 50% of users connecting over IPv6, underscoring that IPv6 is now a mature pillar of the global Internet. At the same time, APNIC Labs measured global IPv6 adoption around 42%, and Geoff Huston explains why that gap isn&amp;rsquo;t a contradiction. APNIC&amp;rsquo;s measurement samples run via online ad placements whose impression volume varies across countries, and those per-economy numbers are then weighted by UN/ITU estimates of each country&amp;rsquo;s total Internet population—meaning the global aggregate depends heavily on sample distribution and weighting methodology. At the individual country level, APNIC&amp;rsquo;s figures track closely with Google&amp;rsquo;s and other measurement sources, making the 42%–50% range a solid band for global deployment.&lt;/p&gt;
&lt;p&gt;IPv6 adoption remains wildly uneven across regions, fixed-line ISPs, and mobile carriers. Slow migration doesn&amp;rsquo;t necessarily mean failure: many established ISPs are still amortizing heavy capital investments in IPv4 and CGNAT gear, whereas rapidly growing mobile networks often adopt IPv6 from day one to lower total cost of ownership—making transition a question of capital cycles and market economics rather than pure protocol superiority. Today&amp;rsquo;s Internet operates as a permanent dual-stack/translation hybrid across direct IPv4, NAT/CGNAT IPv4, and native IPv6, so clinging to IPv4 doesn&amp;rsquo;t avoid complexity either. Increasingly, interoperability is absorbed at the edge by CDNs, cloud load balancers, and dual-stack transit providers rather than requiring every backend system on earth to cut over simultaneously.&lt;/p&gt;
&lt;h2 id="the-unwritten-laws-of-software-engineering"&gt;&lt;a href="https://www.manager.dev/newsletter/the-unwritten-laws-of-software-engineering" rel="noopener noreferrer"&gt;The unwritten laws of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post collects seven operational laws that engineers usually only internalize the hard way after living through production outages. First: if production breaks right after a deploy, roll back immediately (if safe to do so) to restore service and investigate afterward, instead of burning precious minutes trying to prove your commit couldn&amp;rsquo;t possibly be the cause. Second: backups don&amp;rsquo;t exist until you regularly test restoring from them, and the team knows the exact RPO, RTO, and who has permissions to run the restore. Third: logs must carry enough context and a cross-service correlation ID to trace a request end to end without drowning operators in noise.&lt;/p&gt;
&lt;p&gt;Fourth: every database migration must have a fast, concrete, pre-tested rollback plan before it touches production. Fifth: every external dependency will eventually be slow, rate-limit you, or go down completely, so understand its rate limits, failure impact, and SLAs up front and build fallbacks like caching, queues, or serving stale data. Sixth: use the four-eyes principle for risky manual operations in production—if you feel hesitant to wake a teammate up at 2 a.m. to double-check a command, that is the clearest sign you shouldn&amp;rsquo;t be running it alone. Finally, nothing is more permanent than a temporary hack, so even an MVP must be simple and solid enough to live with for years rather than a fragile patch you promise to clean up later.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!mGbr!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8558b1b2-984f-4c42-bb23-e63a2252533c_2650x3068.png" alt="Top Anti-Patterns in Service Architecture"&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><item><title>Newsletter #60</title><link>https://miti99.com/en/post/2025/10/12/</link><pubDate>Sun, 12 Oct 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/10/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #60.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="diff-algorithms"&gt;&lt;a href="https://flo.znkr.io/diff/" rel="noopener noreferrer"&gt;Diff Algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Florian Zenker introduces &lt;code&gt;znkr.io/diff&lt;/code&gt;, a diff library in Go that he built from scratch because existing libraries didn&amp;rsquo;t meet his needs. It works on arbitrary slices as well as text, returning either structured results or the familiar unified diff format. At its core is Myers&amp;rsquo; algorithm with O(ND) complexity, chosen because it works even on types that aren&amp;rsquo;t comparable with standard operators and doesn&amp;rsquo;t require hashing. The API offers &lt;code&gt;Edits()&lt;/code&gt;/&lt;code&gt;Hunks()&lt;/code&gt; for comparable types, &lt;code&gt;EditsFunc()&lt;/code&gt;/&lt;code&gt;HunksFunc()&lt;/code&gt; for arbitrary types with a custom comparison function, and the &lt;code&gt;textdiff&lt;/code&gt; package for unified diffs.&lt;/p&gt;
&lt;p&gt;The most interesting part is how he optimizes it. Preprocessing trims common prefixes and suffixes and strips elements that appear on only one side, cutting worst-case runtime by up to 99%. An anchoring technique inspired by patience diff finds elements that appear exactly once to split the input into smaller subproblems, reducing runtime by up to another 95%. Postprocessing applies Michael Haggerty&amp;rsquo;s indentation heuristic to make diffs easier for humans to read. The library offers three modes: default (balanced), fast (sacrificing minimality), and minimal (shortest diff regardless of cost). His takeaway is that &amp;ldquo;different implementations of the same algorithm can produce wildly different results&amp;rdquo;: diff quality depends heavily on implementation details and postprocessing, not just on which core algorithm you pick.&lt;/p&gt;
&lt;h2 id="building-a-resilient-data-platform-with-write-ahead-log-at-netflix"&gt;&lt;a href="https://netflixtechblog.com/building-a-resilient-data-platform-with-write-ahead-log-at-netflix-127b6712359a" rel="noopener noreferrer"&gt;Building a Resilient Data Platform with Write-Ahead Log at Netflix&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Netflix&amp;rsquo;s data platform team explains why they built a shared Write-Ahead Log (WAL) abstraction. At Netflix&amp;rsquo;s scale, problems like data loss or corruption, inconsistency across data stores (such as dual writes to Cassandra and Elasticsearch), multi-partition updates, cross-region replication, and retrying failed messages in real-time pipelines had either caused outages or forced teams to roll their own bespoke solutions. WAL was created to give every critical application that level of protection out of the box: it records data mutations, guarantees durability, and reliably propagates changes to downstream systems.&lt;/p&gt;
&lt;p&gt;The API is kept deliberately simple with a single &lt;code&gt;WriteToLog&lt;/code&gt; endpoint. Each namespace configures where data is stored (Kafka, SQS, or a combination) along with settings like retry counts, allowing WAL to serve different roles depending on configuration: an SQS-backed delay queue to retry failed messages without hurting throughput, Kafka-backed cross-region EVCache replication, and two-phase-commit coordination for multi-partition writes in the Key-Value abstraction. Internally, producers and consumers are decoupled so backends can be swapped flexibly, every namespace gets a built-in dead-letter queue (DLQ) for failure handling, and WAL guarantees at-least-once delivery semantics. Teams using the Key-Value layer simply flip a flag to get all of these capabilities.&lt;/p&gt;
&lt;h2 id="vercel-vs-cloudflare-two-philosophies-of-building-for-developers"&gt;&lt;a href="https://bharath.sh/writing/vercel-vs-cloudflare" rel="noopener noreferrer"&gt;Vercel vs Cloudflare: Two Philosophies of Building for Developers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post compares Vercel and Cloudflare as two distinct philosophies for serving developers, rooted in each company&amp;rsquo;s origins and business model. Vercel grew out of frontend developer culture and puts developer experience and velocity first: infrastructure is nearly invisible, deployments feel &amp;ldquo;magical,&amp;rdquo; and the dashboard is kept minimal to stay out of your way. Cloudflare grew out of network infrastructure and prizes control and transparency, with dashboards exposing granular technical metrics. As the author sums it up: Vercel optimizes for user confidence, whereas Cloudflare sells guarantees.&lt;/p&gt;
&lt;p&gt;This contrast mirrors how the two companies make money. Vercel monetizes development velocity, encouraging developers to ship quickly and gradually upgrade to paid tiers. Cloudflare monetizes scale itself—sustained usage, bandwidth, and compute. Each side views the other critically: Cloudflare sees Vercel as hiding true costs, while Vercel sees Cloudflare as needlessly complex, yet both approaches make sense within their respective domains. As edge computing and AI workloads grow, the two platforms are converging, each striving to pair great developer experience with powerful underlying infrastructure.&lt;/p&gt;
&lt;h2 id="distracting-software-engineers-is-way-more-harmful-than-most-managers-think"&gt;&lt;a href="https://workweave.dev/blog/distracting-software-engineers-is-more-harmful-than-managers-think-even-in-the-ai-times" rel="noopener noreferrer"&gt;Distracting Software Engineers Is Way More Harmful Than Most Managers Think&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that interrupting software engineers is far more damaging than most managers realize, and that the problem has worsened with the rise of remote work since COVID. The author cites several stats: meetings per employee have risen 13.5% since 2020, virtual meetings are up 60%, 92% of people multitask during meetings, and a study at Meta found engineers get only about two one-hour focus blocks per week. Reaching a state of deep flow takes roughly 45 minutes, and every interruption resets that timer to zero. Tasks like code review and debugging require deep concentration yet often get squeezed hastily between meetings. Even with AI coding tools, deep focus leads to fewer bugs and faster skill growth.&lt;/p&gt;
&lt;p&gt;Proposed solutions include batching meetings into fixed time blocks, requiring a clear agenda, and inviting only people who are truly needed; eliminating recurring meetings, like Pylon&amp;rsquo;s engineering team keeping calendars empty and coordinating only as needed; rethinking mandatory peer reviews by trusting strong engineers to ship changes directly; and having managers lead by example in protecting focus time. The author concludes that engineers need 4–5 uninterrupted hours a day to produce quality work.&lt;/p&gt;
&lt;h2 id="common-problems-managing-senior-engineers"&gt;&lt;a href="https://emdiary.substack.com/p/common-problems-managing-senior-engineers" rel="noopener noreferrer"&gt;Common Problems Managing Senior Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post describes four senior engineer archetypes that frequently challenge managers and how to coach each one. The Over-Engineer loves needlessly complex solutions; managers should anchor them to practical value by asking &amp;ldquo;what&amp;rsquo;s the simplest thing that could possibly work?&amp;rdquo;, requiring decision records that lay out options and trade-offs, and setting clear time or budget constraints. The Builder-First jumps straight into coding without designing first; show them that an imperfect design doc is fine, that design helps assess feasibility, estimate effort, and align the team, and that they can reuse familiar templates from past projects. The Ambiguity-Freezer freezes up when requirements are vague; coach them to ask clarifying questions about stakeholders, metrics, and success criteria, and apply inversion thinking—figuring out what would make the project fail and doing the opposite. The Soloist avoids delegating because doing it themselves feels faster; teach them to plan work in parallel streams, show how delegating frees them up for higher-impact problems, and use pair programming to build trust with teammates.&lt;/p&gt;
&lt;p&gt;The overarching message is that these engineers&amp;rsquo; struggles stem from habits and blind spots rather than a lack of ability. As the author puts it, &amp;ldquo;They don&amp;rsquo;t need micromanagement, they need coaching.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="career-advice-or-something-like-it"&gt;&lt;a href="https://brooker.co.za/blog/2025/06/20/career.html" rel="noopener noreferrer"&gt;Career Advice, or Something Like It&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker advises staying away from &amp;ldquo;negative echo chambers&amp;rdquo; where complaining becomes the group&amp;rsquo;s shared identity. Such communities create a sense of belonging in the short term but harm both your career and mental health over time; Brooker sets a personal threshold and leaves when roughly 20% of a group&amp;rsquo;s content turns negative. He argues that people should consciously choose one of two paths: either focus on growing your career by looking for positives and things you can improve, or stay comfortable where you are and pour your energy into other parts of life, rather than getting stuck in cynicism.&lt;/p&gt;
&lt;p&gt;Instead of spaces dominated by griping, spend time in &amp;ldquo;yes, and&amp;rdquo; environments alongside people doing admirable work and living lives you aspire to. Communities degrade when negativity takes over, so protecting them requires leading by example, sharing constructive perspectives, and occasionally moderating discussions; he admits that &amp;ldquo;doing this is socially hard. At the very least, it requires visibly modeling the good.&amp;rdquo; In his view, sadness and anger rarely produce real change—only concrete action does.&lt;/p&gt;
&lt;h2 id="my-productivity-rules"&gt;&lt;del&gt;&lt;a href="https://www.16elt.com/2025/10/08/studying-while-busy/" rel="noopener noreferrer"&gt;My Productivity Rules&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post shares practical tips for improving study productivity, emphasizing planning, energy management, honesty about effort, daily reviews, and minimizing distractions. It outlines rules such as planning the next day the night before, resting when energy is low, being honest about how much real effort you put in, reflecting on daily progress, and removing distractions like phones or tempting apps.&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;- Plan the next day the night before to avoid morning procrastination&lt;/del&gt;
&lt;del&gt;- Match study intensity to your energy levels throughout the day&lt;/del&gt;
&lt;del&gt;- Be honest about how much real effort you are putting in&lt;/del&gt;
&lt;del&gt;- Reflect on daily progress to improve future plans&lt;/del&gt;
&lt;del&gt;- Eliminate distractions by keeping tempting apps out of sight&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="bonus-an-interesting-visual-from-bytebytego"&gt;Bonus: An interesting visual from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;em&gt;Today I ran into a pretty annoying issue from storing too many collected images directly in the repo. Specifically, it took over 17 minutes to build this site on another machine :v&lt;/em&gt;&lt;/p&gt;
&lt;pre tabindex="0"&gt;&lt;code&gt;...
 | VI
-------------------+------
 Pages | 587
 Paginator pages | 130
 Non-page files | 195
 Static files | 2
 Processed images | 361
 Aliases | 236
 Cleaned | 0

Built in 1043990 ms
...
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;&lt;em&gt;So I decided to switch to using the original image URLs instead of committing images into the repo. The downside is that images might get taken down, and they won&amp;rsquo;t be processed to reduce file size, which increases page load time. I&amp;rsquo;ll try to update the images in older posts too (on some nice sunny day when I&amp;rsquo;m feeling diligent :3)&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://substackcdn.com/image/fetch/$s_!KwvJ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F8ac50da4-feb8-4781-8bb2-e74244aa889f_2250x2814.png" alt="TCP vs UDP"&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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #58</title><link>https://miti99.com/en/post/2025/10/01/</link><pubDate>Wed, 01 Oct 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/10/01/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;Today I tried hooking up &lt;a href="https://github.com/musistudio/claude-code-router" rel="noopener noreferrer"&gt;Claude Code Router&lt;/a&gt; to the &lt;code&gt;openai/gpt-oss-120b&lt;/code&gt; model on &lt;a href="https://build.nvidia.com/" rel="noopener noreferrer"&gt;NVIDIA NIM&lt;/a&gt;, but it hit some error and produced no output at all. So we&amp;rsquo;re back to &lt;code&gt;qwen3-coder&lt;/code&gt; running on &lt;a href="https://platform.iflow.cn/docs/api-mode" rel="noopener noreferrer"&gt;iFlow Platform&lt;/a&gt;.&lt;/del&gt; Enjoy Newsletter #58.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-software-engineers-make-productive-decisions-without-slowing-the-team-down"&gt;&lt;a href="https://strategizeyourcareer.com/p/how-software-engineers-make-productive-decisions" rel="noopener noreferrer"&gt;How Software Engineers Make Productive Decisions (without slowing the team down)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many development teams slow down simply because they treat every decision as if it were irreversible. Author Fran Soto proposes clearly distinguishing between two types: &amp;ldquo;two-way door&amp;rdquo; decisions (easy to reverse, such as adding an unused field to an API response, gating a change behind a feature flag, or swapping out an internal library) and &amp;ldquo;one-way door&amp;rdquo; decisions (hard or impossible to reverse, such as data migrations, schema changes, security changes, or customer-visible changes that risk data loss). To classify a decision quickly, the article offers three questions: if you&amp;rsquo;re wrong, is the impact unnoticeable, an annoyance, or a disaster; how hard is it to roll back, for instance can you revert within ten minutes using existing alerting; and can you limit the blast radius with a canary, feature flag, or phased rollout?&lt;/p&gt;
&lt;p&gt;For reversible decisions, the author advises time-boxing research to 30–60 minutes and then acting, backed by guardrails: feature flags defaulting to off, small pull requests, tests covering both states, canary checks, solid alerting, and a ten-minute rollback playbook. Heavy caution should be reserved for decisions that are genuinely hard to undo. The core takeaway: when risk is low and the change is reversible, ship with guardrails—that&amp;rsquo;s how you move fast without being reckless.&lt;/p&gt;
&lt;h2 id="why-are-event-driven-systems-hard"&gt;&lt;a href="https://newsletter.scalablethread.com/p/why-event-driven-systems-are-hard" rel="noopener noreferrer"&gt;Why are Event-Driven Systems Hard?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Event-driven architecture decouples services and makes them easier to scale, but comes with five major challenges. First is event schema evolution: when one service adds or changes a field without coordination, downstream consumers can break; the fix is enforcing backward and forward compatibility rules alongside a schema registry acting as a central dictionary for event formats. Second is observability: because processing flows are split across independent services, seeing the full picture during debugging is difficult; the remedy is distributed tracing with a correlation ID—an identifier attached to the initial event and propagated through every processing step to reconstruct a request&amp;rsquo;s journey.&lt;/p&gt;
&lt;p&gt;Third is failure handling: at-least-once delivery prevents message loss when infrastructure hiccups, while a Dead-Letter Queue (DLQ) captures messages that repeatedly fail after a bounded number of retries, preventing infinite error loops and allowing later inspection. Fourth, at-least-once delivery itself means a service may receive the same message multiple times if it crashes before acknowledging completion, so consumers must be idempotent: recording processed event IDs and skipping duplicates (coordinated atomically with business state updates so there is no gap) to avoid bugs like charging a customer twice. Finally, eventual consistency: because data propagates asynchronously across services, both UI and business logic must tolerate systems being temporarily out of sync.&lt;/p&gt;
&lt;h2 id="dev-culture-is-dying-the-curious-developer-is-gone"&gt;&lt;a href="https://dayvster.com/blog/dev-culture-is-dying-the-curious-developer-is-gone/" rel="noopener noreferrer"&gt;Dev Culture Is Dying: The Curious Developer Is Gone&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author argues that developer culture is shifting in a troubling direction. Foundational tools like VLC, Linux, Git, and Docker were born out of curiosity and a desire to solve problems, not for profit or clout. He recalls the 2000s, when programmers stayed up all night tinkering with new technology purely to learn, expecting neither commercial reward nor recognition. Today, attention has shifted to metrics like MRR, ARR, DAU, MAU, SEO rankings, and conversion rates, and many developers chase new frameworks out of pressure to look current rather than genuine interest. Intrinsic motivation has gradually given way to external validation.&lt;/p&gt;
&lt;p&gt;The post also points to an identity crisis: developers define themselves by their tools, becoming a &amp;ldquo;Next.js developer&amp;rdquo; or &amp;ldquo;Rust developer&amp;rdquo; instead of by the problems they solve. The author compares consumer software&amp;rsquo;s shift toward subscription models with creators losing ownership of their craft to corporations or growth metrics, asking whether developers still care about the software they build or only about revenue. The closing call to action is to go back to building curiosity-driven projects—even things that can&amp;rsquo;t be monetized—building for the joy of it and sharing them to inspire others.&lt;/p&gt;
&lt;h2 id="tool-calls-are-expensive-and-finite"&gt;&lt;a href="https://www.reillywood.com/blog/tool-calls-are-expensive-and-finite/" rel="noopener noreferrer"&gt;Tool Calls Are Expensive And Finite&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Giving LLMs access to tools enables powerful agents, but Reilly Wood reminds us that a tool call is orders of magnitude more expensive than a normal function call in code, and the number of calls you can make is practically finite. Under the hood, a tool call is still text generation: the model emits structured text (JSON) specifying the tool name and arguments, the harness parses it, executes the real function, and appends the result into the conversation history as a new message before the model reasons further. Every call therefore burns output tokens to generate the invocation and consumes context window space because the result stays in history.&lt;/p&gt;
&lt;p&gt;The author illustrates this with the task of processing 1,000 user IDs via &lt;code&gt;get_user_info()&lt;/code&gt;: a programmer would simply write a loop, whereas an agent would have to make 1,000 individual tool calls and would likely exhaust its context window before finishing. The post suggests three remedies: design agents for tasks that don&amp;rsquo;t require many tool calls, build more flexible tools so each call accomplishes more work, or let the agent write and execute code itself—provided proper security sandboxing is in place.&lt;/p&gt;
&lt;h2 id="keeping-secrets-out-of-logs"&gt;&lt;a href="https://allan.reyes.sh/posts/keeping-secrets-out-of-logs/" rel="noopener noreferrer"&gt;Keeping Secrets Out of Logs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Allan Reyes examines why secrets like passwords and tokens keep leaking into logs, stressing that there is no &amp;ldquo;silver bullet&amp;rdquo; that solves the problem completely—only a combination of &amp;ldquo;lead bullets,&amp;rdquo; imperfect defenses that complement one another. Six common causes are: forgetting to remove debug log statements; logging entire large objects such as config structs or HTTP responses; changing the global log level and exposing previously hidden details; secrets embedded in URLs; error monitoring tools capturing local variables; and users accidentally typing their password into the username field.&lt;/p&gt;
&lt;p&gt;Mitigations include funneling logs through a single pipeline; minimizing, redacting, encrypting, or hashing sensitive data; domain primitives that wrap secrets in dedicated types to prevent accidental logging; read-once objects that lock their value after the first read; log formatters that detect and scrub sensitive patterns; unit tests that fail when sensitive data appears; post-write secret scanners; log preprocessors before storage (such as Vector); static-analysis taint checking; and human training. The broader strategy combines laying a solid foundation, understanding data flows, guarding choke points, layering defenses, and preparing incident response and recovery plans for leaks. The author admits this work is never truly finished because new systems can always bypass existing safeguards.&lt;/p&gt;
&lt;h2 id="things-i-believe"&gt;&lt;a href="https://leerob.com/beliefs" rel="noopener noreferrer"&gt;Things I Believe&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lee Robinson shares the beliefs that shape how he works. First, shipping fast beats a perfect strategy: speed is a superpower, small teams ship faster, and user adoption matters more than merely pushing code. Careers have no ceiling: persistence beats innate talent, steady daily improvements compound over time, and you should take initiative and be helpful. He values truth-seeking—confronting uncomfortable truths, holding strong opinions loosely, and listening to diverse perspectives.&lt;/p&gt;
&lt;p&gt;In his view, communication is the job: clear writing reflects clear thinking, everyone should hone their writing skills, and leaders must clarify ambiguity to prevent misaligned expectations. Leadership doesn&amp;rsquo;t require a title, because influence matters more than position; great leaders both do hands-on work and empower others. Work can also be a hobby when passion is paired with clear boundaries, rather than chasing a mythical &amp;ldquo;work–life balance.&amp;rdquo; Hiring should be uncompromising—only hire candidates who are a &amp;ldquo;hell yes&amp;rdquo; and prioritize growth potential. Finally, always assume good intent, lead with empathy, take criticism objectively, and remember that a working demo is more persuasive than a long memo.&lt;/p&gt;
&lt;h2 id="how-claude-code-is-built"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/how-claude-code-is-built" rel="noopener noreferrer"&gt;How Claude Code is Built&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Claude Code started as a prototype built by Boris Cherny in September 2024: using Claude to control a terminal via AppleScript, initially just to check what song was playing. Once the team saw the model exploring the filesystem on its own, they realized its product potential. Anthropic began using it internally in November 2024, and within five days half of its engineers were on board; although they considered keeping it internal as a competitive advantage, they released it publicly to advance AI safety research. The team chose TypeScript, React with the Ink framework, the Yoga layout engine, and Bun because these technologies are &amp;ldquo;on distribution&amp;rdquo;—things Claude is already great at—allowing roughly 90% of Claude Code&amp;rsquo;s codebase to be written by Claude Code itself.&lt;/p&gt;
&lt;p&gt;Architecturally, Claude Code is a thin shell around the model with minimal business logic, running directly on the user&amp;rsquo;s machine without virtualization. The most complex part is the permission system: the tool asks for user approval before irreversible actions, supporting one-time or persistent grants with multi-level configuration across project, user, and enterprise scopes. Prototyping speed is equally striking: when building the to-do list feature, the team tried around 20 different prototypes in just two days. Even as the engineering team doubled in size, completed pull requests per engineer rose by 67%—a metric that usually drops during rapid team growth.&lt;/p&gt;
&lt;h2 id="bonus-some-cool-visuals-from-bytebytego"&gt;Bonus: Some cool visuals 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/1e27232c-d4f1-4f4b-94fa-7318d39f6f3e_2360x2960.png" alt="How Java Works"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9bef6181-7eed-45a9-9c7e-abd6864cc62b_2360x2960.png" alt="How Gitflow Branching Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/9ffab5bc-5857-4544-8e25-2dbf795e6f85_3000x3900.png" alt="The Life of a Redis Query"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1c2bd03d-66f2-4eb9-8293-7a1d49b9b9b6_2360x2920.png" alt="Cookies vs Sessions"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/26b55058-17ae-453f-8463-4d4e717e489b_2360x2920.png" alt="Access Control Clearly Explained"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/00912640-ad5f-4ec7-aefa-e5eecf67dab0_3000x3900.png" alt="How Git Reset Works?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/43b73739-a975-42af-999d-8676b1605ed2_3000x3900.png" alt="Apache Kafka Explained (At the high level)"&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><item><title>Newsletter #29</title><link>https://miti99.com/en/post/2025/05/16/</link><pubDate>Fri, 16 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/16/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #29 - Today&amp;rsquo;s tech news roundup.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-clean-approach-to-process-optimization"&gt;&lt;a href="https://queue.acm.org/detail.cfm?id=3722546" rel="noopener noreferrer"&gt;A Clean Approach to Process Optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas A. Limoncelli opens with an everyday example: how he reorganized doing the dishes at home. Instead of waiting until the start of a wash cycle to add detergent to the dishwasher, he does it right after unloading the clean dishes. Simply reordering the steps made the chore smoother without any extra effort. He then applied this exact mindset to customer onboarding at his company, cutting wait times from several days down to just a few minutes.&lt;/p&gt;
&lt;p&gt;The core idea is to split a process into two phases. The slow phase covers generic tasks that can be done in advance before an order arrives; the fast phase handles only the specific customization after the order comes in. Alongside this, review optional tasks, since they are often unnecessary or can be done more efficiently. For junior developers, this is a practical lesson: the same approach applies to software deployment pipelines, infrastructure provisioning, and many other areas, improving both performance and service quality.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="microsoft"&gt;&lt;a href="https://www.gatesnotes.com/microsoft-original-source-code" rel="noopener noreferrer"&gt;Microsoft&amp;rsquo;s Original Source Code Released for 50th Anniversary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;To mark Microsoft&amp;rsquo;s 50th anniversary, Bill Gates released the original source code for Altair BASIC, the company&amp;rsquo;s first product, calling it the &amp;ldquo;coolest&amp;rdquo; code he has ever written. The story began with the January 1975 cover of Popular Electronics featuring the Altair 8800 computer from MITS. Gates and Paul Allen contacted founder Ed Roberts and told him they already had a version of BASIC for the Altair&amp;rsquo;s chip, even though they hadn&amp;rsquo;t written a single line yet. The pair chose to build an interpreter rather than a compiler because running code line by line gave beginners immediate feedback and made debugging easier.&lt;/p&gt;
&lt;p&gt;Since they didn&amp;rsquo;t have an Intel 8080 chip, Allen wrote a simulator for it on Harvard&amp;rsquo;s PDP-10 mainframe, Gates wrote the core interpreter, and Monte Davidoff handled the math package. After about two months of working day and night, they squeezed the entire interpreter into just 4 KB of memory using compact data structures and efficient algorithms, because memory at the time cost more than the computer itself. The demo succeeded, MITS licensed the software, and Micro-Soft was born. For developers today, it is a vivid example of optimizing under extreme hardware constraints; Gates tells the fuller story in his memoir &amp;ldquo;Source Code.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="no-code-is-dead-long-live-vibe-coding"&gt;&lt;a href="https://kenneth.io/post/no-code-is-dead-long-live-vibe-coding" rel="noopener noreferrer"&gt;No code is dead. Long live vibe coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kenneth Auchenberg makes a blunt call: in 2025, no-code is dead. For a decade, no-code and low-code platforms promised to democratize software creation, yet none truly broke through or replaced traditional programming. Instead, a new generation of tools powered by AI and large language models is emerging, known as &amp;ldquo;vibe coding.&amp;rdquo; Tools like Bolt, Lovable, and v0 show that generating real, production-grade code from natural-language descriptions is not only viable, but better than drag-and-drop WYSIWYG editors.&lt;/p&gt;
&lt;p&gt;According to the author, users turned out not to want &amp;ldquo;less code&amp;rdquo;—they wanted a better way to write code. They don&amp;rsquo;t want to be locked into proprietary runtimes; they want real source code, full control, and the freedom to edit and deploy anywhere. The previous generation, such as Webflow and Retool, bundled the editor, hosting, runtime, and UI components into a closed system. Now, large language models can generate clean React code that follows open standards and industry best practices, ready to deploy onto open infrastructure. The author calls this the &amp;ldquo;unbundling&amp;rdquo; of no-code.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="simple-scalable-and-global-containers-are-coming-to-cloudflare-workers-in-june-2025"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-containers-coming-2025/" rel="noopener noreferrer"&gt;Simple, scalable, and global: Containers are coming to Cloudflare Workers in June 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare announced that Containers will enter open beta in late June 2025. Workers are already the simplest way to deploy software globally, but there are workloads they cannot handle: running user-generated code in arbitrary languages, executing CLI tools that require a full Linux environment, using multiple gigabytes of memory or multiple CPU cores, or lifting and shifting applications from AWS, GCP, or Azure without a rewrite. Containers fill that gap. With just a few lines of Wrangler configuration and &lt;code&gt;wrangler deploy&lt;/code&gt;, containers spin up on demand near the user, go to sleep after a configurable timeout, and support autoscaling based on CPU usage.&lt;/p&gt;
&lt;p&gt;What sets them apart is the architecture: each container is backed by a Durable Object acting as a programmable &amp;ldquo;sidecar,&amp;rdquo; letting you start, stop, run commands, and monitor container state directly from code. That allows Workers to act as an API gateway, service mesh, or orchestrator for containers without writing Kubernetes operators or configuring a complex control plane. On pricing, users pay only for the time a container actually runs, billed per vCPU, memory, and disk at rates Cloudflare says are competitive with Google Cloud Run. The takeaway: handle the bulk of requests with lightweight, inexpensive Workers, and reach for containers only for heavy workloads that truly need them.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-types-of-companies-you-can-work-for-and-what-they-do-for-your-career"&gt;&lt;a href="https://www.elenaverna.com/p/the-types-of-companies-you-can-work" rel="noopener noreferrer"&gt;The types of companies you can work for and what they do for your career&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Elena Verna advises choosing where you work intentionally rather than chasing titles or compensation. She breaks companies into six archetypes. &amp;ldquo;Unicorns&amp;rdquo; grow around 100% year over year, like early Miro or Figma: the pace is breakneck and burnout is a real risk, but experience there opens many doors. &amp;ldquo;Tankers&amp;rdquo; like Google, Apple, and Microsoft run with mature processes, high pay, and abundant training resources—great for starting a career, though roles are highly specialized and progress is slow. &amp;ldquo;Declining Giants&amp;rdquo; are in constant reorganization; pressure for results is intense, but advancement can be fast. &amp;ldquo;Survival Mode&amp;rdquo; startups haven&amp;rsquo;t found product-market fit yet: autonomy is high and skills broaden quickly, but the risk is steep and the author advises newcomers to avoid them.&lt;/p&gt;
&lt;p&gt;The remaining two are &amp;ldquo;Lifestyle Boats,&amp;rdquo; often bootstrapped, profitable, and sustainably growing like Basecamp, which are great for beginners thanks to a supportive environment; and &amp;ldquo;Social Good Seekers,&amp;rdquo; where social impact comes before revenue—pay may be lower, but fulfillment is high. To identify which type a company is, ask about headcount, revenue growth over the past three years, and how much runway remains before the next fundraise. At the same time, ask yourself how much change and pressure you can tolerate, whether you need a clearly defined role, and what your current financial priorities are.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-to-create-a-chain-reaction-of-good-habits"&gt;&lt;a href="https://jamesclear.com/domino-effect" rel="noopener noreferrer"&gt;How to Create a Chain Reaction of Good Habits&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Clear, author of &amp;ldquo;Atomic Habits,&amp;rdquo; explains the Domino Effect: when you change one behavior, it sets off a chain reaction that shifts related behaviors too. He shares the story of Jennifer Dukes Lee, who didn&amp;rsquo;t make her bed for over twenty years; after doing it four days in a row, she found herself folding laundry, washing the dishes, and organizing the kitchen cabinets. A 2012 Northwestern University study similarly found that when people cut down their sedentary time, they naturally ate less fat even though nobody asked them to. The effect works for bad habits as well—checking your phone leads to scrolling social media, which turns into twenty more minutes of procrastination.&lt;/p&gt;
&lt;p&gt;Clear argues this happens because daily habits are tightly interconnected and because of the principle of commitment and consistency: once we make even a tiny commitment, we tend to follow through because it aligns with our self-image. To deliberately trigger a positive domino chain, start with the small habit you feel most motivated to do and practice it consistently, ride the momentum of finishing one task straight into the next, and when things get hard, break them into smaller pieces and focus on consistency rather than outcomes. Remarkably, the effect doesn&amp;rsquo;t just create new behaviors—it shifts beliefs: each falling domino helps you believe in a new version of yourself and build identity-based habits.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-post-developer-era"&gt;&lt;a href="https://www.joshwcomeau.com/blog/the-post-developer-era/" rel="noopener noreferrer"&gt;The Post-Developer Era&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Two years after writing &amp;ldquo;The End of Front-End Development&amp;rdquo; when GPT-4 launched, Josh W. Comeau revisits whether we have entered a &amp;ldquo;post-developer era.&amp;rdquo; His answer is no. The headline figure that &amp;ldquo;AI writes over 25% of code at Google&amp;rdquo; is easy to misread, because AI isn&amp;rsquo;t working autonomously—skilled developers are always at the wheel, steering and editing. Meanwhile Devin, pitched as an autonomous replacement for software engineers, completed only 3 out of 20 tasks in an independent team&amp;rsquo;s real-world evaluation. Comeau uses Cursor with Claude Sonnet and finds it impressive, but compares it to cruise control: take your hands off the wheel and the car slowly drifts out of its lane. Non-programmers won&amp;rsquo;t spot subtle bugs and eventually end up stuck with an unmaintainable mess.&lt;/p&gt;
&lt;p&gt;The job market remains tough, but Comeau attributes that primarily to high interest rates, waves of layoffs at large tech companies, and the mistaken belief among executives that AI is about to make developers redundant—not to AI actually replacing people. He also worries that newcomers will fall into &amp;ldquo;vibe coding,&amp;rdquo; endlessly clicking accept without understanding the code. Conversely, if you use AI actively as a personal tutor, there has never been a better time to learn programming, and a &amp;ldquo;developer renaissance&amp;rdquo; may follow once companies realize AI is a force multiplier rather than a replacement.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="everything-wrong-with-model-context-protocol-mcp"&gt;&lt;a href="https://blog.sshh.io/p/everything-wrong-with-mcp" rel="noopener noreferrer"&gt;Everything Wrong With Model Context Protocol (MCP)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shrivu Shankar examines the flaws and limitations of the Model Context Protocol, the standard for connecting third-party tools and data to AI assistants like Claude, ChatGPT, and Cursor. On protocol security, the initial version didn&amp;rsquo;t define an authentication mechanism and the subsequent specification drew criticism for its complexity; running MCP servers locally over stdio creates a shortcut for less experienced users to download and execute malware; and many servers trust inputs and execute them directly. On user experience, MCP doesn&amp;rsquo;t distinguish risk levels between a tool that reads logs and one that deletes files, offers no token-cost controls, and at the time of writing only returned unstructured text—something later specs addressed.&lt;/p&gt;
&lt;p&gt;More serious is the security of the language models themselves. Tool descriptions are typically injected into the system prompt, giving them outsized influence over the agent; a server can silently rename or rewrite tool descriptions after the user has approved them, and data pulled from fourth-party sources—such as a database row—can carry prompt injections. Easy data aggregation also lets employees infer sensitive information from data they are individually permitted to view. Finally, model reliability drops when too many tools are exposed, and simple primitives like listing or reading files fall short of the queries users expect. Shankar concludes that safe adoption requires a secure-by-default protocol, applications that protect users, and users who understand the trade-offs of their choices.&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 #27</title><link>https://miti99.com/en/post/2025/05/14/</link><pubDate>Wed, 14 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #27.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="heading"&gt;&lt;a href="https://blog.cloudflare.com/introducing-the-cloudflare-vite-plugin/" rel="noopener noreferrer"&gt;&amp;ldquo;Just use Vite&amp;rdquo;&amp;hellip; with the Workers runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare announced version 1.0 of the Cloudflare Vite plugin alongside official support for React Router v7. Previously, Vite&amp;rsquo;s development server always executed server-side code inside Node.js—even when the application targeted Cloudflare Workers in production—causing subtle, hard-to-catch discrepancies between local dev and production. Built on the experimental Environment API introduced in Vite 6, the new plugin runs your Worker code directly inside the native Workers runtime (&lt;code&gt;workerd&lt;/code&gt;) during local development, keeping dev behavior as close to production as possible.&lt;/p&gt;
&lt;p&gt;For single-page applications (SPAs) built with React, Vue, or Svelte, you can scaffold a new project with the &lt;code&gt;create-cloudflare&lt;/code&gt; CLI or migrate an existing app simply by adding &lt;code&gt;@cloudflare/vite-plugin&lt;/code&gt; to your Vite config and creating a &lt;code&gt;wrangler.jsonc&lt;/code&gt; file. When you edit server-side Worker code, Vite hot-reloads the Worker environment without losing client-side UI state in the browser. Running &lt;code&gt;vite build&lt;/code&gt; outputs both client and server bundles, &lt;code&gt;vite preview&lt;/code&gt; previews the production build inside the Workers runtime, and &lt;code&gt;wrangler deploy&lt;/code&gt; deploys straight to Cloudflare without an extra bundling step. With React Router v7 (the successor to Remix), a single entry file defines the Worker across both dev and build without needing a separate adapter, and the plugin supports the full Cloudflare Developer Platform including KV, D1, Durable Objects, and Workers AI.&lt;/p&gt;
&lt;h2 id="the-best-programmers-i-know"&gt;&lt;a href="https://endler.dev/2025/best-programmers/" rel="noopener noreferrer"&gt;The Best Programmers I Know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthias Endler distills the common traits he has observed in the best programmers he has ever worked with—a list he wishes he had when starting out. First and foremost, they read the canonical reference documentation directly instead of guessing, copying from Stack Overflow, or asking an LLM. Second, they know their tools inside and out: why the tool was created, who maintains it, where its limits lie, and what the surrounding ecosystem looks like. Great programmers also actually read error messages carefully, break intimidating problems down into small, solvable steps, and aren&amp;rsquo;t afraid to get their hands dirty in unfamiliar codebases—which is how they become the go-to person on their team.&lt;/p&gt;
&lt;p&gt;Beyond raw technical chops, they generously help others, write clearly because clear writing reflects clear thinking, and never stop learning—some of the sharpest programmers Endler knows are in their 60s and still run circles around developers half their age. They don&amp;rsquo;t care about titles or hierarchy, build lasting reputation by shipping widely used work, stay patient with both computers and people, never blame &amp;ldquo;random&amp;rdquo; hardware glitches or compiler bugs before checking their own assumptions, aren&amp;rsquo;t afraid to say &amp;ldquo;I don&amp;rsquo;t know,&amp;rdquo; refuse to guess when requirements are ambiguous, and relentlessly favor simple code. Endler notes that this isn&amp;rsquo;t a checklist or a competition, just a reminder that there are no shortcuts around deliberate practice.&lt;/p&gt;
&lt;h2 id="rdel-87-how-do-ai-coding-tools-actually-change-developer-work"&gt;&lt;a href="https://rdel.substack.com/p/rdel-87-how-do-ai-coding-tools-actually" rel="noopener noreferrer"&gt;RDEL #87: How do AI coding tools actually change developer work?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this installment of &lt;em&gt;Research-Driven Engineering Leadership&lt;/em&gt;, Lizzie Matusov summarizes a three-week randomized controlled trial conducted by Microsoft and the Institute for Work Life across 228 engineers at a global software company. Participants were split into three groups—engineers newly granted access to GitHub Copilot, a control group using no AI tools, and a comparison group of existing Copilot users—combining daily diary studies with system telemetry. Before the trial began, 86% of experienced Copilot users believed AI coding tools were useful compared to just 44% of non-users, and the single most common reason engineers hadn&amp;rsquo;t tried AI tools yet was simply being too busy.&lt;/p&gt;
&lt;p&gt;After three weeks, enjoyment and perceived usefulness rose significantly among the new users; 84% reported that Copilot positively changed how they worked, cutting down on tedious boilerplate and making coding more enjoyable. Engineers used Copilot not just for code completion, but also as a replacement for web search and as a sounding board for ideation and design. Interestingly, system telemetry showed no statistically significant difference in lines of code, pull request volume, or active coding time, and engineers&amp;rsquo; baseline level of trust in AI-generated code remained unchanged. Matusov advises engineering leaders to measure productivity holistically across satisfaction and flow using the SPACE framework, carve out dedicated time for teams to experiment, and view AI as a way to offload repetitive drudgery so engineers can focus on design and learning.&lt;/p&gt;
&lt;h2 id="overclocking-dbt-discord"&gt;&lt;a href="https://discord.com/blog/overclocking-dbt-discords-custom-solution-in-processing-petabytes-of-data" rel="noopener noreferrer"&gt;Overclocking dbt: Discord&amp;rsquo;s Custom Solution in Processing Petabytes of Data&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Discord data engineer Chris Dong shares how his team scaled &lt;code&gt;dbt&lt;/code&gt; (data build tool) to process petabytes of data across more than 100 developers collaborating on 2,500+ models. Their out-of-the-box setup quickly hit a wall: full project compilation took over 20 minutes, default incremental materialization strategies struggled at petabyte scale, and developers constantly clobbered each other&amp;rsquo;s test tables in shared environments. To isolate environments cleanly, they overrode the &lt;code&gt;generate_alias_name&lt;/code&gt; macro to automatically prefix table names with the developer&amp;rsquo;s username in local dev, the PR number or commit SHA in CI/CD, and the canonical name in production.&lt;/p&gt;
&lt;p&gt;On the performance side, they replaced standard &lt;code&gt;MAX(timestamp)&lt;/code&gt; incremental filtering with explicit &lt;code&gt;start_date&lt;/code&gt; and &lt;code&gt;end_date&lt;/code&gt; variables—noting that the expensive full-table scans came from the &lt;code&gt;MAX(timestamp)&lt;/code&gt; subquery in the old pattern rather than the &lt;code&gt;is_incremental()&lt;/code&gt; macro itself. They also patched partial-parsing hash mismatches and leveraged zero-copy BigQuery partition copies; together, these optimizations sped up runs by 5x. Historical backfills were automated via semantic versioning inside each model&amp;rsquo;s &lt;code&gt;meta&lt;/code&gt; config: bumping the major version triggers a full refresh of the table and all downstream dependents, while bumping the minor version runs a targeted date-chunked backfill. A shared macro library and Buildkite CI/CD pipeline validate query dry-run costs, dependencies, and blast radius before any change lands in production.&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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #25</title><link>https://miti99.com/en/post/2025/05/12/</link><pubDate>Mon, 12 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/12/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #25.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-13-software-engineering-laws"&gt;&lt;a href="https://newsletter.manager.dev/p/the-13-software-engineering-laws" rel="noopener noreferrer"&gt;The 13 software engineering laws&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anton Zaides rounds up 13 classic &amp;ldquo;laws&amp;rdquo; every software engineer and engineering manager should know. On time and staffing: Parkinson&amp;rsquo;s Law (work expands to fill the time allotted) is counterbalanced by Hofstadter&amp;rsquo;s Law (it always takes longer than you expect), meaning estimation only improves through practice, communication, and flexible scope. Brooks&amp;rsquo;s Law reminds us that adding people to a late software project makes it later. Conway&amp;rsquo;s Law states that system architecture mirrors an organization&amp;rsquo;s communication structure; Flo applied the &amp;ldquo;Inverse Conway Maneuver&amp;rdquo; by embedding iOS, Android, and backend engineers into cross-functional teams to ship 20–30 releases per day. Cunningham&amp;rsquo;s Law offers a clever way to get unstuck: open a pull request—even if you aren&amp;rsquo;t sure it&amp;rsquo;s right—and the owning team will quickly jump in to show you the right way.&lt;/p&gt;
&lt;p&gt;On products and teams: Sturgeon&amp;rsquo;s Law (90% of everything is crud) and Zawinski&amp;rsquo;s Law (every program attempts to expand until it can read mail) warn against feature bloat, while Hyrum&amp;rsquo;s Law guarantees that with enough users, every observable behavior of your system will be depended on by someone, making removals painful. Price&amp;rsquo;s Law (half the work is done by the square root of the total number of contributors) and the Ringelmann Effect (individual effort drops as group size grows) explain why small teams with clear ownership outperform large ones. Goodhart&amp;rsquo;s Law (when a measure becomes a target, it ceases to be a good measure) is balanced by Gilb&amp;rsquo;s Law (imperfect measurement beats no measurement at all). Rounding out the list is Murphy&amp;rsquo;s Law. Zaides concludes that while these aren&amp;rsquo;t physical laws of nature, they are invaluable mental models.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-curve-is-bending-predictions-on-near-term-ai-inference-spending"&gt;&lt;a href="https://grantslatton.com/the-curve-is-bending" rel="noopener noreferrer"&gt;The Curve is Bending: Predictions on near-term AI inference spending&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Grant Slatton, creator of the high-performance spreadsheet engine Row Zero, argues that AI has just crossed an inflection point where the economic value it generates for real-world software engineering exceeds its cost. His personal AI spend jumped from $100/year in 2023 to roughly $5,000/year in 2025. For him, &lt;code&gt;o1-pro&lt;/code&gt; was the first model that felt reliably useful, performing on par with a junior engineer on self-contained single-file tasks—such as pinpointing a bug given a large Rust file, a git diff, and failing test output. He uses Zed Editor&amp;rsquo;s prompt library to generate repetitive spreadsheet functions (cutting 20 minutes of work down to 2), writes small LLM-powered CLI utilities for himself, and used Claude Code—sometimes running three sessions in parallel—to rewrite the entire backend of his personal website, finishing what he estimated as a 100-hour job in under 10 hours for a few hundred dollars.&lt;/p&gt;
&lt;p&gt;Looking ahead from April 2025, Slatton estimates AI tools currently boost his overall productivity by ~1.1x and expects that to reach 2–3x by late 2026. Frontier models like &lt;code&gt;o3-pro&lt;/code&gt; will initially be expensive, but for engineers earning over $100/hour, an annual AI inference budget of $10,000–$50,000 is easy to justify—and by Jevons paradox, falling per-token prices will only increase total spending. He notes that models still lack the architectural &amp;ldquo;taste&amp;rdquo; of a senior engineer, predicts coding agents will match new CS grads by the end of 2026, and advises junior developers to focus on cultivating senior-level judgment as quickly as possible.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="open-source-is-just-that-understanding-boundaries-in-open-source"&gt;&lt;a href="https://vale.rocks/posts/open-source-entitlement" rel="noopener noreferrer"&gt;Open-Source is Just That: Understanding Boundaries in Open Source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Declan Chidlow speaks out against the growing sense of user entitlement directed at volunteer open-source maintainers. As Chidlow points out, open-source software grants specific rights defined by its license—and merely making source code public does not even make a project open source; it does not automatically mean a project accepts external contributions, offers user support, owes anyone new features, or owes anyone the maintainer&amp;rsquo;s personal time, and users remain bound by the license terms. Having permission to use code under a license does not entitle anyone to demand unpaid labor from its author. He criticizes users who spam issue trackers or aggressively demand support, commenters who defend that behavior, and especially profitable companies that build on open source without giving back instead of funding the maintainers they depend on.&lt;/p&gt;
&lt;p&gt;For projects that do welcome engagement, asking for help respectfully means searching existing issues and documentation first, providing complete reproduction details upfront, staying patient and polite, using official channels, and contributing small fixes or docs improvements where you can—and even when you sponsor or pay a maintainer, &amp;ldquo;money does not replace manners.&amp;rdquo; He encourages the community to respectfully stand up for maintainers, urges maintainers to set firm boundaries, and warns against flooding projects with thoughtless AI-generated issues and pull requests. The bottom line: access to source code is not access to someone else&amp;rsquo;s time and labor.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-insanity-of-being-a-software-engineer"&gt;&lt;a href="https://0x1.pt/2025/04/06/the-insanity-of-being-a-software-engineer/" rel="noopener noreferrer"&gt;The Insanity of Being a Software Engineer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vitor Sousa Pereira takes a satirical look at the ever-expanding mountain of knowledge a single software engineer is expected to master. At first, you just needed a couple of languages and tools, plus your company&amp;rsquo;s web framework of choice—Rails, Django, or Laravel—alongside CSS, which you can study your whole life and still not understand why a layout broke. Then React arrived, companies decided they didn&amp;rsquo;t want to hire separate specialists, and the &amp;ldquo;full-stack developer&amp;rdquo; was born—bringing TypeScript, Redux, webpack/esbuild/rollup configs, Prettier, and ESLint along for the ride. Next, DevOps replaced dedicated sysadmins, so developers had to learn Docker, AWS, and Terraform or Pulumi too. Getting promoted into management means learning an entirely new profession—estimating timelines, delegating, writing specs, running annual performance reviews—and unless the company is growing fast, you still have to do all your old IC work on top of it.&lt;/p&gt;
&lt;p&gt;Pereira mentions a recruiter recently reaching out for a role demanding senior-level expertise across Rails, Hotwire, &lt;em&gt;and&lt;/em&gt; native mobile development simultaneously. While acknowledging that software complexity exists for real reasons, he asks what happened to specialization: when building a house, you hire an architect, a structural engineer, an electrician, a plumber, and dozens of other trades—nobody expects one person to do it all. He closes half-jokingly that maybe a future where we build entire applications with a few AI prompts wouldn&amp;rsquo;t be so bad after all.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-day-i-taught-ai-to-understand-code-like-a-senior-developer"&gt;&lt;a href="https://nmn.gl/blog/ai-understand-senior-developer" rel="noopener noreferrer"&gt;The day I taught AI to understand code like a Senior Developer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Namanyay argues that today&amp;rsquo;s code-generating LLMs don&amp;rsquo;t truly understand a codebase—they act like glorified autocomplete tools that forget where files live, duplicate existing helpers, and ignore established design patterns because they only see a narrow context window. Junior developers focus on the &amp;ldquo;what&amp;rdquo; and &amp;ldquo;how,&amp;rdquo; whereas senior developers focus on the &amp;ldquo;why&amp;rdquo; and &amp;ldquo;what if,&amp;rdquo; holding a mental model of the entire system and anticipating ripple effects; current LLMs behave much more like juniors. His solution is modeling the codebase as a hierarchical knowledge graph using an algorithm he calls Ranked Recursive Summarization (RRS): starting at leaf files, ranking their importance, and recursively summarizing upward into parent directories. Because plain RRS still lost domain-specific nuance, he evolved it into Prismatic RRS (PRRS), which summarizes the codebase through multiple &amp;ldquo;prisms&amp;rdquo; such as architecture, data flow, and security.&lt;/p&gt;
&lt;p&gt;With this multi-perspective context, the AI knows where new files belong, which patterns to follow, and how to extend existing abstractions instead of reinventing them—while also surfacing technical debt, security gaps, and speeding up onboarding for human engineers. He packaged this approach into a product called Giga AI, but also shares how developers can apply the idea manually: write concise summaries for key directories and files, have AI refine them, maintain perspective-specific docs, and feed the relevant summaries into context. His core belief: AI should amplify human creativity rather than replace it.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="why-companies-don"&gt;&lt;a href="https://idiallo.com/blog/companies-dont-fix-bugs" rel="noopener noreferrer"&gt;Why Companies Don&amp;rsquo;t Fix Bugs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ibrahim Diallo opens with the famous GTA Online story: a player named &lt;code&gt;t0st&lt;/code&gt; diagnosed why the game&amp;rsquo;s online mode took 20 minutes to load, fixed it with 13 lines of code that cut load times by 70%, and was awarded $10,000 by Rockstar—after the bug had sat in production for eight years. Rather than blaming &amp;ldquo;lazy developers,&amp;rdquo; Diallo traces the typical lifecycle of a bug inside a large company: in year one, an engineer proposes fixing the slow JSON parser, the product manager asks &amp;ldquo;is it in the spec?&amp;rdquo;, and it gets filed under tech debt; by year three, all engineering capacity is locked into expansion packs and paid cosmetics; by year six, the ticket is auto-archived because the codebase has been rewritten twice; in year eight, a newly hired developer discovers the exact same bug all over again.&lt;/p&gt;
&lt;p&gt;He identifies four structural reasons bugs go unfixed: roadmap-driven development pushes any fix not tied to a feature request to the bottom of the backlog; constant employee turnover erodes institutional knowledge; touching poorly tested, undocumented legacy code carries high career risk for little reward; and quality-of-life improvements don&amp;rsquo;t show up on quarterly revenue charts the way selling virtual Shark Cards does. &lt;code&gt;t0st&lt;/code&gt;&amp;rsquo;s fix was a great PR win, but it didn&amp;rsquo;t change the underlying incentives. The takeaway: don&amp;rsquo;t blame individual engineers when the system itself treats user experience as an afterthought.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="3-buckets-of-work-time"&gt;&lt;a href="https://corymiller.com/3-buckets-of-work-time/" rel="noopener noreferrer"&gt;3 Buckets of Work Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cory Miller, a Chief Evangelist working remotely from Oklahoma with a largely European team, audited his calendar and realized his workweek falls into three buckets. The first is &lt;em&gt;talking&lt;/em&gt;—communication and collaboration across meetings and Slack/Teams—which has been taking a larger share than usual since he recently joined a new team. The second is &lt;em&gt;doing&lt;/em&gt;—execution and shipping—which for him mostly means producing internal and customer-facing videos. The third is &lt;em&gt;thinking about work&lt;/em&gt;—strategy and vision, the &amp;ldquo;daydreaming&amp;rdquo; bucket tied to his Wonder and Invention strengths in the Working Genius model, best done alone in quiet reflection before bringing rough ideas back to teammates for feedback.&lt;/p&gt;
&lt;p&gt;Now in his late 40s, having lived through burnout before and raising two young kids with his wife, Miller has no interest in working 60-hour weeks; he wants to work smarter and healthier. He admits that fear and uncertainty often drive him to overcommit, so he is practicing letting go of what he can&amp;rsquo;t control. Wanting enough structure to feel grounded without feeling boxed in, he is experimenting with waking up at 6 a.m. to handle European overlap and communication early, dedicating Mondays and Wednesdays to collaboration, and reserving Tuesdays and Thursdays for deep work and strategic thinking—leaving himself more quiet space to embrace &amp;ldquo;not knowing yet.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="dangerous-advice-for-software-engineers"&gt;&lt;a href="https://www.seangoedecke.com/dangerous-advice/" rel="noopener noreferrer"&gt;Dangerous Advice for Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke compares certain kinds of career advice to &amp;ldquo;sharp tools&amp;rdquo; like &lt;code&gt;ssh&lt;/code&gt;, &lt;code&gt;kubectl&lt;/code&gt;, or write access to a production database: wielded with skill and judgment, they are indispensable; used carelessly, they cause serious damage. Goedecke admits he frequently writes this kind of &amp;ldquo;dangerous&amp;rdquo; advice: deciding for yourself what to work on, occasionally breaking written company rules on purpose, holding strong opinions before you have all the facts, embracing a bit of organizational cunning, and avoiding work that doesn&amp;rsquo;t directly serve shipping. He worries about readers misapplying it, but argues someone still needs to write it down.&lt;/p&gt;
&lt;p&gt;First, most mainstream career advice is sanitized—written to avoid liability or sound virtuous—while strong engineers crave honest talk about how organizations actually work; realizing that reality doesn&amp;rsquo;t match the employee handbook while nobody admits it out loud is deeply isolating. Second, your own manager can almost never give you this advice directly: if you misjudge a situation and say &amp;ldquo;my manager told me to break the process,&amp;rdquo; the fallout hits them even harder than it hits you, even though many managers quietly wish their reports operated with more pragmatic initiative than their job description states. This advice is high-risk, high-reward—helpful for strong engineers and dangerous for weaker ones—so if any piece of it makes you uncomfortable, don&amp;rsquo;t follow it.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="on-the-biology-of-a-large-language-model"&gt;&lt;a href="https://transformer-circuits.pub/2025/attribution-graphs/biology.html" rel="noopener noreferrer"&gt;On the Biology of a Large Language Model&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This landmark Anthropic paper uses &amp;ldquo;circuit tracing&amp;rdquo; to study the internal mechanisms of Claude 3.5 Haiku, likening the approach to a biologist studying living tissue under a microscope. The researchers train a replacement model built on a cross-layer transcoder architecture containing roughly 30 million interpretable &amp;ldquo;features&amp;rdquo; (replacement neurons that typically correspond to human-understandable concepts), then construct attribution graphs for individual prompts to trace how features activate one another step by step. Because attribution graphs are hypotheses, they validate them with intervention experiments—such as inhibiting specific feature clusters inside the original model and observing how behavior changes across multi-step reasoning, poetry, multilingual understanding, addition, medical diagnosis, hallucinations, refusals, jailbreaks, and chain-of-thought faithfulness.&lt;/p&gt;
&lt;p&gt;Their experiments reveal that the model performs genuine multi-step intermediate reasoning &amp;ldquo;in its head&amp;rdquo;—for example, activating &amp;ldquo;Texas&amp;rdquo; before arriving at &amp;ldquo;Austin&amp;rdquo; when asked for the capital of the state containing Dallas—alongside memorized shortcuts. It shows clear signs of forward planning, choosing a rhyming target word before composing a line of poetry; possesses rudimentary &amp;ldquo;metacognitive&amp;rdquo; circuits that track what it knows versus doesn&amp;rsquo;t know; and operates on shared abstract representations across languages. While the authors acknowledge their current tools yield satisfying explanations for only about a quarter of prompts, the work represents a major step forward for AI interpretability and safety.&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 #23</title><link>https://miti99.com/en/post/2025/05/10/</link><pubDate>Sat, 10 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #23.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="llms-an-operator"&gt;&lt;a href="https://theengineeringmanager.substack.com/p/llms-an-operators-view" rel="noopener noreferrer"&gt;LLMs: An Operator&amp;rsquo;s View&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Stanier looks at LLMs from the perspective of someone running an engineering organization. In his view, the baseline productivity floor for developers is rising: even skeptics acknowledge that tools like Copilot and Cursor speed up prototyping, code completion, and unit test generation. Engineering leaders should therefore proactively budget for paid seats and roll them out deliberately—surveying adoption, identifying internal champions to share workflows, and tracking impact over time. As individual output rises, teams can deliver more with fewer people, so before opening new headcount, leaders should first invest in tooling and training for their existing team, which costs a fraction of hiring another senior engineer.&lt;/p&gt;
&lt;p&gt;The flip side is that faster code generation does not automatically mean higher quality. Stanier recommends tightening code review practices—such as requiring multiple reviewers and running regular security refreshers for the team. Hiring is affected too: candidates using LLMs during remote interviews muddy evaluation signals, so companies need an explicit policy—either embracing AI tools and testing critical thinking, or banning them outright—and must communicate those rules upfront to candidates. The bottom line: adopting LLMs is now table-stakes infrastructure investment, paired with the guardrails needed to protect code quality and hiring standards.&lt;/p&gt;
&lt;h2 id="the-reality-of-tech-interviews-in-2025"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/the-reality-of-tech-interviews" rel="noopener noreferrer"&gt;The Reality of Tech Interviews in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gergely Orosz, joined by Evan King (former Staff Engineer at Meta) and Stefan Mai (former Engineering Manager at Amazon and Meta), paints a picture of a tech hiring market that is simultaneously recovering and much tougher. Open roles at Big Tech are up roughly 40% year over year, and total tech job postings have climbed from their 2023 trough of 163,000 to around 230,000, though still far below the 2020–2022 peak. The recovery is highly uneven: AI infrastructure and ML ops roles command top-tier compensation, while new grads face brutal odds—one candidate applied to 100 companies, landed just 4 interviews, and received zero offers after six months. Mid-level loops have stretched out too, with one candidate going through eleven interview rounds before getting an offer.&lt;/p&gt;
&lt;p&gt;The bar for data structures, algorithms, and system design rounds has also risen noticeably: interviewers now expect complete, working solutions with proper error handling and input validation. Two standout trends are &amp;ldquo;downleveling&amp;rdquo;—where staff-level engineers accept senior roles after prolonged job searches—and &amp;ldquo;team matching&amp;rdquo; turning into an extra filtering stage that can stall offers for months. The authors advise preparing thoroughly for both technical and behavioral rounds at every level, especially for specialized roles, and lining up competing offers so you don&amp;rsquo;t get stuck in team-matching limbo.&lt;/p&gt;
&lt;h2 id="senior-developer-skills-in-the-ai-age-leveraging-experience-for-better-results"&gt;&lt;a href="https://manuel.kiessling.net/2025/03/31/how-seasoned-developers-can-achieve-great-results-with-ai-coding-agents/" rel="noopener noreferrer"&gt;Senior Developer Skills in the AI Age: Leveraging Experience for Better Results&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Manuel Kießling argues that AI coding agents like Cursor do not devalue senior engineering experience—they amplify it. While AI models have broad programming knowledge, they have almost no innate understanding of a project&amp;rsquo;s specific architecture, meaning results depend heavily on how a human guides them. Drawing on his team&amp;rsquo;s experience at Joboo, Kießling outlines three practices. First, well-structured requirements: clearly describing data relationships, system architecture, and task boundaries so the AI doesn&amp;rsquo;t wander off track. Second, tool-based guardrails: linters, static analysis, and automated test suites that provide continuous feedback so the agent can self-correct whenever a check fails. Third, file-based &amp;ldquo;keyframing&amp;rdquo;: creating empty skeleton files with the right namespaces and naming conventions upfront so the AI writes code that fits the existing structure instead of inventing random files.&lt;/p&gt;
&lt;p&gt;Using these techniques, his team shipped an entire contract-management feature spanning multiple applications and repositories in minutes rather than hours. Kießling even had the AI build a Python monitoring tool from scratch in a few hours despite having limited Python experience himself, thanks to thorough requirements docs and automated guardrails. The lesson: upfront planning matters more than ever—AI can execute almost anything, and experienced engineers are there to make sure it builds the right thing.&lt;/p&gt;
&lt;h2 id="jep-483-ahead-of-time-class-loading--linking"&gt;&lt;a href="https://www.morling.dev/blog/jep-483-aot-class-loading-linking/" rel="noopener noreferrer"&gt;JEP 483: Ahead-of-Time Class Loading &amp;amp; Linking&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gunnar Morling puts JEP 483—a Java 24 feature from Project Leyden—to the test, showing how it cuts Java application startup time without requiring any source code changes. The idea is shifting class loading and linking from runtime to build time, building on top of existing Application Class Data Sharing (AppCDS) machinery. Creating the AOT cache takes a two-step training run: first recording loaded classes into a configuration file, then generating the cache image from that configuration, with the classpath kept identical between training and production runs.&lt;/p&gt;
&lt;p&gt;On Apache Kafka 4.0, the resulting AOT cache file weighs around 66 MB and drops startup time from 690 ms to 285 ms—a 59% reduction—with most of the savings coming from skipping class reading and parsing. On Apache Flink, time to first message drops from 1.875 seconds to 0.913 seconds, a 51% improvement. Some limitations remain: custom class loaders are not yet supported, JVM startup flags must be adjusted, and integrating the training run into container image builds can add pipeline complexity. Compared with GraalVM native images—which start in milliseconds and use less memory but require code adjustments and a closed-world assumption—Project Leyden aims for a pragmatic middle ground that is immediately useful for cloud-native Java services.&lt;/p&gt;
&lt;h2 id="specifications-in-jakarta-data"&gt;&lt;a href="https://in.relation.to/2025/03/28/repository-specifications/" rel="noopener noreferrer"&gt;Specifications in Jakarta Data&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gavin King (Hibernate) shows how to implement the &amp;ldquo;specifications&amp;rdquo; pattern—familiar from Spring Data—on top of Jakarta Data. Specifications allow dynamic query filtering via the JPA Criteria API without repetitive boilerplate. While Jakarta Data does not yet include built-in specification support, King demonstrates that all it takes is a shared super-interface &lt;code&gt;JpaRepository&amp;lt;T&amp;gt;&lt;/code&gt; exposing two methods: &lt;code&gt;session()&lt;/code&gt; returning Hibernate&amp;rsquo;s &lt;code&gt;StatelessSession&lt;/code&gt; and &lt;code&gt;entityClass()&lt;/code&gt; returning the entity class. Built on top of those, &lt;code&gt;find()&lt;/code&gt; and &lt;code&gt;count()&lt;/code&gt; accept a specification modeled as a &lt;code&gt;BiFunction&amp;lt;CriteriaBuilder, Root&amp;lt;T&amp;gt;, Predicate&amp;gt;&lt;/code&gt; and construct the corresponding Criteria query.&lt;/p&gt;
&lt;p&gt;Paired with the JPA static metamodel, this approach is fully type-safe, catching misspelled attribute names or type mismatches at compile time. King also includes a &lt;code&gt;compose()&lt;/code&gt; helper for combining multiple specifications and hints that Jakarta Data 1.1 is working on a &amp;ldquo;much more interesting&amp;rdquo; native solution. The two snippets below count books matching a title pattern and find books matching both title and author name:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;library&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;count&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;like&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;title&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;title&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;span class="lnt"&gt;4
&lt;/span&gt;&lt;span class="lnt"&gt;5
&lt;/span&gt;&lt;span class="lnt"&gt;6
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-java" data-lang="java"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="n"&gt;library&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;find&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;and&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;like&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;title&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;title&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s"&gt;&amp;#34;%&amp;#34;&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="n"&gt;builder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;lower&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;book&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;join&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Book_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;authors&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="na"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Author_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;equalTo&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;authorName&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="na"&gt;toLowerCase&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;));&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;h2 id="there-is-no-vibe-engineering"&gt;&lt;a href="https://serce.me/posts/2025-03-31-there-is-no-vibe-engineering" rel="noopener noreferrer"&gt;There is no Vibe Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov (SerCe) contrasts &amp;ldquo;vibe coding&amp;rdquo;—Andrej Karpathy&amp;rsquo;s term for programming primarily via AI prompts rather than working directly with code—with real software engineering. His central thesis builds on the classic definition that &amp;ldquo;software engineering is programming integrated over time&amp;rdquo;: vibe coding solves for a single point in time, whereas production systems must survive real-world traffic, scale with demand, withstand security threats, migrate live user data, and adapt to changing requirements. AI can spin up prototypes remarkably fast, but these long-term concerns are hard to express in a prompt and impossible to verify just by eyeballing the UI. Good engineering practices push failure modes left, where fixing them is cheap; vibe coding pushes them right, where fixing them is expensive.&lt;/p&gt;
&lt;p&gt;Tselovalnikov imagines a future where &amp;ldquo;vibe engineering&amp;rdquo; could exist: systems assembled from strictly encapsulated AI-generated components surrounded by rigorous automated testing, profiling, tracing, canary deployments, and protocol compatibility checks. In that world, the engineer&amp;rsquo;s role blends software architect and platform engineer—writing less application code by hand while spending far more energy on boundaries and verification. Yet that is still traditional software engineering, just operating with new tools. In his view, the true inflection point will only arrive when engineers feel comfortable going on call for a production service written entirely by AI—something very few would dare do today.&lt;/p&gt;
&lt;h2 id="refining-var-handles-in-valhalla"&gt;&lt;a href="https://cr.openjdk.org/~jrose/values/atomic-value-access-api.html" rel="noopener noreferrer"&gt;Refining Var-Handles in Valhalla&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This technical design note by John Rose (OpenJDK) explores how &lt;code&gt;VarHandle&lt;/code&gt;—Java&amp;rsquo;s API for heap variable access supporting &lt;code&gt;getfield&lt;/code&gt;, &lt;code&gt;putfield&lt;/code&gt;, and atomic operations like CAS—needs to evolve to support value types in Project Valhalla. The core challenge is ensuring the interpreter, JIT compiler, and JNI access memory consistently when a variable can be laid out in multiple physical representations on the heap. The &lt;code&gt;LayoutKind&lt;/code&gt; enum defines six representations: &lt;code&gt;REFERENCE&lt;/code&gt; for traditional nullable managed pointers, &lt;code&gt;ATOMIC_FLAT&lt;/code&gt; for values packed into 64 bits, &lt;code&gt;NON_ATOMIC_FLAT&lt;/code&gt; for multi-field values wider than 64 bits, their nullable counterparts &lt;code&gt;NULLABLE_ATOMIC_FLAT&lt;/code&gt; and &lt;code&gt;NULLABLE_NON_ATOMIC_FLAT&lt;/code&gt; (which include a null indicator), and &lt;code&gt;BUFFERED&lt;/code&gt; for read-only heap-buffered copies.&lt;/p&gt;
&lt;p&gt;Rose proposes retiring the current internal &lt;code&gt;getValue&lt;/code&gt; method as insufficient, replacing it with three metadata queries and one new access primitive: &lt;code&gt;isFlat()&lt;/code&gt; to distinguish flattened values from ordinary references, &lt;code&gt;isConsistent()&lt;/code&gt; to indicate whether reads and writes are strictly atomic (non-tearing), &lt;code&gt;isPortableAtomic()&lt;/code&gt; to indicate support for advanced atomic operations like CAS, and &lt;code&gt;copyConsistentValue()&lt;/code&gt; to atomically copy heap words according to the layout&amp;rsquo;s protocol. The key design insight is splitting responsibilities into two layers: a new low-level intrinsic handles atomic memory copying, while existing &lt;code&gt;Unsafe&lt;/code&gt; methods operate on a thread-local buffer (specifically a one-element array) to pack and unpack value fields. This keeps &lt;code&gt;VarHandle&lt;/code&gt; logic clean and decoupled from complex GC and memory-layout details.&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 #22</title><link>https://miti99.com/en/post/2025/05/09/</link><pubDate>Fri, 09 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/09/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #22.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="identity-tokens-best-practices"&gt;&lt;a href="https://www.permit.io/blog/identity-tokens-best-practices" rel="noopener noreferrer"&gt;Identity Tokens Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Gabriel L. Manor (Permit.io) explains that an identity token is a signed package of claims issued by an identity provider to represent a user or service, typically built on OAuth 2.0, OpenID Connect, and the JWT format consisting of a header, a payload containing claims like &lt;code&gt;iss&lt;/code&gt;, &lt;code&gt;exp&lt;/code&gt;, and &lt;code&gt;sub&lt;/code&gt;, and a digital signature. The article distinguishes common token types: JWTs, OpenID Connect ID tokens, opaque tokens (random strings whose underlying data is stored server-side), and API keys for service-to-service communication. The biggest advantage is delegated authentication: applications don&amp;rsquo;t have to handle passwords directly and only need to validate the token (signature, issuer, audience, and expiration), making single sign-on (SSO) and scaling microservices straightforward.&lt;/p&gt;
&lt;p&gt;The most valuable section covers common anti-patterns: treating identity tokens as the source of truth for all authorization decisions, stuffing way too much data (permission lists, URLs, entire user objects) into token claims, setting expiration times too short or too long, and maintaining completely separate authentication flows for human users versus machines. The core recommendation is decoupling authentication (who you are) from authorization (what you are allowed to do right now) so policies can change without reissuing tokens. Beyond that, keep tokens small, stick to open standards, balance token lifetimes, plan for token revocation, always transmit tokens over HTTPS, keep them out of logs and URLs, and always verify JWT signatures. Note that since this is the blog of an authorization vendor, it includes a brief product pitch alongside the technical advice.&lt;/p&gt;
&lt;h2 id="tactical-work-in-the-age-of-layoffs"&gt;&lt;a href="https://www.seangoedecke.com/tactical-work-in-the-age-of-layoffs" rel="noopener noreferrer"&gt;Tactical Work in the Age of Layoffs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke observes that the golden era of 2010s tech—when companies actively protected work-life balance—is over; today&amp;rsquo;s leadership demands faster delivery and higher output against a backdrop of layoff anxiety. The naive response is keeping your existing work habits and simply working longer hours: that works in the short term, but leads to burnout, mistakes, and unsustainability. Instead, Goedecke advises deploying your time more tactically, because companies don&amp;rsquo;t care how many hours you work—they care about the volume of visible output you deliver.&lt;/p&gt;
&lt;p&gt;Specifically, when under pressure, you can scale back work that is genuinely useful for the codebase but goes unrewarded as &amp;ldquo;free labor&amp;rdquo;: writing comprehensive tests, refactoring legacy code, proactively helping other teams unasked, exploring new technologies, or improving internal processes. The litmus test is simple: would you be willing to do that work for free? Goedecke isn&amp;rsquo;t advocating abandoning all craft—he still voluntarily writes a few integration tests for critical flows. His second piece of advice is to go all-in when your project has executive visibility (clues: your manager&amp;rsquo;s manager attends the kickoff, or the project gets mentioned in company-wide all-hands), and then coast to recover during quieter stretches, because nobody can sprint forever without burning out.&lt;/p&gt;
&lt;h2 id="tracing-thoughts-in-language-model"&gt;&lt;a href="https://www.anthropic.com/research/tracing-thoughts-language-model" rel="noopener noreferrer"&gt;Tracing Thoughts in Language Model&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anthropic introduces its latest mechanistic interpretability research, likening the effort to building an &amp;ldquo;AI microscope&amp;rdquo; to peer inside a language model&amp;rsquo;s internals. Because language models are not programmed directly by humans—instead learning problem-solving strategies during training—even their creators don&amp;rsquo;t fully understand how they arrive at answers. Two companion papers extend Anthropic&amp;rsquo;s earlier work from identifying individual internal concepts (&amp;ldquo;features&amp;rdquo;) to linking them together into computational &amp;ldquo;circuits,&amp;rdquo; applying the method to study Claude 3.5 Haiku across ten representative behaviors.&lt;/p&gt;
&lt;p&gt;The findings are full of surprises. Claude appears to think in a shared conceptual space across languages, and this language-agnostic representation grows larger with model scale. When writing rhyming poetry, the model selects the rhyming word at the end of a line in advance and then composes the line to land on it, even though it was trained purely to predict one token at a time. When doing mental arithmetic like 36+59, it runs two parallel pathways—one computing a rough magnitude estimate and another computing the exact ones digit—yet when asked to explain how it got the answer, it recites the standard textbook carrying algorithm instead. Researchers also caught the model fabricating plausible-sounding post-hoc reasoning to agree with a user&amp;rsquo;s incorrect hint, and found that by default Claude is wired to abstain from guessing unless a specific circuit suppresses that reluctance when it recognizes a known entity. The team notes that their current method still captures only a small fraction of the model&amp;rsquo;s total computation.&lt;/p&gt;
&lt;h2 id="why-duplicating-environments-for-microservices-backfires"&gt;&lt;a href="https://www.signadot.com/blog/why-duplicating-environments-for-microservices-backfires" rel="noopener noreferrer"&gt;Why Duplicating Environments for Microservices Backfires&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Arjun Iyer (Signadot) argues that in microservices development, the time it takes to test a code change in a production-like environment determines engineering velocity—and the common approach of spinning up full duplicate environments on demand for each developer or team (via VMs, Kubernetes namespaces, or dedicated clusters) breaks down as systems grow. Every environment requires the full set of services, load balancers, API gateways, databases, and message queues, making it painful to manage; teams resort to mocks that drift from reality, test data falls out of sync, environments quickly lag behind &lt;code&gt;main&lt;/code&gt;, and provisioning gets slower and slower. The cloud bill is steep too: running a 50-microservice environment on an EC2 &lt;code&gt;m6a.8xlarge&lt;/code&gt; instance costs roughly $11,232 per year, which multiplied across 50 copies exceeds $560,000 in compute alone.&lt;/p&gt;
&lt;p&gt;The alternative Iyer proposes is sharing a single baseline environment with request-level isolation via lightweight &amp;ldquo;sandboxes,&amp;rdquo; similar to Uber&amp;rsquo;s end-to-end testing architecture: only the modified services are deployed into a sandbox, while requests are dynamically routed based on headers. This saves compute, produces consistent results, simplifies maintenance, spins up sandboxes nearly instantly, and stays much closer to production. Implementing it requires three pieces: context propagation across service boundaries (using OpenTelemetry &lt;code&gt;baggage&lt;/code&gt; and &lt;code&gt;tracecontext&lt;/code&gt; standards), data isolation so tests cannot mutate shared baseline records they didn&amp;rsquo;t create, and message-queue routing so sandboxes don&amp;rsquo;t compete for the same events.&lt;/p&gt;
&lt;h2 id="logging-practices-i-follow"&gt;&lt;del&gt;&lt;a href="https://www.16elt.com/2023/01/06/logging-practices-I-follow" rel="noopener noreferrer"&gt;Logging Practices I Follow&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Eliran Turgeman shares the logging principles he follows, starting from the observation that logs are the most fundamental observability tool and that their primary audience is developers themselves. Before adding a log statement, ask yourself: is this log truly necessary, or does it duplicate information already logged elsewhere in the same flow; could the logged object blow up in size in production—and if so, can you log just a count or a few key fields instead; and does this message actually help someone debug or understand the execution path? Next, keep log formatting consistent across the entire system—for example, always prefixing messages with &lt;code&gt;[serviceName](functionName)&lt;/code&gt; so engineers can locate the exact call site without even opening the codebase.&lt;/p&gt;
&lt;p&gt;For log levels, Turgeman sticks mainly to four: &lt;code&gt;ERROR&lt;/code&gt; when part of a flow fails and needs to page someone on call, &lt;code&gt;WARNING&lt;/code&gt; for abnormal behavior worth investigating, &lt;code&gt;INFO&lt;/code&gt; for major milestones in a request flow, and &lt;code&gt;DEBUG&lt;/code&gt; for fine-grained inspection of objects and data structures; the most common mistakes are logging way too much detail at &lt;code&gt;INFO&lt;/code&gt; or never using &lt;code&gt;DEBUG&lt;/code&gt; at all. Finally, be mindful of cost: dumping a massive JSON payload into logs is both unreadable and expensive—at roughly $0.50 per GB in AWS CloudWatch, a single noisy log line can easily cost thousands of dollars a month. Making every log message unique across the codebase, aided by the service and function prefix, makes troubleshooting much faster.&lt;/p&gt;
&lt;h2 id="sync-and-async"&gt;&lt;a href="https://blogs.newardassociates.com/blog/2025/sync-and-async.html" rel="noopener noreferrer"&gt;Sync and Async&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ted Neward argues that the &amp;ldquo;work from home (WFH) versus return to office (RTO)&amp;rdquo; debate focuses on the wrong question: the real issue isn&amp;rsquo;t &lt;em&gt;where&lt;/em&gt; work happens, but &lt;em&gt;how&lt;/em&gt; work happens—specifically, synchronous versus asynchronous work. After recapping the pandemic shift to remote work and the subsequent wave of hybrid policies and RTO mandates, Neward lays out his premises: we still have no objective metric for developer &amp;ldquo;productivity,&amp;rdquo; remote teams can be led effectively by skilled managers, talent is distributed everywhere, yet human relationships deepen faster face-to-face—and commuting into an office just to sit on Zoom calls with headphones on makes no sense.&lt;/p&gt;
&lt;p&gt;He defines &amp;ldquo;synchronous&amp;rdquo; work as tasks that require back-and-forth interaction with others to make progress, and &amp;ldquo;asynchronous&amp;rdquo; work as tasks where you can move forward independently without waiting on new input. Writing code and debugging are largely asynchronous (even if rubber-ducking a bug with a colleague helps); pair programming and requirements gathering with stakeholders are synchronous; code reviews and architecture brainstorming alternate between both. Rather than a binary, sync and async form a spectrum, which Neward maps across two axes: degree of synchronicity and communication fidelity (bandwidth). Activities high on both axes—like pair programming or design brainstorming—benefit most from being in the same room, while activities low on both—like heads-down coding—can be done from anywhere.&lt;/p&gt;
&lt;h2 id="making-uber"&gt;&lt;a href="https://www.uber.com/en-IN/blog/making-ubers-experiment-evaluation-engine-100x-faster/" rel="noopener noreferrer"&gt;Making Uber&amp;rsquo;s Experiment Evaluation Engine 100x Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber&amp;rsquo;s engineering team recounts how they cut A/B experiment evaluation latency for Go backend microservices by 100x, dropping p99 latency from roughly 10 ms to 100 µs. Previously, every active experiment was evaluated via remote RPC calls to a centralized Parameter Service. That approach was too slow for Uber&amp;rsquo;s real-time paths, turned the central service into a single point of failure, and forced developers to rely on batch prefetching—requiring them to know upfront which parameters a request would need, with any omission causing bugs. Their solution was moving to local evaluation: distributing experiment metadata to every host over Uber&amp;rsquo;s existing Flipr configuration distribution channel and running the evaluation logic inside an in-process &lt;code&gt;ExperimentPlugin&lt;/code&gt; within the client library.&lt;/p&gt;
&lt;p&gt;To guarantee correctness during the migration, the team ran shadow testing across a sample of roughly 20 million evaluations per second, comparing legacy and local results, fixing 13 edge-case bugs, and achieving over 99.999% parity. Because faster evaluations also meant impression logs were pushed to Kafka at a much higher rate, they added monitoring, alerting, and an in-memory LRU cache that deduplicated roughly 80% of redundant exposure logs, along with internal kill-switch parameters to disable features instantly without redeployment. Today, more than 100 services representing nearly 70% of experiment traffic have migrated, cutting UberEats search autocomplete indexing latency by 20%. Their takeaway: start with a simple centralized architecture, and only decentralize once your platform is mature enough to handle it.&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>