<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Compression on miti99</title><link>https://miti99.com/en/tags/compression/</link><description>Recent content in Compression 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/compression/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #92</title><link>https://miti99.com/en/post/2026/03/20/</link><pubDate>Fri, 20 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/20/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #92.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-i-became-good-at-leading-incidents"&gt;&lt;del&gt;&lt;a href="https://tomasztomczyk.com/blog/2026/how-i-became-good-at-leading-incidents/" rel="noopener noreferrer"&gt;How I became good at leading incidents&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;Tomasz Tomczyk shares lessons from leading more than 100 incidents over his career, emphasizing that incident management is not just a technical skill, but a blend of analytical thinking and leadership under pressure. He views every incident as an opportunity to deepen system understanding and build a culture that learns from failure.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;To handle incidents effectively, you need a solid grasp of your deployment pipeline and the entire tech stack from DNS up to the application layer, backed by comprehensive observability. When an incident hits, delegate investigation along clear tracks, make decisive calls when features need to be disabled, and communicate timely updates to stakeholders. Documenting recurring failure patterns in runbooks and practicing through chaos-engineering game days also prepares teams much better for real-world outages.&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;- Master the deployment pipeline and full tech stack to pinpoint root causes quickly&lt;/del&gt;
&lt;del&gt;- Read stack traces fluently and use error-tracking tools like Sentry for deeper investigation&lt;/del&gt;
&lt;del&gt;- Build a culture of psychological safety so failures become learning opportunities&lt;/del&gt;
&lt;del&gt;- Delegate investigation strategically and make decisive calls under pressure&lt;/del&gt;
&lt;del&gt;- Maintain runbooks and run game days to prepare for real incidents&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="decision-trees"&gt;&lt;a href="https://mlu-explain.github.io/decision-tree/" rel="noopener noreferrer"&gt;Decision Trees&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part of the interactive MLU-Explain series by Jared Wilber and Lucía Santamaría, this visual essay introduces decision trees from the ground up. It opens with an intuitive example: a farmer trying to tell apple, cherry, and oak trees apart using only trunk diameter and height. At each step, the algorithm searches for the best split—for instance, nearly every tree with a diameter of 0.45 or greater is an oak, making that condition the root node; the remaining data is recursively partitioned by height or diameter until each region contains mostly a single tree species. The result is a nested set of rules that any new data point can walk down to be classified.&lt;/p&gt;
&lt;p&gt;To pick each split, the ID3 algorithm favors the threshold that yields the highest &lt;em&gt;information gain&lt;/em&gt;—that is, the largest reduction in data entropy. Splitting too deeply, however, causes the tree to memorize noise in the training set rather than generalizable patterns, a classic illustration of the bias–variance trade-off leading to overfitting. Decision trees are easy to interpret, fast to train, require minimal preprocessing, and handle outliers well, but they are notoriously unstable: a tiny change in training data can produce a completely different tree structure. Pruning techniques—such as capping maximum depth or requiring a minimum number of samples per leaf—help keep overfitting in check.&lt;/p&gt;
&lt;h2 id="containers-are-not-a-security-boundary"&gt;&lt;del&gt;&lt;a href="https://www.lucavall.in/blog/containers-are-not-a-security-boundary" rel="noopener noreferrer"&gt;Containers Are Not a Security Boundary&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Drawing on Liz Rice&amp;rsquo;s book &lt;em&gt;Container Security&lt;/em&gt; and his own exploration of the Linux primitives underneath, Luca Cavallin reminds us that containers are not automatically secure. At bottom, a container is just a normal Linux process wrapped in a few isolation primitives: namespaces restrict what the process can see, and cgroups cap the resources it can consume, yet every container on a host shares the exact same Linux kernel. Consequently, kernel vulnerabilities, misconfigured mounts, overly broad capabilities like &lt;code&gt;CAP_SYS_ADMIN&lt;/code&gt;, or forgotten setuid binaries can all become privilege-escalation paths; simply &amp;ldquo;not running as root&amp;rdquo; isn&amp;rsquo;t enough. Classic principles like least privilege, defense in depth, attack-surface reduction, and blast-radius containment still apply in full.&lt;/p&gt;
&lt;p&gt;To harden containers, the author recommends filtering syscalls with seccomp, adding mandatory access control via AppArmor or SELinux, and using user namespaces to map root inside the container to an unprivileged user on the host. When stronger isolation is required—such as running untrusted code or multi-tenant workloads—teams can turn to gVisor, Kata Containers, Firecracker, or full virtual machines where each guest gets its own kernel. The post also emphasizes supply-chain security: treating the Dockerfile as an enforceable policy, using minimal base images, pinning image digests rather than mutable tags, separating build and runtime stages, signing images with Cosign, and having admission controllers reject unsigned or untrusted images before deployment.&lt;/p&gt;
&lt;h2 id="an-ode-to-bzip"&gt;&lt;a href="https://purplesyringa.moe/blog/an-ode-to-bzip/" rel="noopener noreferrer"&gt;An ode to bzip&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Purplesyringa needed to compress Lua source code for the ComputerCraft mod in Minecraft, where in-game floppy disk space is tight and the decompressor itself has to fit inside a tiny budget. Compressing a 327 KB Lua source bundle, &lt;code&gt;bzip2&lt;/code&gt; reached 63,727 bytes and &lt;code&gt;bzip3&lt;/code&gt; reached 61,067 bytes—beating &lt;code&gt;zopfli&lt;/code&gt;, &lt;code&gt;zstd&lt;/code&gt;, &lt;code&gt;xz&lt;/code&gt;, &lt;code&gt;brotli&lt;/code&gt;, and &lt;code&gt;lzip&lt;/code&gt; on that file. The secret lies in the algorithm: whereas most mainstream compressors are built on LZ77 (replacing repeated substrings with back-references to earlier occurrences), &lt;code&gt;bzip&lt;/code&gt; uses the Burrows–Wheeler Transform (BWT) to sort characters by their surrounding context. That clusters identical characters into long runs that compress exceptionally well with run-length encoding—making it a natural fit for structured text like source code.&lt;/p&gt;
&lt;p&gt;Because the BWT transform itself is deterministic while leaving room for simpler block-size and entropy-coding choices, even a stripped-down custom encoder achieves strong compression ratios. By dropping compatibility with the standard container format and using a single Huffman table, the author&amp;rsquo;s custom bzip-style decompressor came in at roughly 1.5 KB of code. &lt;code&gt;bzip&lt;/code&gt; is often dismissed as slow, but when you are compressing to squeeze under a hard size cap, the difference is between booting and not booting at all—and in a high-level interpreted language like Lua where every operation carries overhead anyway, &lt;code&gt;bzip&lt;/code&gt;&amp;rsquo;s speed disadvantage largely fades. The author concludes that while &lt;code&gt;bzip&lt;/code&gt; may no longer be the default general-purpose choice, it remains remarkably effective for text and source code.&lt;/p&gt;
&lt;h2 id="why-arm-is-becoming-the-cpu-foundation-for-ai-data-center-architecture"&gt;&lt;a href="https://newsroom.arm.com/blog/why-system-architects-default-to-arm-in-ai-data-centers" rel="noopener noreferrer"&gt;Why Arm is becoming the CPU foundation for AI data center architecture&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Arm Newsroom piece argues that AI workloads are exposing the limits of traditional general-purpose server designs across power delivery, cooling, memory bandwidth, and system-level efficiency. As a result, data centers are shifting toward purpose-built rack-scale AI systems where the defining question is no longer raw peak FLOPS, but how effectively accelerators, CPUs, memory, networking, and software work together. Agentic AI sharpens this shift: agents plan, invoke tools, retrieve data, and loop continuously, creating 24/7 inference traffic. In that world, the CPU acts as the orchestration hub—handling scheduling, routing, I/O, networking, storage, and security so the accelerators stay fed.&lt;/p&gt;
&lt;p&gt;According to Arm, performance per watt has become the decisive metric because power availability and energy budgets are hard constraints. The post cites projections that nearly half of the compute capacity shipped to top hyperscalers by late 2025 is expected to be Arm-based, alongside benchmarks showing AWS Graviton4 (Neoverse) delivering stronger performance and price-performance than comparable AMD and Intel instances. New rack-scale architectures like the NVIDIA Vera Rubin NVL72—pairing 72 Rubin GPUs with 36 Arm-based Vera CPUs—and the AWS Trainium3 UltraServer with Graviton follow this exact blueprint. Arm also highlights software portability across hardware generations without rewriting application code.&lt;/p&gt;
&lt;h2 id="we-built-an-agent-skill-so-ai-writes-redis-code"&gt;&lt;a href="https://redis.io/blog/we-built-an-agent-skill-so-ai-writes-redis-code/" rel="noopener noreferrer"&gt;We built an Agent Skill so AI writes Redis code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Redis introduces an official Agent Skill—a markdown knowledge pack that AI coding agents like Claude Code, Cursor, Codex, and GitHub Copilot can load into context on demand with a single install command. The team noticed that AI-generated Redis code routinely suffers from three problems. First, models trained on older corpora write code as if Redis stopped at version 6, ignoring vector sets, native JSON, the query engine, and LangCache. Second, agents improvise fragile patterns instead of using battle-tested idioms—building rate limiters without sliding-window sorted sets, omitting cache-stampede protection, or forgetting pipelining. Third, models don&amp;rsquo;t warn you about what they don&amp;rsquo;t know, casually emitting blocking &lt;code&gt;KEYS *&lt;/code&gt; calls against million-key instances or stuffing large JSON blobs into plain strings instead of hashes.&lt;/p&gt;
&lt;p&gt;The skill supplies up-to-date reference patterns for caching, rate limiting, session stores, vector search, semantic caching, agent memory, pub/sub, and streams; decision guides for picking between hashes, JSON, sorted sets, and vector sets; guardrails against anti-patterns like &lt;code&gt;KEYS&lt;/code&gt; in loops or unbounded key growth; and production-ready defaults for connection pooling, pipelining, and cluster compatibility. As Anthropic&amp;rsquo;s team puts it, MCP gives agents tools, while Skills teach them how to use those tools well. Built on an open format, the skill loads only when relevant to keep context windows lean, can be versioned in Git, shared across teams, and composed with other skills.&lt;/p&gt;
&lt;h2 id="inside-the-archive-the-tech-behind-your-2025-wrapped-highlights"&gt;&lt;a href="https://engineering.atspotify.com/2026/3/inside-the-archive-2025-wrapped" rel="noopener noreferrer"&gt;Inside the Archive: The Tech Behind Your 2025 Wrapped Highlights&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spotify&amp;rsquo;s engineering team shares how they built the Wrapped Archive feature for 2025 Wrapped: for every eligible listener, the system selects up to five &amp;ldquo;memorable days&amp;rdquo; from the past year and uses an LLM to write personalized narrative recaps grounded strictly in the user&amp;rsquo;s actual listening history. Candidate days are picked by a prioritized set of heuristics—such as biggest listening day, most new artists discovered, or most unusual listening pattern. To generate roughly 1.4 billion stories across 350 million users at a sustainable cost, the team distilled a frontier model into a much smaller model using a carefully curated &amp;ldquo;golden&amp;rdquo; dataset, then aligned it further with Direct Preference Optimization (DPO) from human evaluations. The batch pipeline ran continuously for four days at thousands of requests per second.&lt;/p&gt;
&lt;p&gt;On the storage side, each memorable day was written to its own column in a column-oriented key-value store, so concurrent writes for the same user never collided or required locks or read-modify-write cycles. Because Wrapped launches globally all at once, the team pre-scaled infrastructure and ran full load tests across every region hours ahead of launch. Quality was guarded by an LLM-as-a-judge pipeline that scored roughly 165,000 sampled stories for factual accuracy, safety, tone, and formatting—which caught a timezone bug in the data pipeline that was shifting dates in generated stories, letting the team fix and regenerate the affected batch before launch. Their biggest takeaway: at this scale, calling the LLM is the easy part; capacity planning and automated safety loops are where the real engineering lives.&lt;/p&gt;
&lt;h2 id="managing-multiple-agents"&gt;&lt;a href="https://fffej.substack.com/p/managing-multiple-agents" rel="noopener noreferrer"&gt;Managing Multiple Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jeff explores what happens when you apply classic human management styles to multi-agent AI orchestration through a playful simulation: four &amp;ldquo;minions&amp;rdquo; assembling an Ikea Billy bookcase—Kevin reading the manual, Stuart fetching parts, Bob assembling, and Dave running quality checks—all powered by the open-weights &lt;code&gt;gpt-oss:20b&lt;/code&gt; model. Under &lt;em&gt;Command and Control&lt;/em&gt;, every action had to be approved by the coordinator, burning through messages and moving at a crawl. &lt;em&gt;Taylorism&lt;/em&gt; broke the job into rigid, standardized micro-steps, running much faster but stripping the agents of any autonomy to adapt.&lt;/p&gt;
&lt;p&gt;In the simulation, &lt;em&gt;management by outcomes&lt;/em&gt;—stating the goal alongside a work-in-progress (WIP) limit—won handily, finishing five times faster than Command and Control and three times faster than Taylorism. Most delightfully, Stuart noticed on his own that assembly had become the bottleneck and jumped in to help Bob without being told. By contrast, &lt;em&gt;total autonomy&lt;/em&gt; with no constraints still got the bookcase built, but devolved into chaos with agents duplicating each other&amp;rsquo;s work—echoing Kent Beck&amp;rsquo;s line that &amp;ldquo;autonomy without constraints is chaos.&amp;rdquo; The author concludes that orchestrating AI agents mirrors managing people: less capable agents need tight scaffolding, while capable agents perform best when given clear goals and constraints and left to figure out the rest.&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 #59</title><link>https://miti99.com/en/post/2025/10/03/</link><pubDate>Fri, 03 Oct 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/10/03/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #59.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="taking-a-look-at-compression-algorithms"&gt;&lt;a href="https://cefboud.com/posts/compression/" rel="noopener noreferrer"&gt;Taking a Look at Compression Algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Moncef Abboud&amp;rsquo;s article dives into four popular lossless compression algorithms—GZIP (DEFLATE), Snappy, LZ4, and ZSTD—framed around the three metrics every compression algorithm must balance: compression ratio, compression speed, and decompression speed. DEFLATE combines LZ77 sliding-window matching, which replaces repeated sequences with back-references, and Huffman coding, which assigns shorter codes to frequent symbols. Walking through Go&amp;rsquo;s standard library implementation, the author shows how a chained hash table finds matching substrings and how the compression level essentially controls how deep down that chain the compressor searches: searching longer burns more CPU but yields a higher compression ratio.&lt;/p&gt;
&lt;p&gt;Snappy and LZ4 both belong to the LZ family but prioritize speed: Snappy compresses at 250 MB/s and up, while LZ4 reaches roughly 780 MB/s for compression and nearly 5 GB/s for decompression at a similar ratio (~2.1x), thanks to a simple block format using a 4-bit token layout for literal and match lengths plus hardware-friendly XOR comparisons. ZSTD achieves the best of both worlds: a ~2.9x compression ratio matching or beating DEFLATE alongside a ~510 MB/s compression speed approaching LZ4, by combining LZ-style matching with modern FSE entropy coding (based on ANS) and support for pre-trained dictionaries. No single algorithm wins everywhere: DEFLATE suits general archival, Snappy and LZ4 fit speed-critical systems, and ZSTD is the balanced all-rounder.&lt;/p&gt;
&lt;h2 id="90"&gt;&lt;a href="https://lucumr.pocoo.org/2025/9/29/90-percent/" rel="noopener noreferrer"&gt;90%&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher shares that for an infrastructure component he started at his new company, over 90% of the code was written by AI. It is a Go service for sending and receiving emails, complete with an OpenAPI-compatible REST API and SDKs for Python and TypeScript, totaling around 40,000 lines of code. Even so, he treats every line as his own responsibility: he designed the system, database schema, and architecture himself, using AI only as a &amp;ldquo;rubber duck&amp;rdquo; sparring partner. AI allowed him to pursue choices that used to be too tedious to do by hand, such as writing raw SQL instead of using an ORM for easier debugging, or making the OpenAPI spec the single source of truth and generating both client and server code from it. He uses Claude Code for debugging and Codex for code review.&lt;/p&gt;
&lt;p&gt;Ronacher is equally candid about the downsides: left unchecked, AI agents write terrible code, reinvent existing utilities, build abstractions at the wrong scale, fail to truly grasp Go concurrency with goroutines, pull in outdated dependencies, and swallow errors in ways that hurt observability. For example, an AI-written rate limiter &amp;ldquo;worked&amp;rdquo; but lacked jitter and had poor storage design—easy to fix if you understand the domain, dangerous if you don&amp;rsquo;t. Conversely, AI shines at rapid research-and-prototyping loops, continuous refactoring, spinning up AWS infrastructure, or migrating a test suite to testcontainers in an hour. His conclusion: 90% AI-written code is already a reality, but it doesn&amp;rsquo;t eliminate the need to be a strong engineer.&lt;/p&gt;
&lt;h2 id="the-weird-concept-of-branchless-programming"&gt;&lt;a href="https://sanixdk.xyz/blogs/the-weird-concept-of-branchless-programming" rel="noopener noreferrer"&gt;The Weird Concept of Branchless Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Branchless programming is the technique of rewriting conditional statements into arithmetic and bitwise operations, or using conditional move instructions like &lt;code&gt;cmov&lt;/code&gt;, so the CPU doesn&amp;rsquo;t have to guess which branch will be taken. Modern CPU branch predictors perform remarkably well when conditions follow a pattern, but with unpredictable data like user input or shuffled arrays, every misprediction forces a pipeline flush and costs roughly 15–20 cycles. Branchless code runs more consistently and often has more predictable execution time, which matters in cryptography to defend against side-channel attacks—though removing branches alone does not guarantee constant time, as memory access patterns, compiler optimizations, and machine instructions must still be verified.&lt;/p&gt;
&lt;p&gt;The author illustrates this with three C examples of increasing complexity: computing an absolute value using a bitmask derived from a 31-bit arithmetic right shift, a &lt;code&gt;clamp&lt;/code&gt; function that bounds a value between min and max without an &lt;code&gt;if&lt;/code&gt;, and a quicksort &lt;code&gt;partition&lt;/code&gt; function that increments the index directly using the comparison result. Benchmarks show that &lt;code&gt;abs&lt;/code&gt; and &lt;code&gt;clamp&lt;/code&gt; are barely any faster because the branch predictor already handles them well; only &lt;code&gt;partition&lt;/code&gt;, with its unpredictable condition, sees a ~1.2x speedup. The takeaway: branchless programming is a &amp;ldquo;scalpel, not a sledgehammer&amp;rdquo;—use it for hot loops with unpredictable branches, timing-sensitive code, or SIMD vectorization, and stick to plain &lt;code&gt;if&lt;/code&gt; statements when readability matters more than a few nanoseconds.&lt;/p&gt;
&lt;h2 id="ai-coding-assistants-building-apps-for-30-hours-straight"&gt;&lt;a href="https://threadreaderapp.com/thread/1972793278744461627.html" rel="noopener noreferrer"&gt;AI Coding Assistants: Building Apps for 30 Hours Straight&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In an X thread, Carlos E. Perez (@IntuitMachine) analyzes the leaked system prompt of Claude Sonnet 4.5 to explain how the model can work autonomously for roughly 30 hours straight to build a Slack-like application with over 10,000 lines of code. According to Perez, the secret lies in forcing any code snippet longer than about 20 lines into a persistent artifact—at most one artifact per response—paired with clear rules for when to make targeted updates versus when to rewrite the file from scratch. This lets the model evolve a large codebase across many turns without losing state. The prompt also enforces runtime constraints such as banning &lt;code&gt;localStorage&lt;/code&gt; and restricting how libraries are imported so UI previews remain stable inside the sandbox.&lt;/p&gt;
&lt;p&gt;Alongside this are patterns that sustain long-horizon autonomy: a research mode that plans, searches, and synthesizes answers; using tools to verify facts rather than guessing; separating thinking from acting to prevent premature coding; planning and feedback loops inspired by Voyager and Generative Agents; passing full conversation state on every call; and a &amp;ldquo;failure ritual&amp;rdquo; that clears stale context and retries with lessons learned. Favoring familiar stacks like React and Flask and keeping outputs in JSON for automated testing also prevent multi-hour sessions from collapsing under their own complexity.&lt;/p&gt;
&lt;h2 id="development-gets-better-with-age"&gt;&lt;a href="https://www.allthingsdistributed.com/2025/10/better-with-age.html" rel="noopener noreferrer"&gt;Development Gets Better with Age&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After nearly 25 years at Amazon, Werner Vogels reflects on the advantages of older developers. They have already encountered most of the problems younger engineers are facing today, carry battle scars from war rooms, know what is practical and effective, and are trained to spot warning signs early. That frees up mental bandwidth for creativity, building mental models, and finding novel solutions—which he considers the best part of the craft. They have also watched industry patterns repeat over and over, including vendors that promise the moon and deliver products riddled with holes.&lt;/p&gt;
&lt;p&gt;On generative AI, Vogels acknowledges that it is an exciting, powerful technology in the hands of experienced builders with healthy skepticism, but notes that the hype wave exploded because it arrived without an instruction manual. AWS responded by returning to its roots: democratizing access, giving customers model choice, and putting privacy and security first. When customers ask what they should do with generative AI, it is mostly driven by FOMO rather than a concrete problem. That is when seasoned developers know to hit pause, talk deeply with the customer to uncover the real challenge, and recognize that only sometimes is generative AI the right answer. As he puts it: new technology, same old patterns.&lt;/p&gt;
&lt;h2 id="programming-deflation"&gt;&lt;a href="https://tidyfirst.substack.com/p/programming-deflation" rel="noopener noreferrer"&gt;Programming Deflation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck starts from the premise that AI-assisted programming is steadily driving down the cost, skill barrier, and time required to build software, and asks: will this lead to fewer programmers or more? Economics offers two opposing answers: the substitution effect says machines will replace people, while Jevons paradox predicts demand will surge when a resource becomes cheaper. If writing software tomorrow is even cheaper than today, organizations might delay investment, much like a deflationary spiral. Unlike economic deflation, however—which reflects weakness—&amp;ldquo;programming deflation&amp;rdquo; comes from real productivity gains: when the cost of experimentation approaches zero, people want to try ideas immediately; low-quality code floods the market while the gap to carefully crafted software widens; and value shifts from writing code to understanding what to build and how systems fit together.&lt;/p&gt;
&lt;p&gt;Beck&amp;rsquo;s advice is to use cheap tools for the obvious parts and save your energy for hard problems, focus on integration since typing code is no longer the bottleneck, cultivate &amp;ldquo;taste&amp;rdquo; to know what is worth building, and think in systems. In a world of abundant code, the scarce resources are understanding, judgment, and the wisdom to know what not to do. Those qualities remain valuable whether the future holds fewer programmers or more, so instead of trying to predict which scenario wins, build skills that thrive in both.&lt;/p&gt;
&lt;h2 id="what-is"&gt;&lt;a href="https://www.seangoedecke.com/taste/" rel="noopener noreferrer"&gt;What is &amp;ldquo;good taste&amp;rdquo; in software engineering?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke distinguishes &amp;ldquo;technical taste&amp;rdquo; from technical skill: you can be highly skilled with bad taste, or vice versa. In his view, taste is the ability to choose the right set of engineering values for the project at hand. For instance, he prefers &lt;code&gt;map&lt;/code&gt; and &lt;code&gt;filter&lt;/code&gt; over &lt;code&gt;for&lt;/code&gt; loops because pure functions are easier to reason about and avoid off-by-one errors, whereas someone who prefers &lt;code&gt;for&lt;/code&gt; loops has equally valid reasons like easier performance reasoning or simpler control-flow extensions. The difference isn&amp;rsquo;t skill, but which values each engineer prioritizes. Most engineering decisions trade off competing values—resilience, speed, readability, correctness, flexibility, portability, scalability, and development velocity—and no engineer weights them all equally.&lt;/p&gt;
&lt;p&gt;Bad taste means prioritizing values that don&amp;rsquo;t fit the project, and it usually stems from rigidity: importing a solution that worked elsewhere without considering context, or justifying choices with &amp;ldquo;it&amp;rsquo;s best practice.&amp;rdquo; Such an engineer is like a broken compass—only right when standing in the right spot by chance. Good taste is harder to spot because it only reveals itself on real problems; the telltale sign is that projects you work on, or whose design you agree with, tend to succeed. To develop taste, the author recommends working on a wide variety of projects, paying attention to what turns out to be easy or painful, and staying flexible rather than forming rigid dogmas about the &amp;ldquo;one true way&amp;rdquo; to write software.&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;img src="https://substackcdn.com/image/fetch/$s_!CEQb!,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F30caf720-4b66-4f5f-84d2-72c578969944_2250x2624.heic" alt="Service Discovery 101: The Phonebook for Distributed Systems"&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;My backlog of saved articles is now empty. It&amp;rsquo;ll probably take a while to build up a new stash before I can continue. See you next time!&lt;/em&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></channel></rss>