<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Developer Experience on miti99</title><link>https://miti99.com/en/tags/developer-experience/</link><description>Recent content in Developer Experience 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/developer-experience/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #132</title><link>https://miti99.com/en/post/2026/09/10/</link><pubDate>Thu, 10 Sep 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/09/10/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #132.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="perfection-is-not-over-engineering"&gt;&lt;a href="https://var0.xyz/posts/perfection-is-not-over-engineering.html" rel="noopener noreferrer"&gt;Perfection is not over-engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The phrase &amp;ldquo;we don&amp;rsquo;t want to aim for perfection&amp;rdquo; comes up in engineering meetings more times than the author can count. He understands the caution—over-engineering has burned out plenty of teams—but argues the industry is conflating two completely different things. Over-engineering is simply &lt;em&gt;solving the wrong problem&lt;/em&gt;, usually with good intentions and a pile of accidental complexity attached. A &amp;ldquo;perfect&amp;rdquo; solution, by contrast, is very real once requirements are clear and all constraints are on the table: tighten the constraints enough and only one design fits, making it perfect precisely because nothing else satisfies the actual problem. Picking Python on serverless to skip a build step might be ideal for one team and completely wrong for a team that doesn&amp;rsquo;t know Python or needs predictable low latency.&lt;/p&gt;
&lt;p&gt;In the author&amp;rsquo;s view, every system is a product: internal libraries, APIs, and CLI tools all have real users with real needs. The clearest tell of over-engineering is asking &amp;ldquo;why did we build it this way?&amp;rdquo; and getting an answer that falls apart under scrutiny. A classic example is a three-person team maintaining five microservices that share the same underlying data: foreign keys once enforced by the database turn into loosely coupled string IDs, and one service deletes records without the others knowing—all to buy &amp;ldquo;independent deployability,&amp;rdquo; a problem the three-person team never actually had. The takeaway: that isn&amp;rsquo;t an excess of perfection, it&amp;rsquo;s a failure of requirements gathering. The enemy was never perfection; it was vague requirements.&lt;/p&gt;
&lt;h2 id="claude-is-not-a-compiler"&gt;&lt;a href="https://blog.exe.dev/claude-is-not-a-compiler" rel="noopener noreferrer"&gt;Claude Is Not a Compiler&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Josh Bleecher Snyder argues that Claude is not a compiler—because it is &lt;em&gt;better&lt;/em&gt; than one. In the idealized textbook view, software is built in neat horizontal layers: vision becomes strategy, product specs become engineering plans, source code becomes binaries, with each layer owned by a different role making thousands of micro-decisions. In reality, layers constantly leak and rub against one another, and working &lt;em&gt;across&lt;/em&gt; layers is where the biggest wins happen—just as the Empire State Building was designed and erected in under a year because the owners, architects, structural engineers, and contractors sat in the same room making cross-cutting trade-offs together. Claude can work vertically across all those layers at once—discussing strategy, architecture, source code, and assembly without needing to schedule a meeting.&lt;/p&gt;
&lt;p&gt;Snyder illustrates this with &lt;code&gt;exe.dev&lt;/code&gt;&amp;rsquo;s distributed DNS server. High-level strategic and architectural decisions were settled human-to-human; for the rest, he spun up multiple parallel agent loops to build full implementations with tests, then had another agent compare the resulting designs. What shocked him was how many consequential design decisions the agents quietly made on their own without asking—and how differently each agent resolved them, such as how to handle a database state rollback. Repeating this multi-agent exploration three times let him distill a concise design document that guided the final agent across every critical decision point. A week later, having barely read the raw code himself, he could answer every question from his teammates, and a month into production the DNS server had zero incidents. He calls this &amp;ldquo;vibe-engineering&amp;rdquo;—and predicts that soon we&amp;rsquo;ll just call it software engineering.&lt;/p&gt;
&lt;h2 id="in-defense-of-not-understanding-your-codebase"&gt;&lt;a href="https://www.seangoedecke.com/in-defense-of-not-understanding-your-codebase/" rel="noopener noreferrer"&gt;In defense of not understanding your codebase&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;How thoroughly must an engineer understand their codebase? Sean Goedecke argues the answer depends entirely on the environment. Developers working on small, self-contained codebases like Redis will insist you must understand every line; engineers working on massive systems like Google or GitHub know that is literally impossible. Because the first group dominates online discourse, Goedecke steps up to defend the second: in a sufficiently large system, having only a &lt;em&gt;partial&lt;/em&gt; understanding isn&amp;rsquo;t a moral failing—it is the best anyone can ever achieve. At scale, everyone operates with an incomplete, slightly wrong mental model, so effective engineers must get comfortable making educated guesses.&lt;/p&gt;
&lt;p&gt;He pushes back against Peter Naur&amp;rsquo;s famous essay &lt;em&gt;&amp;ldquo;Programming as Theory Building.&amp;rdquo;&lt;/em&gt; While agreeing that a programmer&amp;rsquo;s most valuable asset is the mental &amp;ldquo;theory&amp;rdquo; of how the program works, Goedecke rejects Naur&amp;rsquo;s conclusion that once the original team leaves, a codebase is dead and ought to be rewritten from scratch. First, large legacy systems encode thousands of hard-won edge cases that a greenfield rewrite won&amp;rsquo;t rediscover until production breaks, and successful rewrites almost always happen incrementally by carving up the existing system. Second, &amp;ldquo;abandoned&amp;rdquo; codebases are successfully revived in industry all the time: you start by tracing one end-to-end flow and expand your mental map from there. Finally, preserving a pristine mental theory is just one business value among many, routinely traded off whenever teams collaborate or patch urgent security vulnerabilities. Being a professional engineer means aligning with your company&amp;rsquo;s trade-offs—even when that means working effectively in code you don&amp;rsquo;t fully understand.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-the-network"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-01-Beyond-Happy-Path-Engineering-the-Network/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: the Network&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This opening installment of Gabor Koos&amp;rsquo;s &lt;em&gt;&amp;ldquo;Beyond Happy Path Engineering&amp;rdquo;&lt;/em&gt; series examines the assumptions that local development environments indulge but production mercilessly punishes, starting with the network. A network call looks like a simple function call, but it crosses a boundary into a system you do not control. Using checkout payment authorization as a running example, Koos notes that &amp;ldquo;clean&amp;rdquo; failures like a refused connection are easy to handle compared to a timeout &lt;em&gt;after&lt;/em&gt; the request was sent: the operation may have succeeded, failed, or still be sitting in a queue. The foundational rule of distributed systems is that &lt;em&gt;not receiving a response does not mean the operation didn&amp;rsquo;t happen&lt;/em&gt;. Latency is also a failure mode in disguise: a slow downstream service ties up threads and connection pools, averages hide catastrophic tail latency, and slowness cascades into full outages faster than hard errors.&lt;/p&gt;
&lt;p&gt;Koos outlines the essential defenses: treat timeouts as explicit design decisions derived from per-request latency budgets; retry only when safe, backing mutations with idempotency keys passed on every attempt alongside exponential backoff and jitter to prevent thundering herds; and propagate deadlines and cancellation contexts downstream so abandoned work stops immediately. Circuit breakers and load shedding protect overloaded services, while graceful degradation separates critical path steps (like taking payment) from deferrable side effects (like sending confirmation emails) using explicit order states like &lt;code&gt;&amp;quot;pending&amp;quot;&lt;/code&gt;. GitHub&amp;rsquo;s October 2018 outage—where a network partition lasting under a minute caused over 24 hours of degraded service—vividly illustrates the cost of happy-path network assumptions.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-time"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-07-19-Beyond-Happy-Path-Engineering-Time/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Time&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part two of the series turns to time—seemingly the simplest dependency of all: grab the current timestamp, compare two values, and make a decision. The running example is a checkout flow that holds inventory for fifteen minutes using &lt;code&gt;if now() &amp;gt; reservation.expiresAt&lt;/code&gt;. If the cleanup worker&amp;rsquo;s clock drifts two minutes ahead of the checkout server&amp;rsquo;s clock, items get released back to inventory while the customer is mid-payment. Wall clocks can jump forward or backward mid-execution via NTP adjustments, turning elapsed durations negative, and timestamps across different machines cannot reliably establish event ordering. Worst of all, time bugs fail silently: services stay up, dashboards stay green, and the system quietly makes wrong business decisions.&lt;/p&gt;
&lt;p&gt;The core lesson is that &amp;ldquo;time&amp;rdquo; actually answers four distinct questions: &lt;em&gt;wall-clock time&lt;/em&gt; records when an event happened in the real world, &lt;em&gt;monotonic time&lt;/em&gt; measures elapsed durations and timeouts on a single machine, &lt;em&gt;logical time&lt;/em&gt; (versions or sequence numbers) orders competing updates, and &lt;em&gt;business time&lt;/em&gt; governs billing periods, cutoff windows, and user time zones. Expiration should be modeled as an explicit &lt;em&gt;state transition&lt;/em&gt; rather than a passive timestamp comparison: use timestamps only to find candidate rows, then execute a conditional write that transitions the row to &lt;code&gt;expired&lt;/code&gt; only if its status is still &lt;code&gt;reserved&lt;/code&gt;, making late or duplicate cleanup runs harmless. When local clocks aren&amp;rsquo;t enough to arbitrate, reconcile against the authoritative external source, such as the payment provider. Cloudflare&amp;rsquo;s New Year&amp;rsquo;s 2017 leap-second DNS outage—when subtracting two &lt;code&gt;time.Now()&lt;/code&gt; readings yielded a negative number and triggered a panic—serves as a classic cautionary tale.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-databases"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-01-Beyond-Happy-Path-Engineering-Databases/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Databases&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part three tackles databases, the layer developers most often treat as an infallible black box. Using an e-commerce checkout flow that works flawlessly on a developer&amp;rsquo;s laptop because there is zero concurrent traffic, Koos shows how production changes everything: checkouts, admin dashboards, background jobs, analytics queries, and schema migrations all compete for the same connections and locks. A single slow query can exhaust the connection pool, causing incoming requests to queue up, users to hit refresh, and &amp;ldquo;checkout to go down&amp;rdquo; even though the database hasn&amp;rsquo;t crashed. Two concurrent requests can both read &lt;code&gt;stock = 1&lt;/code&gt; and both sell the last item; wrapping code in a transaction doesn&amp;rsquo;t magically prevent race conditions unless business invariants are enforced explicitly. On top of that come lagging read replicas, commit timeouts that leave the caller unsure whether the write succeeded, deadlocks, and schema migrations running alongside multiple live application versions.&lt;/p&gt;
&lt;p&gt;Koos recommends starting from the invariant that must never be violated—such as &amp;ldquo;never sell more than available inventory&amp;rdquo;—and enforcing it directly in the atomic write statement (&lt;code&gt;UPDATE ... WHERE stock &amp;gt;= quantity&lt;/code&gt;) backed by database constraints rather than application-level checks alone. Keep transactions short, never make network calls inside a transaction, and retry only transient errors. Make writes idempotent, define explicit data-freshness requirements per endpoint before routing reads to replicas, run schema migrations in backward-compatible expand-and-contract phases, and rehearse backup restores regularly. Atlassian&amp;rsquo;s 2022 outage and GitHub&amp;rsquo;s 2018 incident both prove that recovery speed matters just as much as data durability.&lt;/p&gt;
&lt;h2 id="beyond-happy-path-engineering-storage"&gt;&lt;a href="https://blog.gaborkoos.com/posts/2026-08-11-Beyond-Happy-Path-Engineering-Storage/" rel="noopener noreferrer"&gt;Beyond Happy Path Engineering: Storage&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part four examines object storage, which looks simpler than a relational database but hides a fundamental trap: your database and your object store are two separate systems with no shared transaction coordinator. Consider a document upload flow: write the file to S3, insert a metadata row in the database, and return the URL. If the blob upload succeeds but the database insert fails, you get an invisible orphaned object; flip the order and a failed upload leaves a database row pointing to a missing blob that serves &lt;code&gt;404&lt;/code&gt;s. Abandoned multipart uploads quietly rack up storage bills, presigned URLs remain valid even after the database record is deleted, concurrent uploads to the same key silently overwrite each other, and CDNs keep serving stale cached files. High durability also doesn&amp;rsquo;t equal recoverability, because an accidental &lt;code&gt;DELETE&lt;/code&gt; is replicated just as durably as a valid write.&lt;/p&gt;
&lt;p&gt;Koos advises ordering upload steps so failures fail safe, tracking lifecycle state explicitly in the database (&lt;code&gt;pending&lt;/code&gt;, &lt;code&gt;confirmed&lt;/code&gt;, &lt;code&gt;failed&lt;/code&gt;), and serving only &lt;code&gt;confirmed&lt;/code&gt; records. Object keys should use immutable UUIDs or content hashes rather than user-supplied filenames; large files should upload directly from the client via short-lived presigned URLs; and deletions should soft-delete the database row first before a background job purges the blob, backed by a periodic reconciliation sweeper. The 2014 demise of Code Spaces—which shut down permanently after an attacker gained access to their AWS control panel and wiped both production storage and backups—underscores why backups must live outside the blast radius of production credentials.&lt;/p&gt;
&lt;h2 id="everyone-should-know-simd"&gt;&lt;a href="https://mitchellh.com/writing/everyone-should-know-simd" rel="noopener noreferrer"&gt;Everyone Should Know SIMD&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SIMD has a reputation for being arcane, and Mitchell Hashimoto regularly meets strong engineers who write it off as too hard to learn or useful only in niche high-performance computing. He argues that reputation is undeserved: the vast majority of practical &amp;ldquo;process N items at a time&amp;rdquo; SIMD code follows a single five-step template, and once you internalize that template, writing SIMD is almost as straightforward as writing a standard &lt;code&gt;for&lt;/code&gt; loop. Because SIMD lets the CPU process multiple data elements in a single instruction, any loop scanning bytes, characters, or array elements is a candidate once inputs reach thousands or millions of bytes.&lt;/p&gt;
&lt;p&gt;The five-step template is: broadcast constants into vectors and initialize accumulators if needed; loop over the input in chunks equal to the vector width; perform parallel comparisons or arithmetic across all lanes; reduce or store the vector result; and handle the trailing remainder elements using your original scalar loop. Hashimoto walks through a real example from the Ghostty terminal emulator written in Zig: finding the end of a run of printable ASCII characters by scanning until a byte is &lt;code&gt;&amp;lt;= 0xF&lt;/code&gt;. The scalar loop is a one-liner; the SIMD version adds about 12 lines of code and delivers a theoretical 4x speedup on ARM NEON, 8x on AVX2, and 16x on AVX-512, measuring roughly 5x faster in real benchmarks on an Intel AVX2 machine. While compilers can sometimes auto-vectorize simple loops, whenever a hot path cares about a 5x speedup, Hashimoto prefers explicit, portable SIMD that won&amp;rsquo;t silently regress after a compiler upgrade or minor code tweak.&lt;/p&gt;
&lt;h2 id="htop-explained"&gt;&lt;a href="https://peteris.rocks/blog/htop/" rel="noopener noreferrer"&gt;htop explained&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pēteris Ņikiforovs admits that for years he used &lt;code&gt;htop&lt;/code&gt; without truly understanding half the numbers on screen—for instance, assuming a load average of &lt;code&gt;1.0&lt;/code&gt; on a dual-core machine meant the CPUs were 50% busy. So he dug into the Linux kernel sources and wrote a comprehensive visual guide breaking down every single bar and column in &lt;code&gt;htop&lt;/code&gt;. What makes the guide stand out is that he traces every metric back to its exact kernel source: uptime comes from &lt;code&gt;/proc/uptime&lt;/code&gt;, load average comes from &lt;code&gt;/proc/loadavg&lt;/code&gt;, and you can verify how &lt;code&gt;htop&lt;/code&gt; gathers them yourself by running it under &lt;code&gt;strace&lt;/code&gt; to see which files it opens.&lt;/p&gt;
&lt;p&gt;Load average isn&amp;rsquo;t CPU percentage at all—it is the exponentially damped moving average of runnable threads plus threads stuck in uninterruptible sleep waiting on disk or network I/O; the 1-minute figure reflects roughly 63% of the past minute&amp;rsquo;s load and 37% of the prior average. The guide then demystifies process states (&lt;code&gt;R&lt;/code&gt; running/runnable, &lt;code&gt;S&lt;/code&gt; interruptible sleep, &lt;code&gt;D&lt;/code&gt; uninterruptible sleep, &lt;code&gt;Z&lt;/code&gt; zombie terminated but not yet reaped by its parent), &lt;code&gt;NI&lt;/code&gt; nice values from &lt;code&gt;-20&lt;/code&gt; to &lt;code&gt;19&lt;/code&gt; and their relation to kernel priority (&lt;code&gt;PR = 20 + NI&lt;/code&gt;), and the memory columns: &lt;code&gt;VIRT&lt;/code&gt; includes unbacked virtual reservations and memory-mapped files so it&amp;rsquo;s rarely actionable, &lt;code&gt;RES&lt;/code&gt; is actual resident RAM (though shared libraries and copy-on-write pages get double-counted across processes), and &lt;code&gt;MEM%&lt;/code&gt; is simply &lt;code&gt;RES&lt;/code&gt; divided by total RAM. He wraps up by auditing every default background process on a fresh Ubuntu Server install to see which ones can be safely stripped out.&lt;/p&gt;
&lt;h2 id="the-productivity-experience-paradox"&gt;&lt;a href="https://annievella.com/posts/the-productivity-experience-paradox/" rel="noopener noreferrer"&gt;The Productivity-Experience Paradox&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In the second article from her master&amp;rsquo;s research on how AI coding tools affect software engineers, Annie Vella shares findings from a longitudinal study tracking the exact same cohort of engineers across two waves six months apart (October 2024 to April 2025). On the productivity front, the news is consistently positive: 84% of respondents reported that AI helped them get more done in both waves. Yet developer experience—measured across the DevEx framework dimensions of feedback loops, cognitive load, and flow state—moved in the opposite direction: the share of engineers reporting a net-negative experience nearly doubled from 14% to 27%, and not a single engineer who fell into the negative group in Wave 1 recovered to an all-positive experience by Wave 2.&lt;/p&gt;
&lt;p&gt;The central finding is that productivity and developer experience—long assumed to rise and fall together—are decoupling: tracking the same individuals over time, experience degraded while output held steady, with a near-zero correlation ($r = 0.02$) between changes in flow state and changes in perceived productivity. That decoupling is dangerous because the business case for investing in DevEx has historically been &amp;ldquo;happy developers are productive developers&amp;rdquo;; when output stays high, rising cognitive strain stays invisible until it turns into burnout. Flow suffered the sharpest drop (negative reports rose from 7% to 20%) even as feedback loops sped up, and Vella suspects the two are linked: every fast AI response triggers a micro-context switch from creator to reviewer. Borrowing the term &amp;ldquo;junk flow&amp;rdquo; to describe a slot-machine-like loop of rapid prompting that mimics flow without deep satisfaction, she concludes that while AI boosts extrinsic output, it risks eroding the intrinsic craft and joy of software engineering.&lt;/p&gt;
&lt;h2 id="prefactoring-clear-the-way-for-your-new-feature"&gt;&lt;a href="https://testing.googleblog.com/2026/07/prefactoring-clear-way-for-your-new.html" rel="noopener noreferrer"&gt;Prefactoring: Clear the Way for Your New Feature&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short post from Google&amp;rsquo;s &lt;em&gt;&amp;ldquo;Tech on the Toilet&amp;rdquo;&lt;/em&gt; series opens with Kent Beck&amp;rsquo;s famous advice: &lt;em&gt;&amp;ldquo;First make the change easy (warning: this may be hard), then make the easy change.&amp;rdquo;&lt;/em&gt; When you try to bolt a new feature directly onto code that wasn&amp;rsquo;t structured to accommodate it, things get messy fast: tweaking one file forces changes in three others, and soon you&amp;rsquo;re knee-deep in unrelated modules. &lt;em&gt;Prefactoring&lt;/em&gt;—short for preparatory refactoring—is the discipline of restructuring existing code to fit the upcoming requirement &lt;em&gt;before&lt;/em&gt; writing the new feature, rather than promising yourself you&amp;rsquo;ll clean it up afterward.&lt;/p&gt;
&lt;p&gt;The payoffs are immediate: the new feature slots in naturally, code reviews go much faster because structural refactoring and behavioral changes live in separate commits, fewer bugs slip in because cleanup is isolated from new logic, and rollbacks are safer because each change is small and self-contained. In the post&amp;rsquo;s example, the first CL simply extracts a &lt;code&gt;get_display_name(user)&lt;/code&gt; helper to deduplicate name-formatting logic across the profile page and email templates; the second CL adds middle-name support with a one-line edit inside that helper. Even if you only spot the right abstraction mid-implementation, you can still split the cleanup into a preparatory CL—or spin off reviewer-suggested cleanups in parallel while your main CL is under review. Not every cleanup belongs up front, though: if a refactoring doesn&amp;rsquo;t directly unblock your feature, save it for later, or fold it in if it&amp;rsquo;s truly trivial.&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 #109</title><link>https://miti99.com/en/post/2026/06/06/</link><pubDate>Sat, 06 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/06/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #109.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-history-of-ides-at-google"&gt;&lt;a href="https://laurent.le-brun.eu/blog/a-history-of-ides-at-google" rel="noopener noreferrer"&gt;A History of IDEs at Google&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurent Le Brun, who spent 12 years working on developer tooling at Google, recounts the journey from a fragmented ecosystem of editors to a single IDE used by nearly the entire company. Back in 2011, when someone asked whether Google should standardize on one IDE, the near-unanimous answer was &amp;ldquo;no&amp;rdquo; — Jeff Dean argued that forcing a whole team onto a single editor was a recipe for misery. The price of that freedom was that every useful integration — Bazel, code search, formatters — had to be rebuilt for every editor. Around 2013, Cider launched as a web-based editor initially meant for quick doc edits, but thanks to a backend capable of indexing Google&amp;rsquo;s massive monorepo, it gradually won over Go and then Java developers.&lt;/p&gt;
&lt;p&gt;In 2020, the team decided to replace Cider&amp;rsquo;s custom frontend with the VS Code core while keeping Google&amp;rsquo;s proprietary backend; Cider V opened to 5,000 engineers in 2021 and accounted for roughly 80% of main-repo development by 2023. Once most engineers shared a single platform, teams had strong incentives to build internal extensions — roughly 100 within two years — and AI features like code completion and automated review-comment resolution could be rolled out company-wide far faster. The takeaway: standardizing tooling creates massive leverage, even if the up-front investment is high and not every company can pull it off.&lt;/p&gt;
&lt;h2 id="finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks"&gt;&lt;a href="https://medium.com/pinterest-engineering/finding-zombies-in-our-systems-a-real-world-story-of-cpu-bottlenecks-ea4722e552eb" rel="noopener noreferrer"&gt;Finding zombies in our systems: A real-world story of CPU bottlenecks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In early 2025, Pinterest&amp;rsquo;s Ray ML training jobs kept crashing due to flaky network connections, and it took the Kubernetes platform team over three months to track down the culprit. The first clue was that the EC2 ENA network driver reset itself whenever its transmit queue stalled for more than 5 seconds, a classic symptom of CPU starvation; weirdly, the resets only happened in a single availability zone even though cluster configs looked identical, and rebooting nodes only bought about a week of relief. On 96-vCPU GPU instances, aggregate &lt;code&gt;perf&lt;/code&gt; profiles looked completely normal; only per-core, per-second &lt;code&gt;mpstat&lt;/code&gt; monitoring revealed a single CPU core pinned at 100% system time for several seconds right when each reset occurred. The team set up automated 2-minute &lt;code&gt;perf record&lt;/code&gt; captures and used Netflix&amp;rsquo;s Flamescope to scrub to the exact second of the spike.&lt;/p&gt;
&lt;p&gt;The culprit: right before every reset, &lt;code&gt;kubelet&lt;/code&gt; spiked to ~6.5% total CPU (normally under 1%), spending nearly all of that time inside the kernel&amp;rsquo;s &lt;code&gt;mem_cgroup_nr_lru_pages&lt;/code&gt; function. The kernel was tracking nearly 70,000 memory cgroups even though only 240 were actually active — &amp;ldquo;zombie memcgs&amp;rdquo; — and walking that list pinned a single core long enough to starve the network driver thread sharing it. The root cause traced back to the AWS Deep Learning AMI (Ubuntu 20.04) base image, which shipped with the Amazon ECS agent enabled by default; unable to join an ECS cluster, the agent crashed in a tight loop, leaking a zombie cgroup on every restart. The fix was simple: disable the ECS agent systemd unit and reboot the fleet. As for why the &amp;ldquo;healthy&amp;rdquo; availability zone never broke? Another bug there prevented the ECS agent from ever starting in the first place.&lt;/p&gt;
&lt;h2 id="programming-still-sucks"&gt;&lt;a href="https://www.stvn.sh/writing/programming-still-sucks-fqffhyp" rel="noopener noreferrer"&gt;Programming Still Sucks.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Steven Langbroek wrote this essay to answer the familiar question &amp;ldquo;Will AI take programmers&amp;rsquo; jobs?&amp;rdquo;, and his answer is no: the real culprit is greed, merely dressed up in a new coat called &amp;ldquo;automation.&amp;rdquo; Starting from a casual question at a birthday party, he paints software engineering as a burning ship: no map, no crew, sails mounted backward, useless navigation instruments, and a predecessor who abandoned ship after leaving behind half-baked &amp;ldquo;initiatives.&amp;rdquo; Layoffs, he argues, are signed off by people who know the consequences full well but bow to spreadsheets and quarterly targets, telling themselves they&amp;rsquo;ll &amp;ldquo;fix it later&amp;rdquo; — a &amp;ldquo;later&amp;rdquo; that never comes.&lt;/p&gt;
&lt;p&gt;The sharpest pain point is what happens to junior developers. A junior&amp;rsquo;s value isn&amp;rsquo;t the code they write today, but the fact that one day they become the senior who understands every dark corner of the system; eliminate apprenticeships to optimize short-term output, and a few years later there is nobody left to take the helm. The emotional heart of the piece is Sara, an older infrastructure specialist who inherited her knowledge from Ben and keeps the company alive via a mysterious cron job nobody else understands. When Sara retires, the company will desperately need a replacement after having dismantled the very pipeline that could have trained one. The disaster, Langbroek concludes, isn&amp;rsquo;t technological — it&amp;rsquo;s organizations actively sabotaging themselves.&lt;/p&gt;
&lt;h2 id="how-container-filesystem-works-building-a-docker-like-container-from-scratch"&gt;&lt;a href="https://labs.iximiuz.com/tutorials/container-filesystem-from-scratch" rel="noopener noreferrer"&gt;How Container Filesystem Works: Building a Docker-like Container From Scratch&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ivan Velichko&amp;rsquo;s tutorial on iximiuz Labs builds a container by hand using nothing but standard Linux tools like &lt;code&gt;unshare&lt;/code&gt;, &lt;code&gt;mount&lt;/code&gt;, and &lt;code&gt;pivot_root&lt;/code&gt; — not to replace Docker, but to give readers a clear mental model of what happens under the hood of &lt;code&gt;docker run&lt;/code&gt;. The foundation is the mount namespace: it isolates the mount table — the list of mounted filesystems visible to a process — rather than the underlying physical filesystem itself, something you can verify with &lt;code&gt;findmnt&lt;/code&gt; across two namespaces. Velichko emphasizes mount propagation across &lt;code&gt;private&lt;/code&gt;, &lt;code&gt;shared&lt;/code&gt;, and &lt;code&gt;slave&lt;/code&gt; modes: if ignored, mounts created inside a container can leak out to the host, and &lt;code&gt;pivot_root&lt;/code&gt; — the safer alternative to &lt;code&gt;chroot&lt;/code&gt; — requires that the parent mount not be marked &lt;code&gt;shared&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;The hands-on walkthrough mirrors what &lt;code&gt;runc&lt;/code&gt; actually does: prepare a rootfs directory from an Alpine image; create mount, pid, cgroup, uts, and net namespaces; mount the &lt;code&gt;/proc&lt;/code&gt;, &lt;code&gt;/dev&lt;/code&gt;, and &lt;code&gt;/sys&lt;/code&gt; pseudo-filesystems with appropriate restrictions; bind-mount container-specific &lt;code&gt;/etc/hosts&lt;/code&gt;, &lt;code&gt;/etc/hostname&lt;/code&gt;, and &lt;code&gt;/etc/resolv.conf&lt;/code&gt; files; swap the root filesystem via &lt;code&gt;pivot_root&lt;/code&gt;; and harden the container by remounting sensitive &lt;code&gt;/proc&lt;/code&gt; paths read-only and masking others with &lt;code&gt;tmpfs&lt;/code&gt; or &lt;code&gt;/dev/null&lt;/code&gt;. On the security side, an untrusted rootfs can contain symlinks pointing outside the container, so production runtimes use &lt;code&gt;openat2()&lt;/code&gt; with &lt;code&gt;RESOLVE_NO_SYMLINKS&lt;/code&gt; and operate via file descriptors to prevent TOCTTOU race conditions. Finally, bind mounts are the exact same mechanism powering Docker&amp;rsquo;s &lt;code&gt;-v&lt;/code&gt; flag when sharing host volumes with a container.&lt;/p&gt;
&lt;h2 id="using-ai-to-write-better-code-more-slowly"&gt;&lt;a href="https://nolanlawson.com/2026/05/25/using-ai-to-write-better-code-more-slowly/" rel="noopener noreferrer"&gt;Using AI to write better code more slowly&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Amid the &amp;ldquo;vibe coding&amp;rdquo; frenzy, Nolan Lawson asks the opposite question: if so many people are using LLMs to crank out sloppy code as fast as possible, can we use the exact same tools to write better code more slowly? His answer is yes. His workflow centers on multi-model code review: having Claude, Codex, and Cursor Bugbot independently review a pull request, rank issues as critical, high, medium, or low, and then manually synthesizing and verifying their findings to filter out false positives. Using distinct models and wiping context between rounds reduces the chance that all of them hallucinate the same nonexistent bug. He then has the agent fix the critical and high issues, repeats the review loop until none remain, weighs whether the minor issues are worth addressing, and throws out the entire pull request if the process exposes a fundamental architectural flaw.&lt;/p&gt;
&lt;p&gt;Interestingly, his overall delivery speed hasn&amp;rsquo;t increased at all: the review process routinely uncovers pre-existing bugs in surrounding code, turning every new feature into a side quest of writing tests and cleaning up legacy debt. For anyone letting agents open hundred-line pull requests they don&amp;rsquo;t fully grasp, Lawson advises slowing down: ask the agent how the code works and where it could break, have it generate documentation with Mermaid diagrams, or use Matt Pocock&amp;rsquo;s &lt;code&gt;/grill-me&lt;/code&gt; skill until you understand every detail. This approach burns more tokens, but pays off in a deep understanding of failure modes and a much healthier codebase.&lt;/p&gt;
&lt;h2 id="how-cockroachdb-built-vector-indexing-at-scale"&gt;&lt;a href="https://blog.bytebytego.com/p/how-cockroachdb-built-vector-indexing" rel="noopener noreferrer"&gt;How CockroachDB Built Vector Indexing at Scale&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteByteGo breaks down C-SPANN, the vector indexing algorithm CockroachDB designed in-house because no off-the-shelf approach fit a distributed transactional database. Vectors have no natural total ordering, rendering B-trees useless, so every vector index trades exactness for speed via approximate nearest neighbor (ANN) search. CockroachDB set six hard constraints: no central coordinator node, no reliance on massive in-memory structures, minimal network hops, shardable across nodes, no hot spots, and real-time incremental updates — ruling out both traditional HNSW and IVF. C-SPANN instead uses a wide, shallow hierarchical K-means tree: with a branching factor around 100, a million vectors need just three levels and ten billion vectors need five.&lt;/p&gt;
&lt;p&gt;The key architectural decision is storing each partition as ordinary key-value rows inside CockroachDB, allowing the index to automatically inherit range splitting, load balancing, replication, and multi-region placement without a separate infrastructure stack. To cut storage overhead, RaBitQ compresses 1,536-dimensional vectors from ~3 KB down to 200 bytes (a 94% reduction), then uses the full-precision vectors to rerank a small candidate set. For multi-tenancy, prefix columns like &lt;code&gt;(user_id, embedding)&lt;/code&gt; create isolated per-tenant trees, combining with &lt;code&gt;REGIONAL BY ROW&lt;/code&gt; to satisfy data-residency rules. The trade-offs are stated plainly: C-SPANN trails dedicated vector databases on raw tail latency and currently only supports Euclidean distance in preview, but it is a great fit for workloads where vectors need to live alongside transactional data.&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 #37</title><link>https://miti99.com/en/post/2025/07/26/</link><pubDate>Sat, 26 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/26/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #37.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="i-think-it"&gt;&lt;a href="https://maych.in/blog/its-time-to-give-nix-a-chance/" rel="noopener noreferrer"&gt;I Think It&amp;rsquo;s Time to Give Nix a Chance&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Chinmay D. Pai makes the case that Nix deserves a closer look from everyday developers. Unlike traditional package managers that install everything into shared global directories, Nix stores each package inside an immutable &lt;code&gt;/nix/store&lt;/code&gt; path prefixed with a cryptographic hash of all its build inputs. That allows multiple versions of the same software to coexist without conflict, each carrying its own complete dependency tree. Nix flakes pin dependencies so environments can be reproduced reliably across machines, even if they don&amp;rsquo;t guarantee bit-for-bit identical builds in every case. You can also try out tools without installing them permanently via &lt;code&gt;nix shell&lt;/code&gt; or &lt;code&gt;nix run&lt;/code&gt;, while the immutable store and non-standard filesystem layout neutralize several common Linux attack vectors.&lt;/p&gt;
&lt;p&gt;Pai is equally candid about the downsides: learning a bespoke functional language, deciphering cryptic error messages, understanding Nix&amp;rsquo;s evaluation model to debug issues, wrestling with software that hardcodes standard Linux paths, high disk usage, and fragmented documentation. To get started without drowning, he recommends installing via the Determinate Systems Installer, experimenting with &lt;code&gt;nix shell&lt;/code&gt;, and then setting up a simple project dev shell. Nix pays off most for teams plagued by &amp;ldquo;works on my machine&amp;rdquo; drift, painful onboarding, cross-platform builds, or strict compliance requirements—while small projects with stable dependencies probably don&amp;rsquo;t need it yet.&lt;/p&gt;
&lt;h2 id="you-can-choose-tools-that-make-you-happy"&gt;&lt;a href="https://borretti.me/article/you-can-choose-tools-that-make-you-happy" rel="noopener noreferrer"&gt;You Can Choose Tools That Make You Happy&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fernando Borretti argues that programmers&amp;rsquo; technology choices are driven largely by emotion rather than the pure engineering rationality we claim. People pick tools that match an aesthetic and a desired self-image: using Emacs because it feels intellectually elite, or running NetBSD because it fits a cyberpunk persona. Afterward, we construct technical rationalizations to disguise the real motive—downplaying glaring flaws in niche tools (&amp;ldquo;sure, I had to write my own HTTP server&amp;rdquo;), inventing dubious advantages, or lobbing vague criticisms at mainstream options like &amp;ldquo;Docker is too complex&amp;rdquo; or &amp;ldquo;C++ builds character, whereas Rust makes you soft.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Borretti has no problem with emotional tool choices as long as you don&amp;rsquo;t lie to yourself or others. If you pick something for its aesthetic or identity, lean into it honestly and intentionally; just don&amp;rsquo;t claim SNOBOL has a bright commercial future, or tell your manager the decision came from a sober cost-benefit analysis. The core message: you are allowed to choose tools that make you happy—just be honest about why. He also cautions that passion still needs a reality check, because extreme choices divorced from reason can sink years into dead-end paths.&lt;/p&gt;
&lt;h2 id="the-copilot-delusion"&gt;&lt;del&gt;&lt;a href="https://deplet.ing/the-copilot-delusion/" rel="noopener noreferrer"&gt;The Copilot Delusion&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;This post delivers a sharp critique of AI coding assistants like GitHub Copilot and their negative impact on software development. The author argues that these tools generate code without any real understanding of system architecture or deep technical trade-offs.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The core concern is that relying on AI erodes developers&amp;rsquo; critical thinking and ability to learn. When we &amp;ldquo;outsource our thinking to AI,&amp;rdquo; we also &amp;ldquo;outsource our learning&amp;rdquo; to it. These tools lack intuition for hardware performance, memory management, and low-level optimization—key ingredients of high-quality software engineering.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The author worries about the cultural shift across the industry, warning it could produce a generation of developers who prioritize fast output over quality, threatening the &amp;ldquo;hacker spirit&amp;rdquo; and deep technical curiosity. The risk is a wave of developers who think they are skilled simply because their bot got CI to pass, while lacking foundational understanding.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;&lt;strong&gt;Main concerns:&lt;/strong&gt;&lt;/del&gt;
&lt;del&gt;- AI generates code without understanding system architecture&lt;/del&gt;
&lt;del&gt;- Erosion of developers&amp;rsquo; critical thinking skills&lt;/del&gt;
&lt;del&gt;- Lack of intuition around performance and optimization&lt;/del&gt;
&lt;del&gt;- Risk of creating a generation of developers who are only &amp;ldquo;good on paper&amp;rdquo;&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="why-cline-doesn"&gt;&lt;a href="https://cline.bot/blog/why-cline-doesnt-index-your-codebase-and-why-thats-a-good-thing" rel="noopener noreferrer"&gt;Why Cline Doesn&amp;rsquo;t Index Your Codebase (And Why That&amp;rsquo;s a Good Thing)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this May 2025 post, the Cline team explains why they deliberately avoid vector-indexing your codebase and why direct exploration fits their agent better. First, code doesn&amp;rsquo;t work in isolated fragments: chopping it into small chunks breaks interconnected logic, like trying to understand a symphony from random ten-second clips, especially since source code lacks the clean paragraph boundaries of prose. Second, indexes go stale fast as code is refactored and updated; an outdated snapshot can lead an AI to suggest functions that no longer exist or miss recent architectural shifts. Third, generating vector embeddings creates a secondary copy of your intellectual property, bringing extra storage and security risk.&lt;/p&gt;
&lt;p&gt;Instead, Cline navigates a repository the way an experienced engineer does: systematically following imports and call chains. When modifying a payment handler, for instance, Cline traces imports to locate custom error utilities, inspects sibling functions to pick up local conventions, and checks call sites—building contextual understanding rather than doing fuzzy pattern matching. That workflow is now practical thanks to the huge context windows of modern frontier models, shifting the bottleneck from raw retrieval volume to context quality: prioritizing comprehension over retrieval.&lt;/p&gt;
&lt;h2 id="the-perfect-commit"&gt;&lt;a href="https://simonwillison.net/2022/Oct/29/the-perfect-commit/" rel="noopener noreferrer"&gt;The Perfect Commit&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison shares how he organizes his work around the idea of the &amp;ldquo;perfect commit,&amp;rdquo; treating each commit as a carefully packaged unit of work rather than a rough save point. A perfect commit bundles four things: an implementation focused on a single change, tests proving it works, updated documentation, and a link to an issue thread with the surrounding context. In his view, tests boost long-term velocity by letting you change code confidently without regressions, so every project should start with at least one passing test. Documentation—whether for a Python module, a web service, or a CLI tool—belongs right inside the repository so it stays in sync with the code, is versioned alongside it, and gets reviewed in the same diff.&lt;/p&gt;
&lt;p&gt;Rather than writing long commit messages, Willison puts rich context into GitHub issues, which are easier to search, support pasted screenshots, and can be updated later. He acknowledges this goes against traditional Git orthodoxy, but finds it much more effective in practice. Not every commit needs all four elements: tiny bug fixes or doc typo corrections can skip the ceremony. For messy exploratory work, use a separate branch with rough commits and squash-merge a single clean commit into &lt;code&gt;main&lt;/code&gt;. To make the habit effortless, he uses cookiecutter templates that pre-configure test harnesses and GitHub Actions from day one, as seen across open-source projects like Datasette and &lt;code&gt;sqlite-utils&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-software-engineering-kanagawa-moment"&gt;&lt;a href="https://pashabitz.substack.com/p/the-software-engineering-kawagara" rel="noopener noreferrer"&gt;The Software Engineering Kanagawa Moment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pasha uses Hokusai&amp;rsquo;s woodblock print &amp;ldquo;The Great Wave off Kanagawa&amp;rdquo; as a metaphor for the wave of AI automation reshaping software engineering. In his view, programming is uniquely exposed to automation because abundant training data exists, outputs can be verified objectively, and the field faces none of the regulatory barriers that protect professions like medicine or law. Coding agents have already moved well past autocomplete, turning ticket descriptions into complete pull requests, while junior developer hiring has noticeably cooled. Well-bounded, self-contained tasks like refactoring and test writing are being automated first.&lt;/p&gt;
&lt;p&gt;What remains for humans is understanding business needs, shaping product design, setting up technical scaffolding, and defining coding conventions—though the author admits even that boundary is fragile as language models keep improving. His advice for engineers at every level is to adopt coding agents actively, audit workflows for automation opportunities, and sharpen product and business judgment; junior developers in particular should practice shipping end-to-end products, learn deployment infrastructure, and study how real production systems are built rather than just following tutorials. His conclusion is blunt: the wave cannot be stopped, and much like agricultural mechanization shifted labor out of farming, it could displace millions of coding jobs.&lt;/p&gt;
&lt;h2 id="websockets-guarantee-order---so-why-are-my-messages-scrambled"&gt;&lt;a href="https://www.sitongpeng.com/writing/websockets-guarantee-order-so-why-are-my-messages-scrambled" rel="noopener noreferrer"&gt;WebSockets guarantee order - so why are my messages scrambled?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sitong Peng recounts an interesting debugging mystery: WebSocket messages were showing up out of order in her logs, even though WebSockets run over TCP, which guarantees in-order delivery. The culprit wasn&amp;rsquo;t the network protocol, but the application layer. The message event handler called &lt;code&gt;await blob.arrayBuffer()&lt;/code&gt;, suspending execution while each message payload was processed; because processing took anywhere from 1 to 5 seconds per message, a smaller message that arrived later could finish before an earlier, slower one. TCP delivered the frames in exact order—the async handler scrambled them afterward.&lt;/p&gt;
&lt;p&gt;Peng walks through two fixes. The first buffers incoming messages in a queue and processes them in batches of five with &lt;code&gt;Promise.all&lt;/code&gt;, preserving order across results while still allowing parallelism within each batch. The second uses an async generator to process messages strictly one at a time—slower since there is no concurrency, but guaranteeing total ordering when application logic requires it. The broader lesson is how tricky it is to debug across multiple abstraction layers: even when the transport layer guarantees reliability and ordering, careless concurrency in application code can undo it, so you have to separate what each layer actually promises.&lt;/p&gt;
&lt;h2 id="why-agents-are-bad-pair-programmers"&gt;&lt;a href="https://justin.searls.co/posts/why-agents-are-bad-pair-programmers/" rel="noopener noreferrer"&gt;Why agents are bad pair programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Justin Searls argues that AI coding agents make terrible pair programmers because they &amp;ldquo;write code faster than humans can think.&amp;rdquo; That speed breaks the collaborative loop: the human partner can&amp;rsquo;t keep up, tunes out, and loses track of how the system works. It feels like pairing with someone who grabs the keyboard and types in silence at superhuman speed. When the agent inevitably hits a wall, the human lacks the mental context from earlier decisions needed to bail it out; worse, the agent may have solved the wrong problem entirely, leaving behind a pile of accidental complexity to clean up.&lt;/p&gt;
&lt;p&gt;Searls suggests two paths forward. First, move agents into an asynchronous workflow: hand them self-contained tasks and review the output via pull requests, like GitHub&amp;rsquo;s Coding Agent. Second, slow things down when working synchronously by using &amp;ldquo;Edit&amp;rdquo; or &amp;ldquo;Ask&amp;rdquo; modes instead of fully autonomous &amp;ldquo;Agent&amp;rdquo; mode; ping-pong pairing in Edit mode, where you review and approve each step, strikes the best balance. He also urges toolmakers to add adjustable generation speed, pause-and-ask checkpoints, UIs that reflect workflow state like GitHub integration and to-do lists, less overconfident agent personas that check in more often, and voice chat. Those changes would turn agents into genuine collaborators rather than lone sprinters.&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 #30</title><link>https://miti99.com/en/post/2025/05/17/</link><pubDate>Sat, 17 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/17/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #30 - Today&amp;rsquo;s tech news roundup.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="what-i"&gt;&lt;a href="https://muratbuffalo.blogspot.com/2025/04/what-id-do-as-college-freshman.html" rel="noopener noreferrer"&gt;What I&amp;rsquo;d do as a College Freshman in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Computer science professor Murat Demirbas asks what he would do if he were starting college over as a freshman in 2025, and his first answer is still to study Computer Science. Against the claim that &amp;ldquo;nobody needs to learn programming anymore,&amp;rdquo; he argues that AI tools cannot replace real mastery: debugging skills, abstract thinking, and fast adaptability have to be forged firsthand. He advises building a strong foundation in both computer science and AI, then pairing AI with a deep domain such as systems, databases, or programming languages—aiming to become &amp;ldquo;π-shaped,&amp;rdquo; with depth in two areas and broad literacy across many others.&lt;/p&gt;
&lt;p&gt;Beyond technical depth, soft skills are indispensable: clear communication powers remote work, learning in public, and even working with LLMs, while management starts with managing yourself. Demirbas still views the US as the best launchpad for a tech career and university as the best place to meet talented peers and build projects together. Borrowing a friend&amp;rsquo;s metaphor, he says you should either be an all-terrain Jeep with an entrepreneurial mindset, or a specialized, high-speed Ferrari when a paved track exists—just don&amp;rsquo;t be an easily replaceable Corolla, because in the AI era that is what gets automated away. Finally, play the long game, compounding skills and relationships rather than chasing trends.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="llms-are-weird-computers"&gt;&lt;a href="https://www.phillipcarter.dev/posts/llms-computers" rel="noopener noreferrer"&gt;LLMs Are Weird Computers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Phillip Carter proposes a useful mental model for large language models (LLMs): treat them as a &amp;ldquo;weird&amp;rdquo; or &amp;ldquo;inverted&amp;rdquo; kind of computer alongside the &amp;ldquo;normal&amp;rdquo; computers we already know. Traditional computers execute with exact precision but struggle with ambiguity, whereas LLMs do the opposite: they excel at handling ambiguity but struggle when absolute precision is required.&lt;/p&gt;
&lt;p&gt;Viewing LLMs as a new class of computer with its own distinct properties helps developers better understand their strengths and limits, making it clearer which tasks to hand to an LLM and when traditional computation is still the right tool.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="every-caching-strategy-explained-in-5-minutes"&gt;&lt;a href="https://www.swequiz.com/blog/every-caching-strategy-explained-in-5-minutes" rel="noopener noreferrer"&gt;Every Caching Strategy Explained in 5 Minutes&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This SWE Quiz post gives a quick tour of common caching strategies, a foundational topic for optimizing application performance. With Cache-Aside (also called lazy loading), the application manages the cache directly: it checks the cache first and queries the database only on a miss, which fits read-heavy systems that can tolerate briefly stale data. Read-Through instead has the application talk only to the cache while the cache itself loads missing data from the database, keeping application code cleaner.&lt;/p&gt;
&lt;p&gt;On the write side, Write-Through writes synchronously to both the cache and the database, guaranteeing consistency at the cost of slower writes. Write-Behind (Write-Back) writes only to the cache and flushes to the database asynchronously later, speeding up writes but risking data loss if the cache fails before syncing. Write-Around bypasses the cache on writes and uses it only for reads, which suits data that is rarely re-read immediately after being written. Choosing the right strategy depends on an application&amp;rsquo;s specific trade-offs across performance, consistency, and fault tolerance.&lt;/p&gt;
&lt;h2 id="some-features-that-every-javascript-developer-should-know-in-2025"&gt;&lt;a href="https://waspdev.com/articles/2025-04-06/features-that-every-js-developer-must-know-in-2025" rel="noopener noreferrer"&gt;Some features that every JavaScript developer should know in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This WaspDev article rounds up modern JavaScript features every developer should know to write cleaner, more efficient code. Standouts include iterator helper methods like &lt;code&gt;drop()&lt;/code&gt;, &lt;code&gt;take()&lt;/code&gt;, and &lt;code&gt;filter()&lt;/code&gt;, which process large datasets lazily one element at a time without allocating memory-hungry intermediate arrays. The &lt;code&gt;at()&lt;/code&gt; method supports negative indexing on arrays, such as &lt;code&gt;arr.at(-1)&lt;/code&gt; to grab the last element, while &lt;code&gt;Promise.withResolvers()&lt;/code&gt; cleanly exposes &lt;code&gt;resolve&lt;/code&gt; and &lt;code&gt;reject&lt;/code&gt; alongside a newly created Promise.&lt;/p&gt;
&lt;p&gt;The post also highlights underused techniques: passing a callback function to &lt;code&gt;replace()&lt;/code&gt; and &lt;code&gt;replaceAll()&lt;/code&gt; for complex string substitutions, swapping two variables via &lt;code&gt;[a, b] = [b, a]&lt;/code&gt; instead of a temporary variable, and deep-cloning objects with &lt;code&gt;structuredClone()&lt;/code&gt; rather than &lt;code&gt;JSON.parse(JSON.stringify())&lt;/code&gt;. Rounding out the list are tagged templates for flexible template-literal processing, &lt;code&gt;WeakMap&lt;/code&gt;/&lt;code&gt;WeakSet&lt;/code&gt; for attaching metadata to objects without preventing garbage collection, and new &lt;code&gt;Set&lt;/code&gt; operations like &lt;code&gt;union()&lt;/code&gt;, &lt;code&gt;intersection()&lt;/code&gt;, and &lt;code&gt;difference()&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="what-makes-a-great-developer-experience"&gt;&lt;a href="https://www.codesimplicity.com/post/what-makes-a-great-developer-experience/" rel="noopener noreferrer"&gt;What Makes a Great Developer Experience?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Max Kanat-Alexander, who has spent over 20 years working on developer experience (DX) and helped design key parts of DX at Google and LinkedIn, distills the field&amp;rsquo;s core principles. In his view, a great DX optimizes three things: cycle time, the elapsed time from when a developer forms an intent to when that intent is fulfilled; focus, the ability to work in uninterrupted flow; and cognitive load, the amount of knowledge required and the number of decisions a developer must make to get something done.&lt;/p&gt;
&lt;p&gt;Most of the post focuses on the practical challenges of improving DX: understanding the real problem through data and developer feedback, managing change through gradual rollouts and driving adoption, building high-leverage tools that save human time rather than just machine resources, saying &amp;ldquo;no&amp;rdquo; or &amp;ldquo;not yet&amp;rdquo; kindly to requests that don&amp;rsquo;t fit, and placing the burden on the party actually causing the problem. The overarching lesson is that the hardest part of DX is usually human rather than technical.&lt;/p&gt;
&lt;h2 id="when-life-gives-you-java"&gt;&lt;a href="https://oblac.rs/when-life-gives-you-java/" rel="noopener noreferrer"&gt;When Life Gives You Java&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Igor Spasić shares how he writes Java when he has to use the language but still wants clean code, borrowing ideas from more expressive functional languages. He makes classes package-private by default and exposes them publicly only when strictly necessary, treating each package as a module. Roughly 95% of references are marked &lt;code&gt;final&lt;/code&gt; to embrace immutability, which makes &lt;code&gt;null&lt;/code&gt; nearly disappear outside very narrow boundaries. He no longer uses inheritance in his own code, favoring object composition instead, while still accepting inheritance where external libraries require it.&lt;/p&gt;
&lt;p&gt;Spasić thinks in terms of &amp;ldquo;input, process, output&amp;rdquo; functions: because Java lacks true first-class functions, each class typically wraps a single function or a small group of closely related ones. Algebraic data types (ADTs) are modeled as &lt;code&gt;record&lt;/code&gt;s implementing a &lt;code&gt;sealed interface&lt;/code&gt;, and domain errors are returned as part of the result via dedicated ADTs, reserving exceptions for genuine runtime failures like out-of-memory errors, I/O failures, or lost database connections. That produces more small classes, which he considers a worthwhile trade-off for more modular code with fewer surprises.&lt;/p&gt;
&lt;h2 id="just-throw-it-into-postgres"&gt;&lt;a href="https://simonsafar.com/2025/throw_it_into_postgres/" rel="noopener noreferrer"&gt;Just Throw It Into Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Safar argues that between the two extremes of forcing all data into a strictly normalized relational schema and dumping raw data into countless files in a directory tree, there is a practical middle ground: just throw the data straight into PostgreSQL without overthinking upfront organization. Thanks to &lt;code&gt;JSONB&lt;/code&gt;, PostgreSQL can query fields inside JSON documents directly, while indexes and dedicated columns can be added later once the data is already there.&lt;/p&gt;
&lt;p&gt;He illustrates this with three examples. First, he built a custom Java code-navigation tool for Emacs: it parsed compiled class files to record relationships like &amp;ldquo;function A calls function B,&amp;rdquo; then loaded hundreds of thousands of records into PostgreSQL via &lt;code&gt;COPY&lt;/code&gt; in a few dozen seconds—fast enough to invoke &lt;code&gt;psql&lt;/code&gt; multiple times per second for autocomplete. Second, he loaded tens of thousands of Chinese character SVGs from the Make Me a Hanzi project into a table with a &lt;code&gt;JSONB&lt;/code&gt; column and joined it against a dictionary table for fast lookups. Third, he stored temperature sensor readings arriving over MQTT so Grafana could chart them. The takeaway: get the data stored first and organize it later, rather than trying to design the perfect schema on day one.&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>