<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Prompt Engineering on miti99</title><link>https://miti99.com/en/tags/prompt-engineering/</link><description>Recent content in Prompt Engineering 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/prompt-engineering/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #83</title><link>https://miti99.com/en/post/2026/02/24/</link><pubDate>Tue, 24 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #83.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-uber-scaled-data-replication-to-move-petabytes-every-day"&gt;&lt;a href="https://www.uber.com/en-IN/blog/scaled-data-replication/" rel="noopener noreferrer"&gt;How Uber Scaled Data Replication to Move Petabytes Every Day&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Uber shares how its engineering team scaled HiveSync—its cross-region data replication service built on Apache Hadoop DistCp—to keep pace with a data lake exceeding 350 PB. In Q3 2022 alone, daily replicated data volume jumped from 250 TB to 1 PB, the number of datasets managed by HiveSync grew from 30,000 to 144,000, and daily replication jobs surged from 10,000 to 374,000. This growth was driven by an active-passive architecture that concentrated ~90% of writes in the primary region, onboarding all Hive datasets into HiveSync, and an upcoming cloud migration. Under that load, replication latency SLAs (P100 under 4 hours, P99.9 under 20 minutes) were slipping.&lt;/p&gt;
&lt;p&gt;To fix this, Uber made four targeted improvements to DistCp. First, they offloaded two resource-intensive phases—Copy Listing and Input Splitting—from the central HiveSync server to the YARN Application Master, cutting job submission latency by 90%. Second, they parallelized Copy Listing across a thread pool making concurrent &lt;code&gt;namenode&lt;/code&gt; RPCs, reducing p99 latency by 60% and max latency by 75%. Third, they parallelized file concatenation inside the Copy Committer, slashing merge time by 97.29%. Finally, they enabled &amp;ldquo;Uber jobs&amp;rdquo; to run single-mapper replication tasks (which accounted for 52% of all jobs) directly inside the Application Master JVM, eliminating roughly 268,000 YARN container launches per day. Together, these optimizations increased incremental replication throughput 5x within a year and enabled Uber to migrate over 306 PB of data to the cloud.&lt;/p&gt;
&lt;h2 id="how-to-write-a-good-spec-for-ai-agents"&gt;&lt;a href="https://addyosmani.com/blog/good-spec/" rel="noopener noreferrer"&gt;How to write a good spec for AI agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani lays out a practical framework for writing specifications for AI coding agents, addressing a classic tension: a spec needs enough detail to steer the agent accurately without bloating the prompt and overwhelming the context window. Principle one is to start with a high-level vision—provide a concise objective and let the agent expand it into a detailed plan that you review and refine. Principle two is to structure the spec like a Product Requirements Document (PRD) covering six essential areas: executable commands, testing conventions, project structure, code style examples, Git workflow, and explicit boundaries. An analysis by GitHub of over 2,500 agent configuration files found that vague, high-level instructions were the single most common failure mode.&lt;/p&gt;
&lt;p&gt;Principle three is to break work into modular prompts or sub-agent tasks rather than one massive monolith, since the &amp;ldquo;curse of instructions&amp;rdquo; causes model adherence to drop sharply when too many rules compete at once. Principle four is building in quality gates: a three-tier boundary system (&amp;ldquo;Always do,&amp;rdquo; &amp;ldquo;Ask first,&amp;rdquo; and &amp;ldquo;Never do&amp;rdquo;) paired with self-verification hooks. Finally, treat the spec as a living document that gets tested and updated as the codebase evolves. The article also warns against common pitfalls like vague prompts (&amp;ldquo;build something cool&amp;rdquo;), dumping raw context without summarization, skipping human code review, and moving faster than your ability to verify.&lt;/p&gt;
&lt;h2 id="unconventional-postgresql-optimizations"&gt;&lt;a href="https://hakibenita.com/postgresql-unconventional-optimizations" rel="noopener noreferrer"&gt;Unconventional PostgreSQL Optimizations&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Haki Benita walks through three unconventional PostgreSQL optimization techniques. First is enabling &lt;code&gt;constraint_exclusion = on&lt;/code&gt; so the query planner uses table &lt;code&gt;CHECK&lt;/code&gt; constraints to skip full table scans altogether. When a user accidentally queries a value that violates a check constraint—for example, &lt;code&gt;WHERE plan = 'Pro'&lt;/code&gt; when the constraint only allows lowercase &lt;code&gt;'free'&lt;/code&gt; or &lt;code&gt;'pro'&lt;/code&gt;—PostgreSQL&amp;rsquo;s default &lt;code&gt;partition&lt;/code&gt; setting still scans the entire table (taking ~7.4 ms in the benchmark), whereas turning &lt;code&gt;constraint_exclusion&lt;/code&gt; on lets the planner prove the query cannot match any rows and return instantaneously. Because checking constraints adds planning overhead, PostgreSQL defaults to only checking them on inherited partitions and &lt;code&gt;UNION ALL&lt;/code&gt; queries, making &lt;code&gt;on&lt;/code&gt; best suited for analytics or reporting databases where users write ad-hoc queries.&lt;/p&gt;
&lt;p&gt;The second technique is indexing a lower-cardinality expression: instead of building a B-Tree index on a raw &lt;code&gt;timestamptz&lt;/code&gt; column (214 MB), indexing the truncated date via &lt;code&gt;date_trunc('day', ...)&lt;/code&gt; shrinks the index to 66 MB—over 3x smaller—and speeds up queries through page-level deduplication. Because expression indexes only kick in when queries write the exact same expression, he suggests pairing them with PostgreSQL 18&amp;rsquo;s virtual generated columns for ergonomics. The third technique enforces uniqueness on large text values like URLs using a hash index: PostgreSQL doesn&amp;rsquo;t support &lt;code&gt;UNIQUE&lt;/code&gt; hash indexes directly, but you can create an &lt;code&gt;EXCLUDE USING hash (url WITH =)&lt;/code&gt; exclusion constraint, shrinking the index from 154 MB (B-Tree) down to 32 MB—nearly 5x smaller. The trade-offs are that exclusion constraints cannot be referenced by foreign keys and do not support &lt;code&gt;ON CONFLICT (url) DO UPDATE&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="software-engineering-when-machine-writes-the-code"&gt;&lt;a href="https://www.shayon.dev/post/2026/19/software-engineering-when-the-machine-writes-code/" rel="noopener noreferrer"&gt;Software engineering when machine writes the code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shayon Mukherjee reflects on what happens to software engineering when machines write the bulk of the code. He isn&amp;rsquo;t anti-AI, but worries that in chasing raw velocity we are trading away deep system comprehension. By Jevons paradox, making a resource more efficient increases total consumption; similarly, AI won&amp;rsquo;t lead us to write less software—it will lead us to build sprawling, complex systems faster than humans can mentally absorb them. He contrasts writing code by hand—where you build a rich mental model through hundreds of micro-decisions—with reviewing AI-generated PRs, where you try to reconstruct understanding after the fact. Accepting working code without truly understanding why it works creates dangerous blind spots during 3 a.m. incidents and long-term maintenance.&lt;/p&gt;
&lt;p&gt;He is especially concerned for junior engineers: if they skip the formative struggle of implementing things from scratch, making mistakes, and debugging for hours, they may never develop the pattern recognition and architectural intuition that only come from friction. His suggested remedy is using AI as a Socratic tutor to explain concepts and trade-offs while still writing the implementation yourself. He also proposes a zoned approach to codebases: core domain logic demands deep human ownership with minimal AI generation, standard application code can lean on AI with thorough review, and pure boilerplate can be delegated almost entirely to AI.&lt;/p&gt;
&lt;h2 id="a-guide-to-effective-prompt-engineering"&gt;&lt;a href="https://blog.bytebytego.com/p/a-guide-to-effective-prompt-engineering" rel="noopener noreferrer"&gt;A Guide to Effective Prompt Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteByteGo presents a practical guide to prompt engineering—crafting instructions that reliably elicit the right output from large language models. Anyone can type a prompt, but getting consistent, high-quality results is a distinct engineering skill. A well-structured prompt typically combines four elements: task description, background context, illustrative examples, and specific output constraints. Modern LLM APIs also split instructions into a system prompt (defining role, tone, and guardrails) and a user prompt (the actual task). Clarity is paramount: state exactly what you want, define the output format explicitly, and never assume the model can read your mind; supplying sufficient context also dramatically reduces hallucinations. The post notes how models use in-context learning from examples in the prompt, and points out the &amp;ldquo;lost in the middle&amp;rdquo; effect where models pay closer attention to instructions at the very beginning and end of a long prompt.&lt;/p&gt;
&lt;p&gt;Five core prompting techniques are covered: zero-shot prompting (direct instructions with no examples, suited for simple tasks); few-shot prompting (providing two to five input–output examples to demonstrate the exact pattern and format); chain-of-thought prompting (asking the model to reason step by step before answering complex logic or math problems); role prompting (assigning a persona to anchor perspective and depth); and prompt chaining (breaking a complex workflow into a sequence of focused prompts). On best practices, iterate systematically, version-control your prompts, and test against diverse inputs and edge cases while avoiding vague phrasing, bloated walls of text, and unspecified output formats.&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 #48</title><link>https://miti99.com/en/post/2025/08/07/</link><pubDate>Thu, 07 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/07/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #48.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="todos-aren"&gt;&lt;a href="https://sophiebits.com/2025/07/21/todos-arent-for-doing" rel="noopener noreferrer"&gt;TODOs aren&amp;rsquo;t for doing&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sophie Alpert pushes back against two common policies for handling &lt;code&gt;TODO&lt;/code&gt; comments in codebases: requiring every &lt;code&gt;TODO&lt;/code&gt; to have a corresponding ticket in an issue tracker, or automatically deleting &lt;code&gt;TODO&lt;/code&gt;s that have sat around too long. In her view, only urgent &lt;code&gt;TODO&lt;/code&gt;s like &amp;ldquo;Finish writing the second half of this file so next week&amp;rsquo;s launch doesn&amp;rsquo;t crash&amp;rdquo; actually need to be tracked as tasks. The most valuable &lt;code&gt;TODO&lt;/code&gt;s aren&amp;rsquo;t meant to be done at all: they document edge cases and design hints, such as &amp;ldquo;if the user clicks this button three times in a row, the event handler will break&amp;rdquo;—a rare scenario the author noticed but didn&amp;rsquo;t need to fix yet.&lt;/p&gt;
&lt;p&gt;The real value of these comments is preserving the original author&amp;rsquo;s train of thought and context. When another developer reads the code later and wonders whether a structure could be written differently, a well-placed &lt;code&gt;TODO&lt;/code&gt; answers that question immediately, giving them the confidence to refactor instead of hesitating out of fear that the original author knew something they didn&amp;rsquo;t. For junior developers, this is a helpful perspective: treat &lt;code&gt;TODO&lt;/code&gt;s as small notes left for future readers rather than a backlog of chores that must be swept clean.&lt;/p&gt;
&lt;h2 id="automating-away-claude"&gt;&lt;a href="https://writeaheadblogg.ing/posts/claude-hooks-auto-fix-trailing-whitespace/" rel="noopener noreferrer"&gt;Automating Away Claude&amp;rsquo;s Bad Habits with Hooks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Claude Code frequently leaves trailing whitespace at the end of lines because language models generate text token by token without &amp;ldquo;seeing&amp;rdquo; the rendered formatting, and telling it not to in instructions is unreliable. Brian Cosgrove solves this cleanly using hooks—user-defined shell commands that run automatically at specific points in Claude&amp;rsquo;s workflow loop. Specifically, he configures a &lt;code&gt;PostToolUse&lt;/code&gt; hook that runs RuboCop with the &lt;code&gt;Layout/TrailingWhitespace&lt;/code&gt; rule every time Claude edits a Ruby file. He deliberately chooses a language-aware linter over a generic &lt;code&gt;sed&lt;/code&gt; or regex replacement, which could corrupt binary files or break trailing-space line breaks in Markdown and other whitespace-sensitive formats.&lt;/p&gt;
&lt;p&gt;Beyond &lt;code&gt;PostToolUse&lt;/code&gt;, hooks also support &lt;code&gt;PreToolUse&lt;/code&gt;, &lt;code&gt;Notification&lt;/code&gt;, &lt;code&gt;Stop&lt;/code&gt;, and &lt;code&gt;SubagentStop&lt;/code&gt; events, allowing you to inspect, transform, or block actions at various stages: running linters, executing tests, verifying that code compiles, or preventing risky operations like committing untested code. The author also warns that hooks run with the user&amp;rsquo;s full permissions, so you should read every command carefully before adding it, as a malicious hook could compromise your system during routine Claude operations. This is a practical example of turning AI&amp;rsquo;s &amp;ldquo;bad habits&amp;rdquo; into automatically corrected steps rather than repeating yourself in prompts.&lt;/p&gt;
&lt;h2 id="docs-for-ai-agents"&gt;&lt;del&gt;&lt;a href="https://technicalwriting.dev/ai/agents/" rel="noopener noreferrer"&gt;Docs for AI Agents&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Kayce Basques shares thoughts on documentation written for AI agents and how it relates to internal technical documentation that engineering teams write for themselves, such as RFCs or build guides. Agent docs make agent outputs more consistent, aligned with project conventions, and accurate: when first using Claude Code, the author noticed the tool correctly guessed the site used Sphinx built with Bazel, but ran the wrong command; adding the right command to the agent doc fixed it permanently. Each tool looks for its own root file (&lt;code&gt;CLAUDE.md&lt;/code&gt; for Claude Code, &lt;code&gt;GEMINI.md&lt;/code&gt; for Gemini CLI, &lt;code&gt;AGENTS.md&lt;/code&gt; for Codex CLI), and the file&amp;rsquo;s contents are injected verbatim into the system prompt on every model call, so it needs to stay concise. Subdirectory and user-level agent docs are also supported.&lt;/p&gt;
&lt;p&gt;The big question is whether to maintain two separate sets of documentation. Reasons to keep them separate include different writing styles, agents&amp;rsquo; need for brevity versus humans&amp;rsquo; need for comprehensive context, and the fact that models already know many general concepts; the reason to merge them is avoiding duplication and drift over time. The author suggests several approaches: using AI itself to keep the two sets in sync, merging them into one, embedding agent instructions as comments inside human docs and extracting them via a script, using &lt;code&gt;@&lt;/code&gt; imports to pull in files like &lt;code&gt;CONTRIBUTING.md&lt;/code&gt;, or using pre-merge checks to enforce that related files are updated together.&lt;/p&gt;
&lt;h2 id="developers-are-using-these-ai-agents-to-build-software-10x-faster"&gt;&lt;a href="https://dev.to/therealmrmumba/developers-are-using-these-ai-agents-to-build-software-10x-faster-efn" rel="noopener noreferrer"&gt;Developers Are Using These AI Agents to Build Software 10x Faster&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article rounds up AI coding agents that are helping developers move significantly faster in 2025, with brief descriptions of how each tool automates parts of the workflow. The list includes Cursor (an AI-first editor with real-time suggestions), Emergent (multi-agent orchestration for generating features and preparing deployments), DeepDocs (automatically syncing GitHub documentation with code changes via GitHub Actions), Continue.dev (an open-source platform for building custom AI-integrated IDEs), ByteDance&amp;rsquo;s Trae (end-to-end web app development with multimodal input support), Cline (a VS Code extension built for large codebases), Google&amp;rsquo;s Gemini CLI and Sourcegraph&amp;rsquo;s Cody CLI (in-terminal assistants), OpenHands (an autonomous open-source agent framework), Replit AI (a cloud environment with built-in database support), Augment Code (an IDE-integrated agent that can run code and spot performance issues), and CodeRabbit (automated GitHub pull request reviews).&lt;/p&gt;
&lt;p&gt;The central message is that these agents take over repetitive tasks, enabling faster delivery and cleaner code for solo developers, startups, and large enterprises alike. The author concludes that adopting a few such tools in your 2025 workflow is shifting from a productivity boost to a necessity. For newer developers, it serves as a handy survey for picking tools to try out.&lt;/p&gt;
&lt;h2 id="what-kind-of-work-i-want-in-2025"&gt;&lt;a href="https://www.seangoedecke.com/my-engineering-values-2025/" rel="noopener noreferrer"&gt;What kind of work I want (in 2025)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke candidly lists the kind of engineering work he wants in 2025—a great template for any engineer thinking deliberately about their career path. On work environment, he prioritizes fully remote roles with occasional in-person gatherings over mandatory hybrid policies; he prefers low-process management that trusts engineers without heavy scrum ceremonies, and wants to stay based in Australia. On projects, he looks for work at the core of the business that leadership cares about, including unglamorous systems like billing; he excels at getting things done inside large monolithic codebases and prefers iteratively improving an imperfect solution over polishing indefinitely.&lt;/p&gt;
&lt;p&gt;He targets large US tech companies or comparable Australian firms, avoids startups, wants to work on large-scale systems people have heard of, and is currently very interested in AI both as a tool and as a transformative technology. His ethical boundaries are explicit: no proof-of-work blockchain, online gambling, autonomous weapons, or predatory financial services, alongside a strong preference for diverse teams. The biggest shift since 2021 is abandoning the idea of building a safe career maintaining legacy systems—since those roles are prime targets during layoffs—in favor of high-priority initiatives; his expectations of managers have also simplified down to competence and honesty.&lt;/p&gt;
&lt;h2 id="welcoming-the-next-generation-of-programmers"&gt;&lt;a href="https://lucumr.pocoo.org/2025/7/20/the-next-generation/" rel="noopener noreferrer"&gt;Welcoming The Next Generation of Programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Armin Ronacher, creator of Flask, argues that AI coding tools will expand rather than shrink the programming profession: AI will not reduce the number of programmers—in fact, the opposite seems much more likely. His definition is deliberately inclusive: &amp;ldquo;If you create a program, whether by hand or with the help of an agent, you are a programmer.&amp;rdquo; He sees growing consensus that newcomers will and should write AI-generated code, and points to the Python community&amp;rsquo;s tradition of openness—through initiatives like PyLadies—as a model for welcoming this new wave of learners.&lt;/p&gt;
&lt;p&gt;The challenge he highlights is that whereas new programmers used to learn alongside human mentors, those learning through ChatGPT may lack human connection altogether. Rather than looking down on &amp;ldquo;vibe coders,&amp;rdquo; the community should actively mentor them and build pathways into the broader ecosystem, so tooling companies don&amp;rsquo;t turn them into dependent users with no incentive to learn deeper fundamentals. The goal is to turn isolated human-AI interactions into a shared learning journey that helps the next generation develop sound software engineering practices.&lt;/p&gt;
&lt;h2 id="pattern-matching-across-different-languages"&gt;&lt;a href="https://blog.frankel.ch/pattern-matching-different-languages/" rel="noopener noreferrer"&gt;Pattern-matching across different languages&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nicolas Fränkel compares how pattern matching is supported across Java, Scala, Kotlin, Python, and Rust, starting from the traditional C-style &lt;code&gt;switch&lt;/code&gt; statement. Every example uses the same geometric hierarchy of &lt;code&gt;Rectangle&lt;/code&gt; and &lt;code&gt;Circle&lt;/code&gt; with a perimeter function, combining type matching and pattern guards to detect when a rectangle is a square. Java 23 uses &lt;code&gt;switch&lt;/code&gt; expressions with arrow syntax, supporting type patterns and &lt;code&gt;when&lt;/code&gt; guards, selecting the first matching branch. Kotlin uses &lt;code&gt;when&lt;/code&gt; expressions and &lt;code&gt;is&lt;/code&gt; checks, with the article&amp;rsquo;s example enabling an experimental flag for guards. Python added the &lt;code&gt;match&lt;/code&gt; statement in 3.10, which destructures attributes by name very cleanly. The Rust translation uses trait objects and downcasting, making it more verbose; the author explicitly notes that this setup is not idiomatic and does not reflect Rust&amp;rsquo;s true pattern-matching strengths.&lt;/p&gt;
&lt;p&gt;Among the languages compared, Scala pioneered pattern matching early on and still stands out for destructuring and extracting class fields directly inside a match arm without extra variable bindings; it inspired the other languages, though the author notes Java and Kotlin have largely closed the gap in this example. He concludes that pattern matching combined with destructuring makes code significantly more readable and maintainable—a technique well worth learning in any modern language.&lt;/p&gt;
&lt;h2 id="a-real-world-ai-coding-case-sample"&gt;&lt;a href="https://blog.korny.info/2025/07/18/a-real-world-ai-coding-case-sample" rel="noopener noreferrer"&gt;A real-world AI coding case sample&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Korny shares a real-world walkthrough of using Claude to add a feature to an ASP.NET Core application: publishing a &lt;code&gt;PersonBusinessLink&lt;/code&gt; event to Kafka with a &amp;ldquo;linked&amp;rdquo; or &amp;ldquo;unlinked&amp;rdquo; type whenever a contact person is associated with or removed from a business. The project uses monadic &lt;code&gt;Result&lt;/code&gt; and &lt;code&gt;Option&lt;/code&gt; return types, domain-driven design with repositories and services, and Kafka running in Docker with Testcontainers for integration tests. Rather than letting Claude run on autopilot, he guided it step by step: first asking it to identify existing patterns in the codebase, then requesting the feature with a detailed spec, reviewing every change before committing, and stepping in when Claude picked the wrong Kafka topic or partition key. When Claude struggled with the monadic control flow, he debugged it himself rather than letting it spin its wheels.&lt;/p&gt;
&lt;p&gt;Claude did well at learning test conventions from existing files and handling straightforward boilerplate, but needed course correction on architectural decisions and couldn&amp;rsquo;t resolve deeper bugs on its own. The author&amp;rsquo;s advice is to treat AI like a very fast, enthusiastic, but naive junior developer: useful when carefully guided, but not reliably autonomous on complex tasks. He also raises serious concerns about the environmental cost, unsustainable venture funding, and the motives of the companies behind these tools.&lt;/p&gt;
&lt;h2 id="clowns-to-the-left-of-me"&gt;&lt;a href="https://blog.korny.info/2025/07/19/clowns-to-the-left-of-me" rel="noopener noreferrer"&gt;Clowns to the Left of Me&amp;hellip;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Korny reflects on the polarized debate around AI coding tools and places himself squarely in the middle, echoing the song &amp;ldquo;Stuck in the Middle With You&amp;rdquo; referenced in the title. On one side are the hype evangelists claiming 50x productivity gains, advocating coding without regard for security, and getting swept up in the thrill of rapid code generation—leading them to overstate capabilities and downplay risks. On the other side are the skeptics, who are right to push back against exaggerated claims, but sometimes treat preliminary studies as definitive proof and dismiss the tools after a few low-context tries.&lt;/p&gt;
&lt;p&gt;The author takes a pragmatic view: the tools genuinely help him in real work—such as writing Python scripts, generating diagrams for documentation, or spotting security vulnerabilities—but require careful prompting, output verification, and choosing the right use cases. What matters is learning when and how to use them effectively; he recommends following balanced practitioners like Simon Willison and Birgitta Böckeler. Still, he stresses that we shouldn&amp;rsquo;t ignore systemic issues: massive energy consumption, environmental harm tied to fossil fuels, unsustainable VC subsidies, and power concentrated in the hands of controversial tech leaders. Bottom line: evaluate the tools through evidence and hands-on experience.&lt;/p&gt;
&lt;h2 id="improving-the-prompt-to-the-ai-to-get-better-code"&gt;&lt;a href="https://blog.vanillajava.blog/2025/07/improving-prompt-to-ai-to-get-better.html" rel="noopener noreferrer"&gt;Improving the prompt to the AI to get better code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author of Vanilla Java Blog experiments with optimizing a Java method that formats a time zone offset from milliseconds into ISO 8601 (&lt;code&gt;±hh&lt;/code&gt;, &lt;code&gt;±hhmm&lt;/code&gt;, or &lt;code&gt;±hhmmss&lt;/code&gt;) while allocating as few objects as possible for low-latency applications. Initial &amp;ldquo;one-shot&amp;rdquo; prompts produced wildly uneven results across models. A refined prompt spelled out explicit constraints: use a &lt;code&gt;ThreadLocal&lt;/code&gt; buffer, stick to simple arithmetic, avoid &lt;code&gt;String.format&lt;/code&gt; and object allocations, and return an &lt;code&gt;intern()&lt;/code&gt;ed string. This guidance helped weaker models improve dramatically.&lt;/p&gt;
&lt;p&gt;Seven systems were evaluated: Gemini 2.5 Pro, o3-pro, o4-mini-high, Claude 4, Grok 3 Think, GitHub Copilot with GPT-4.1, and Microsoft Copilot in Think Deeper mode. Response times ranged from a few seconds to 18 minutes without a corresponding jump in quality. Most solutions used a &lt;code&gt;ThreadLocal&lt;/code&gt; &lt;code&gt;char[]&lt;/code&gt; buffer and manipulated digits directly, but not a single model suggested using &lt;code&gt;byte[]&lt;/code&gt;, even though modern Java strings store characters internally as a byte array. The takeaways: detailed prompts narrow the gap between models, longer thinking time does not guarantee better code, and AI can still miss specialized performance tricks; the best approach is testing multiple models and iterating on the prompt rather than asking just once.&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 #39</title><link>https://miti99.com/en/post/2025/07/29/</link><pubDate>Tue, 29 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/29/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #39.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="100-senior-java-developer-interview-questions-and-answers--2025-edition"&gt;&lt;a href="https://dev.to/haraf/100-senior-java-developer-interview-questions-and-answers-2025-edition-4f6n" rel="noopener noreferrer"&gt;100+ Senior Java Developer Interview Questions and Answers – 2025 Edition&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DEV Community guide compiles over 100 interview questions and answers aimed at senior Java developer roles in 2025, organized into five tracks. The Core Java section covers 25 questions split evenly across multithreading and concurrency (deadlocks, the &lt;code&gt;volatile&lt;/code&gt; keyword), collections and their internal implementations, object-oriented design principles, memory management (garbage collection, heap layout), and Java 8+ features like functional interfaces, streams, and &lt;code&gt;Optional&lt;/code&gt;. The Spring Boot and microservices section adds another 25 questions covering auto-configuration, bean lifecycles, inter-service communication (REST, gRPC, message queues), security with JWT, OAuth2, and role-based access control, observability tools like Sleuth, Zipkin, and Prometheus, and deployment and fault-tolerance strategies.&lt;/p&gt;
&lt;p&gt;The remaining three sections feature 20 questions on design patterns (Singleton, Factory, Strategy, Builder, Observer, Proxy, Adapter), 15 on algorithms and data structures (complexity analysis, sorting, searching, graph traversal, Tries, LRU caches), and 15 on SQL and databases (&lt;code&gt;JOIN&lt;/code&gt;s, normalization, indexing, ACID properties, and consistency in distributed systems). What makes the list useful is its focus on real-world engineering scenarios rather than trivia syntax. For junior and mid-level developers, it serves as a solid roadmap for spotting knowledge gaps on the way to senior roles.&lt;/p&gt;
&lt;h2 id="the-prompt-engineering-playbook-for-programmers"&gt;&lt;a href="https://addyo.substack.com/p/the-prompt-engineering-playbook-for" rel="noopener noreferrer"&gt;The Prompt Engineering Playbook for Programmers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani (Google) distills practical techniques for prompting AI coding assistants around seven core principles: provide rich context (language, framework, error messages, expected behavior), state specific goals, break large tasks into smaller steps, include input/output examples (few-shot prompting), assign a role such as code reviewer or security specialist, iterate across multiple turns, and keep your own codebase clean and well-named. His baseline rule is to assume the AI knows nothing about your project beyond what you explicitly put in front of it. For debugging, a reliable template is &amp;ldquo;the code is supposed to do X, but instead does Y when given input Z&amp;rdquo;; in the post&amp;rsquo;s example, pairing the error trace with sample data and expected output lets the AI immediately spot an off-by-one loop condition.&lt;/p&gt;
&lt;p&gt;When refactoring, spell out the exact goal—readability, performance, deduplication, or preserving existing error behavior—rather than just saying &amp;ldquo;refactor this.&amp;rdquo; For new features, start from a high-level outline and build incrementally: scaffold the component first, add state management next, and wire up the API last. Common pitfalls include vague prompts, cramming too many requirements into a single turn, and omitting success criteria. Osmani advises treating AI like an eager junior developer: give clear direction, iterate patiently, and ask it to explain its reasoning so you solve the problem and learn at the same time.&lt;/p&gt;
&lt;h2 id="why-your-ai-coding-assistant-keeps-doing-it-wrong-and-how-to-fix-it"&gt;&lt;a href="https://blog.thepete.net/blog/2025/05/22/why-your-ai-coding-assistant-keeps-doing-it-wrong-and-how-to-fix-it/" rel="noopener noreferrer"&gt;Why Your AI Coding Assistant Keeps Doing It Wrong, and How To Fix It&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Pete Hodgson argues that instead of debating whether &amp;ldquo;AI writes good code,&amp;rdquo; we should ask which kinds of tasks AI excels at and which ones to avoid handing it. AI coding assistants have a peculiar skill profile: they write implementation code like a senior engineer but make design decisions like a novice, and they permanently operate like a teammate &amp;ldquo;in their first hour on the job,&amp;rdquo; lacking knowledge of your codebase, team conventions, or domain context. To evaluate whether a task is a good fit, Hodgson proposes a two-axis matrix: solution space (from narrow, where there is only one obvious approach like removing a feature flag, to wide, where many reasonable designs exist like supporting multi-image uploads) and context required (relying on tacit team knowledge vs. information that can be stated explicitly). AI performs best when the solution space is narrow and the context is explicit, because wide solution spaces make it hard for the model to guess the &amp;ldquo;right&amp;rdquo; local convention.&lt;/p&gt;
&lt;p&gt;That framework points to two levers. To narrow the solution space, give specific implementation instructions instead of letting the AI invent the plan, and break larger problems into smaller steps. To supply missing context, state requirements explicitly in the prompt, use memory or rules files, let the agent search the codebase and read docs, and connect MCP servers to database schemas or issue trackers. In short, shape the work to play to AI&amp;rsquo;s strengths rather than expecting the tool to adapt on its own.&lt;/p&gt;
&lt;h2 id="why-ai-agents-need-a-new-protocol"&gt;&lt;a href="https://glama.ai/blog/2025-06-06-mcp-vs-api" rel="noopener noreferrer"&gt;Why AI Agents Need a New Protocol&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This Glama.ai post explains why AI agents benefit from the Model Context Protocol (MCP) rather than relying solely on traditional HTTP APIs. The core premise is that HTTP APIs evolved to serve human developers and browser apps, not autonomous agents. MCP enforces consistency at the protocol layer itself, whereas OpenAPI merely documents existing APIs in all their idiosyncrasies; as the author puts it, you cannot fix structural inconsistency by writing better documentation. From there, the post highlights five practical differences: MCP lets agents query a server&amp;rsquo;s capabilities dynamically at runtime instead of relying on static docs; with raw APIs, models must construct HTTP requests themselves and frequently hallucinate paths or parameters, whereas with MCP the model simply selects a tool and deterministic code handles the underlying call; MCP treats bidirectional communication as a first-class primitive; each MCP tool maps to a complete user intent rather than scattering a workflow across multiple low-level endpoints; and MCP servers can run as local processes over &lt;code&gt;stdio&lt;/code&gt; with no network layer required.&lt;/p&gt;
&lt;p&gt;The author also points to the long-term payoff of standardization: models only need to learn one uniform interaction pattern instead of thousands of bespoke API dialects. The takeaway isn&amp;rsquo;t that MCP replaces HTTP APIs, but that they belong side by side—keeping APIs for developers while adding MCP as a dedicated integration layer for AI agents.&lt;/p&gt;
&lt;h2 id="understanding-logical-replication-in-postgres"&gt;&lt;a href="https://www.springtail.io/blog/postgres-logical-replication" rel="noopener noreferrer"&gt;Understanding logical replication in Postgres&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Garth Goodson, CTO of Springtail, walks through how logical replication works in PostgreSQL—replicating data at the level of logical row changes rather than copying raw physical disk blocks. Its foundation is the Write-Ahead Log (WAL): every modification is written to an append-only log before touching data files, with each record assigned a unique Log Sequence Number (LSN). The source database defines a &lt;code&gt;publication&lt;/code&gt; specifying which tables or schemas to replicate, and the target creates a &lt;code&gt;subscription&lt;/code&gt; to consume them. A replication slot tracks which WAL records have been sent and acknowledged; only WAL segments older than the replica&amp;rsquo;s confirmed flush position can be recycled, preventing data loss at the cost of requiring careful disk-space monitoring if a subscriber falls behind. Finally, logical decoding and output plugins translate raw WAL records into a consumable format; the default &lt;code&gt;pgoutput&lt;/code&gt; plugin emits two message types: &lt;code&gt;XLogData&lt;/code&gt; carrying the actual row changes and &lt;code&gt;KeepAlive&lt;/code&gt; heartbeats to maintain the connection.&lt;/p&gt;
&lt;p&gt;Logical replication is well suited for high availability, scaling out read queries, disaster recovery, and running analytical queries without bogging down the primary database. However, it comes with important caveats: it does not automatically replicate DDL changes such as schema migrations, index builds, or sequence updates; it lags behind physical replication under heavy write throughput; it requires more operational setup; and replicating &lt;code&gt;UPDATE&lt;/code&gt; or &lt;code&gt;DELETE&lt;/code&gt; operations requires tables to have a primary key or an explicit replica identity (with &lt;code&gt;REPLICA IDENTITY FULL&lt;/code&gt; as a fallback).&lt;/p&gt;
&lt;h2 id="one-man-armies"&gt;&lt;a href="https://quarter--mile.com/One-Man-Armies" rel="noopener noreferrer"&gt;One Man Armies&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This short essay on Quarter Mile opens with a striking observation: human productivity varies wildly, and projects many assume would require a full team and $5 million are sometimes built by a single obsessed, hardworking individual. To make the point, the author lists landmark works created (almost) entirely solo: Eric Barone building &lt;em&gt;Stardew Valley&lt;/em&gt; across 70-hour weeks for 4.5 years, Markus Persson writing &lt;em&gt;Minecraft&lt;/em&gt; in 2 years, John Resig creating jQuery, Chris Sawyer writing &lt;em&gt;RollerCoaster Tycoon&lt;/em&gt; in assembly, Chris Hunt spending 12 years on the RPG &lt;em&gt;Kenshi&lt;/em&gt;, Linus Torvalds starting Linux, and Donald Knuth writing &lt;em&gt;The Art of Computer Programming&lt;/em&gt;. The list stretches well beyond software too: Ada Lovelace&amp;rsquo;s first computer program, Einstein&amp;rsquo;s general relativity, Antoni Gaudí&amp;rsquo;s 40+ years on the Sagrada Família, Marie Tharp&amp;rsquo;s first scientific map of the Atlantic ocean floor, and Karlheinz Stockhausen&amp;rsquo;s nearly 30-hour &lt;em&gt;Licht&lt;/em&gt; seven-opera cycle.&lt;/p&gt;
&lt;p&gt;The author leaves readers to draw their own conclusions, offering just one gentle nudge: if general relativity, an entire cathedral, a 29-hour opera cycle, and billion-dollar video games can be brought into the world by one person, your own ambitious, seemingly far-fetched ideas probably aren&amp;rsquo;t too big either—and if you care about them enough, they are worth trying.&lt;/p&gt;
&lt;h2 id="what"&gt;&lt;a href="https://rdel.substack.com/p/rdel-96-whats-the-relationship-between" rel="noopener noreferrer"&gt;What&amp;rsquo;s the relationship between developer seniority and code refactoring?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In the RDEL (Research-Driven Engineering Leadership) newsletter, Lizzie Matusov summarizes a study examining how developer seniority relates to code refactoring. Researchers analyzed 800 open-source Java projects on GitHub, mining over 700,000 refactoring operations across 111,884 commits, measuring seniority via each contributor&amp;rsquo;s Developer Commit Ratio, and using machine learning models to classify the motivation behind each refactoring. They found that the top 5% most senior contributors performed an average of 11.14 refactorings compared to 3.57 among everyone else, and applied a wider variety of refactoring techniques. Most refactorings happened while implementing new features or fixing bugs rather than as standalone cleanup, and that motivation held steady across seniority levels. Notably, the most senior developers were actually &lt;em&gt;less&lt;/em&gt; likely to document their refactorings in commit messages than less experienced contributors.&lt;/p&gt;
&lt;p&gt;From those findings, the post offers three takeaways for engineering leaders. First, encourage engineers at all levels to participate in refactoring through pair programming and shared design principles. Second, make refactoring work visible by recognizing it in retrospectives and promotion criteria. Third, standardize how refactorings are documented using lightweight commit-message prompts and code-review guidelines that apply equally to everyone, regardless of seniority.&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 #38</title><link>https://miti99.com/en/post/2025/07/28/</link><pubDate>Mon, 28 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/28/</guid><description>&lt;p&gt;&lt;em&gt;Since I still haven&amp;rsquo;t finished my task with &lt;del&gt;Claude Code + Serena MCP&lt;/del&gt; from yesterday&amp;rsquo;s post, today we&amp;rsquo;re back to our boring AI-powered Newsletter series!! Enjoy Newsletter #38 hehe :&amp;gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="9-lessons-from-cursor"&gt;&lt;a href="https://byteatatime.dev/posts/cursor-prompt-analysis/" rel="noopener noreferrer"&gt;9 Lessons From Cursor&amp;rsquo;s System Prompt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteAtATime pointed Cursor at a custom API endpoint (a local ngrok tunnel) to capture the raw requests the editor sends to the model, dissecting the system prompt for Agent mode running on GPT-4.1 and extracting nine prompt-engineering lessons. First, Cursor defines the persona sharply: the AI is a pair-programming assistant operating inside Cursor as an autonomous agent. Roughly 1,250 tokens of instructions are organized into XML-tagged blocks like &lt;code&gt;&amp;lt;communication&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;tool_calling&amp;gt;&lt;/code&gt;, and &lt;code&gt;&amp;lt;making_code_changes&amp;gt;&lt;/code&gt; so the model doesn&amp;rsquo;t lose track of directives buried mid-prompt. The prompt repeatedly pushes autonomy: keep going until the user&amp;rsquo;s request is completely resolved, look up information with tools rather than asking the user, and plan before acting. It also tells the model never to mention internal tool names to the user, alongside practical guardrails like not generating long hashes and not attempting to fix linter errors more than three times on the same file.&lt;/p&gt;
&lt;p&gt;Most interestingly, Cursor sends two separate user-role messages: the first carries the user&amp;rsquo;s custom rules, and the second holds the actual query wrapped in rich context including web search results, file contents, and IDE state. As the author sums it up, context is &amp;ldquo;king, queen, and the entire royal court&amp;rdquo;: the more directly relevant information you pack into the prompt, the better the model performs. The final two lessons come from tool design: the file-reading tool returns only 200 to 250 lines per call to protect the context window, while terminal command outputs append stateful metadata like the current working directory so subsequent tool calls stay accurate.&lt;/p&gt;
&lt;h2 id="my-ai-skeptic-friends-are-all-nuts"&gt;&lt;a href="https://fly.io/blog/youre-all-nuts/" rel="noopener noreferrer"&gt;My AI Skeptic Friends Are All Nuts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas Ptacek (Fly.io) writes a deliberately provocative piece aimed at his AI-skeptic friends: even if LLM progress froze today, it would still be the second most important shift of his career. In his view, most dismissals are anchored in an outdated workflow—asking ChatGPT a question and pasting the snippet into an editor—whereas serious users now work with agents that read project files directly, run Unix tools, interact with Git, run linters, compile, execute tests, and iterate on the output. Because of that feedback loop, he argues, &amp;ldquo;hallucination&amp;rdquo; is largely a solved problem in practice: when an LLM invents a nonexistent function, the agent sees the compiler error and fixes it on the next turn. LLMs can handle the bulk of tedious code, freeing developers to spend their energy on the parts that truly matter.&lt;/p&gt;
&lt;p&gt;Ptacek addresses the remaining objections one by one. You are still responsible for whatever you merge to &lt;code&gt;main&lt;/code&gt;, so review AI-generated code just as you would a colleague&amp;rsquo;s. &amp;ldquo;Mediocre&amp;rdquo; code isn&amp;rsquo;t a dealbreaker because most code doesn&amp;rsquo;t need to be art, and LLMs actually raise the quality floor. LLMs struggling with Rust is mostly a tooling problem today, whereas Go pairs remarkably well with agents. On the craftsmanship argument, he reminds readers that professional developers are paid to solve real problems for people with code, not to act as artisanal woodworkers in their day jobs. He readily concedes that LLMs may shrink software job headcount, and ends by noting that his skeptic friends are sharp engineers—once they actually try coding agents, they&amp;rsquo;ll be even more effective with them than everyone else.&lt;/p&gt;
&lt;h2 id="claude-4-best-practices"&gt;&lt;a href="https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices" rel="noopener noreferrer"&gt;Claude 4 Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is Anthropic&amp;rsquo;s official prompt-engineering guide for Claude models, originally written for Claude 4 and since updated for newer generations. The foundational rule is to write clear, explicit instructions: treat Claude like a brilliant new hire who has zero context on your team&amp;rsquo;s norms. If you want &amp;ldquo;above and beyond&amp;rdquo; output, ask for it explicitly—for example, instead of just saying &amp;ldquo;Create an analytics dashboard,&amp;rdquo; add &amp;ldquo;Include as many relevant features and interactions as possible.&amp;rdquo; Explaining the &lt;em&gt;why&lt;/em&gt; behind a constraint helps Claude generalize toward your real goal; wrap few-shot examples in &lt;code&gt;&amp;lt;example&amp;gt;&lt;/code&gt; tags, and separate instructions, context, and input data with XML tags. For long documents, place the reference material at the top of the prompt and the question at the very end, asking Claude to quote relevant passages before answering.&lt;/p&gt;
&lt;p&gt;To control formatting, tell Claude what to do rather than what &lt;em&gt;not&lt;/em&gt; to do—such as &amp;ldquo;write in smooth, flowing prose paragraphs&amp;rdquo; instead of &amp;ldquo;do not use markdown&amp;rdquo;—and match your prompt&amp;rsquo;s formatting style to the output style you want. The guide also covers leveraging extended thinking to reflect on results after tool calls, encouraging parallel tool execution for independent operations, and tracking state across long-running tasks. For coding specifically, instruct Claude to write general-purpose solutions that work for all valid inputs rather than hardcoding values to pass visible tests, since tests are meant to verify correctness rather than define the implementation.&lt;/p&gt;
&lt;h2 id="stop-over-thinking-ai-subscriptions"&gt;&lt;a href="https://steipete.me/posts/2025/stop-overthinking-ai-subscriptions" rel="noopener noreferrer"&gt;Stop Over-thinking AI Subscriptions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Steinberger, tired of constantly being asked how much he spends on AI, runs the numbers to show that AI subscriptions are a bargain compared to the time they save. At the time of writing (early June 2025), he calls the $200/month Claude Max 20x plan the best deal in tech: roughly 900 messages per 5-hour window, which translates to virtually unlimited Claude Code usage. Cursor Pro at $20/month includes 500 fast requests and charges $0.04 per extra request, meaning a three-hour live tutorial with over 200 requests cost him only about $8. His biggest variable expense is OpenAI&amp;rsquo;s o3 ($10 per million input tokens, $40 per million output tokens), which makes up roughly half of his total AI bill; developers on a tighter budget can route o3 through a standard ChatGPT subscription using Repo Prompt, or join Anthropic&amp;rsquo;s developer partner program for 30% off API rates. He even built a menu-bar app called Vibe Meter to track spend in real time.&lt;/p&gt;
&lt;p&gt;Addressing fears of future price hikes, Steinberger points out that per-token inference costs have dropped roughly 1,000x over two years and competition continues to drive prices down. For contractors, the math is dead simple: at an $800 day rate, saving a single afternoon a month is worth $200, meaning Claude Max pays for itself in 5 hours and Cursor in 45 minutes. His takeaway: time is the only resource you cannot replenish, and Claude Max was the cheapest way to &amp;ldquo;mint&amp;rdquo; extra working hours.&lt;/p&gt;
&lt;h2 id="tests-should-not-contain-logic"&gt;&lt;del&gt;&lt;a href="https://blog.snork.dev/posts/tests-should-not-contain-logic.html" rel="noopener noreferrer"&gt;Tests Should Not Contain Logic&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This short post makes a case for keeping logic—especially conditionals and loops—out of unit tests so that when a test fails, you can immediately rule out a bug in the test itself. The author illustrates this with a buggy FizzBuzz implementation: because it checks &lt;code&gt;n % 3&lt;/code&gt; before &lt;code&gt;n % 15&lt;/code&gt;, calling &lt;code&gt;fizzbuzz(15)&lt;/code&gt; returns &lt;code&gt;&amp;quot;fizz&amp;quot;&lt;/code&gt; instead of &lt;code&gt;&amp;quot;fizzbuzz&amp;quot;&lt;/code&gt;. If a developer tries to avoid repetitive assertions by writing a loop that computes the expected value using the exact same &lt;code&gt;if/elif&lt;/code&gt; chain, the test duplicates the production bug and passes anyway. By contrast, &amp;ldquo;obvious&amp;rdquo; flat assertions with literal expected values, like &lt;code&gt;assert fizzbuzz(15) == &amp;quot;fizzbuzz&amp;quot;&lt;/code&gt;, catch the bug immediately.&lt;/p&gt;
&lt;p&gt;To reduce repetition without sneaking logic back into tests, the author recommends parameterized (table-driven) tests: declare a list of explicit &lt;code&gt;(input, expected)&lt;/code&gt; pairs—such as &lt;code&gt;(1, &amp;quot;1&amp;quot;)&lt;/code&gt;, &lt;code&gt;(3, &amp;quot;fizz&amp;quot;)&lt;/code&gt;, &lt;code&gt;(5, &amp;quot;buzz&amp;quot;)&lt;/code&gt;, and &lt;code&gt;(15, &amp;quot;fizzbuzz&amp;quot;)&lt;/code&gt; with &lt;code&gt;@pytest.mark.parametrize&lt;/code&gt; in pytest. That keeps tests concise and readable while verifying each case independently against a concrete literal.&lt;/p&gt;
&lt;h2 id="do-you-really-know-java"&gt;&lt;a href="https://blog.jetbrains.com/idea/2025/05/do-you-really-know-java/" rel="noopener noreferrer"&gt;Do You Really Know Java?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marking Java&amp;rsquo;s 30th anniversary, this JetBrains retrospective looks back at the language&amp;rsquo;s journey. In 1991, James Gosling&amp;rsquo;s team at Sun Microsystems kicked off the Green Project to build software for consumer electronics, needing a lightweight, safe language that could run across any hardware. Originally named Oak after the tree outside Gosling&amp;rsquo;s office window, the language was renamed Java after a trademark clash—likely inspired by Java coffee. Java debuted publicly in 1995 right as the web exploded. Its standout features for the era included &amp;ldquo;write once, run anywhere&amp;rdquo; portability via the JVM, automatic garbage collection, built-in multithreading (now joined by virtual threads from Project Loom), and a sandbox security model that treated untrusted code as a potential threat.&lt;/p&gt;
&lt;p&gt;The post also traces IntelliJ IDEA&amp;rsquo;s arrival in 2001, bringing context-aware code completion, reliable automated refactorings, and real-time static analysis. In the AI era, Java 24 ships over 20 features—including the Vector API to tap specialized CPU instructions for compute-heavy workloads—alongside Projects Panama, Amber, and Valhalla and ecosystem frameworks like LangChain4j and Spring AI. As the article puts it, Java doesn&amp;rsquo;t chase hype; it quietly gets stronger where it counts. Fun closing trivia: Java&amp;rsquo;s mascot Duke was designed by Joe Palrang, who later worked on animated films like &lt;em&gt;Shrek&lt;/em&gt; and &lt;em&gt;Madagascar&lt;/em&gt;.&lt;/p&gt;
&lt;h2 id="machine-code-isn"&gt;&lt;a href="https://jimmyhmiller.com/machine-code-isnt-scary" rel="noopener noreferrer"&gt;Machine Code Isn&amp;rsquo;t Scary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jimmy Miller, who started out writing ActionScript in Flash, shares how he got over his fear of working close to the metal. Once he actually dug in, he realized that if you can make sure a JSON payload conforms to a JSON schema, you can write machine code. Machine code isn&amp;rsquo;t a single universal format—it depends on the processor&amp;rsquo;s instruction set architecture (x86-64 on most PCs, ARM on modern Macs, Raspberry Pis, and phones)—but it revolves around just three concepts: instructions, registers, and memory. On AArch64, every instruction is a 32-bit integer; an add-immediate instruction, for instance, is just a packed bit layout combining a 64-bit flag, a 12-bit immediate value, a source register, and a destination register at fixed bit offsets. Assembly like &lt;code&gt;add x1, x0, #0x2a&lt;/code&gt; is simply a human-readable shorthand for that integer, while &lt;code&gt;str&lt;/code&gt; writes a value to memory much like assigning into a giant array.&lt;/p&gt;
&lt;p&gt;x86-64 is messier because instructions have variable lengths and carry decades of &amp;ldquo;historical baggage,&amp;rdquo; yet the building blocks are the same: a REX prefix for 64-bit operations, a ModR/M byte specifying register or memory addressing, and an opcode. Miller puts those bytes together by hand to encode an instruction that loads the number 42 into the &lt;code&gt;RBX&lt;/code&gt; register. He notes there is still plenty more to learn—status flags, calling conventions, the stack—but getting a minimal program running from raw bytes dissolved the mystique and filled in foundational gaps he had previously papered over with other people&amp;rsquo;s libraries.&lt;/p&gt;
&lt;h2 id="the-art-of-sql-query-optimization"&gt;&lt;a href="https://jnidzwetzki.github.io/2025/06/03/art-of-query-optimization.html" rel="noopener noreferrer"&gt;The Art of SQL Query Optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SQL is declarative: you state &lt;em&gt;what&lt;/em&gt; result you want, and the database engine figures out &lt;em&gt;how&lt;/em&gt; to compute it. The query optimizer enumerates candidate execution plans, estimates their cost, and picks the cheapest one—for example, when a query returns most of a table, a sequential full-table scan is often faster than chasing index pointers. To visualize where PostgreSQL switches plans, Jan Nidzwetzki built Plan Explorer, an open-source tool inspired by the Picasso optimizer visualizer: it runs a parameterized query across a 2D grid of selectivity values and plots the chosen execution plan, estimated cost, actual runtime, estimated row count, and actual row count. It can run entirely in the browser via PGlite (PostgreSQL compiled to WebAssembly) or in server mode against a real PostgreSQL instance using &lt;code&gt;EXPLAIN (ANALYZE)&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;On a self-join over an indexed 100,000-row table, Plan Explorer reveals PostgreSQL switching between five distinct execution plans depending on the filter bounds. One neat detail: even when the query is written with a &lt;code&gt;LEFT JOIN&lt;/code&gt;, PostgreSQL executes an &lt;code&gt;INNER JOIN&lt;/code&gt; because a filter on the right-hand table eliminates any &lt;code&gt;NULL&lt;/code&gt;-padded rows the left join would have produced. The visualizations also expose a cardinality-estimation bug: PostgreSQL assumes two filter predicates are correlated when they are actually independent, causing estimated row counts to diverge sharply from reality—a case where extended statistics can help. Beyond the striking visual patterns, Plan Explorer is a practical workbench for anyone tuning or developing custom cost models in PostgreSQL.&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>