<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Engineering Career on miti99</title><link>https://miti99.com/en/tags/engineering-career/</link><description>Recent content in Engineering Career 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/engineering-career/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #82</title><link>https://miti99.com/en/post/2026/02/19/</link><pubDate>Thu, 19 Feb 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/02/19/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #82.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="how-the-lobsters-front-page-works"&gt;&lt;a href="https://blog.nilenso.com/blog/2026/01/20/lobsters-front-page/" rel="noopener noreferrer"&gt;How the Lobsters front page works&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Because the source code for Lobsters—the computing-focused link-aggregation community—is open source, the author dug into its front-page ranking algorithm. The core formula is &lt;code&gt;hotness = -1 × (base + order × sign + age)&lt;/code&gt;, where a more negative value ranks higher on the page. &lt;code&gt;base&lt;/code&gt; is the sum of tag modifiers (each tag carries a weight between -10 and +10; for instance, &lt;code&gt;culture&lt;/code&gt; and &lt;code&gt;rant&lt;/code&gt; are penalized), plus a &lt;code&gt;0.25&lt;/code&gt; boost if the submitter marked themselves as the article&amp;rsquo;s author. &lt;code&gt;order&lt;/code&gt; is the base-10 logarithm of story points plus comment points, meaning the jump from 0 to 100 upvotes has a much larger impact than going from 1,000 to 1,100. Comment points count for half an upvote each, are capped so they never exceed the story&amp;rsquo;s own score, and are ignored entirely when &lt;code&gt;base&lt;/code&gt; is negative—preventing low-quality flamebaits from rising on comment volume alone. The &lt;code&gt;sign&lt;/code&gt; term turns out to be effectively a no-op in practice, while &lt;code&gt;age&lt;/code&gt; is the submission timestamp divided by a 22-hour window, growing linearly and steadily overpowering the logarithmic vote score.&lt;/p&gt;
&lt;p&gt;The author finds the algorithm solid: new stories get a fair shot at visibility and nothing camps on the front page forever. Still, Lobsters&amp;rsquo; distinct character comes primarily from opinionated moderation, a narrow focus on computing, and its invite-tree membership model rather than the ranking formula itself. Even when disagreeing with the most vocal commenters, the author notes that disengaging only hands them more influence, since just a few early upvotes from active users are enough to propel a story onto the front page.&lt;/p&gt;
&lt;h2 id="software-engineers-can-no-longer-neglect-their-soft-skills"&gt;&lt;a href="https://www.qu8n.com/posts/most-important-software-engineering-skill-2026" rel="noopener noreferrer"&gt;Software engineers can no longer neglect their soft skills&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Quan argues that starting in 2026, communication has become the single most important skill for a software engineer—surpassing raw coding speed, system design, or deep mastery of a language like Rust. The reason is the rapid leap in AI coding agents: he uses Claude Code for nearly every non-trivial task and spent over $500 on usage in December alone. With Claude Opus 4.5, vanilla Claude Code out of the box handles roughly 80% of implementation work, meaning prompt tricks and custom MCP setups are no longer real differentiators. The bottleneck has shifted from implementation to specification: the clearer the spec, the better the agent satisfies both technical and business requirements—yet arriving at a clear spec is deceptively hard.&lt;/p&gt;
&lt;p&gt;In reality, tickets rarely capture the full requirements. Engineers have to ask probing questions to surface unstated assumptions stakeholders didn&amp;rsquo;t even realize they were making, facilitate trade-off discussions, push back on scope creep without damaging relationships, and exercise judgment on edge cases nobody thought to specify. Previously, an engineer with mediocre communication skills could still thrive on the strength of exceptional coding output; today, the non-coding parts of the job are mandatory. Engineers are conditioned to believe every problem has a deterministic solution and a &amp;ldquo;best practice,&amp;rdquo; whereas working with humans is messy and ambiguous. And you can&amp;rsquo;t outsource human communication to AI, because real communication requires empathy—something everyone needs more of right now.&lt;/p&gt;
&lt;h2 id="dithering---part-2"&gt;&lt;a href="https://visualrambling.space/dithering-part-2/" rel="noopener noreferrer"&gt;Dithering - Part 2&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Part two of this interactive visual series on dithering—the technique of creating the illusion of more colors than a palette actually has—focuses on ordered dithering, which uses a spatial threshold map to decide each pixel&amp;rsquo;s final color when converting grayscale images to 1-bit black and white. The author starts with basic quantization: using a single threshold collapses every shade of gray into solid black or white, whereas applying multiple thresholds across neighboring pixels turns a uniform gray region into a mix of black and white dots that preserves perceived brightness. When tiling a small threshold map across an entire image, arranging thresholds sequentially produces distracting vertical stripes because the output mirrors the map&amp;rsquo;s internal layout. A 2×2 Bayer matrix fixes this by arranging thresholds in a crosshatch pattern that distributes dots evenly; with only 4 threshold levels, however, tonal transitions still show harsh banding, which a 16-level 4×4 Bayer matrix smooths out considerably.&lt;/p&gt;
&lt;p&gt;How the threshold map is arranged defines the visual texture of the dithered image. An 8×8 Bayer matrix (64 levels) yields finer gradients with diminishing returns; a Cluster Dot matrix groups pixels into circular halftone-like dots reminiscent of vintage newsprint; and Void and Cluster—the author&amp;rsquo;s personal favorite—uses a blue-noise threshold map to produce an organic, non-repetitive texture that blends smoothly into gray. The next installment will cover error diffusion, a family of dithering algorithms that doesn&amp;rsquo;t use a threshold map at all.&lt;/p&gt;
&lt;h2 id="what-came-first-the-cname-or-the-a-record"&gt;&lt;a href="https://blog.cloudflare.com/cname-a-record-order-dns-standards/" rel="noopener noreferrer"&gt;What came first: the CNAME or the A record?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;On January 8, 2026, a memory-optimization update to Cloudflare&amp;rsquo;s &lt;code&gt;1.1.1.1&lt;/code&gt; public DNS resolver inadvertently broke DNS resolution for a subset of users. The bug lurked in the code that merges cached &lt;code&gt;CNAME&lt;/code&gt; chains when only part of a chain has expired: previously, the resolver allocated a new list, placed the &lt;code&gt;CNAME&lt;/code&gt; records first, and appended the final &lt;code&gt;A&lt;/code&gt;/&lt;code&gt;AAAA&lt;/code&gt; records at the end; to reduce allocations and copying, the new code appended the refreshed &lt;code&gt;CNAME&lt;/code&gt; records onto the end of the existing answer list. Many stub resolvers process answer records sequentially in a single pass, tracking the &amp;ldquo;current target name&amp;rdquo; and updating it only when they encounter a matching &lt;code&gt;CNAME&lt;/code&gt;—so if the &lt;code&gt;CNAME&lt;/code&gt; appears after the &lt;code&gt;A&lt;/code&gt; record, the &lt;code&gt;A&lt;/code&gt; record is skipped and the response is treated as empty. Linux&amp;rsquo;s &lt;code&gt;glibc&lt;/code&gt; (&lt;code&gt;getaddrinfo&lt;/code&gt;) hit this exact failure mode, and certain Cisco switches even entered boot loops, whereas &lt;code&gt;systemd-resolved&lt;/code&gt; was unaffected because it searches across the entire record set.&lt;/p&gt;
&lt;p&gt;The deeper root cause was a decades-old ambiguity in RFC 1034 from 1987: the spec merely says the answer is &amp;ldquo;possibly preface[d]&amp;rdquo; by &lt;code&gt;CNAME&lt;/code&gt; records, without normative &lt;code&gt;MUST&lt;/code&gt; or &lt;code&gt;SHOULD&lt;/code&gt; keywords (which RFC 2119 didn&amp;rsquo;t standardize until 1997). While the RFCs explicitly state that record order &lt;em&gt;within&lt;/em&gt; a single RRset is insignificant, they say nothing about the relative order &lt;em&gt;between&lt;/em&gt; different RRsets in the same message section—or even the order of links within a &lt;code&gt;CNAME&lt;/code&gt; chain. Cloudflare had historically placed &lt;code&gt;CNAME&lt;/code&gt;s first, but had no regression test enforcing that ordering. They rolled back the change, committed to preserving &lt;code&gt;CNAME&lt;/code&gt;-first ordering permanently, and submitted an Internet-Draft to the IETF proposing to formally require &lt;code&gt;CNAME&lt;/code&gt; records to appear in canonical chain order before final answer records.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #70</title><link>https://miti99.com/en/post/2025/12/13/</link><pubDate>Sat, 13 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #70.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-developer-productivity-paradox-why-faster-coding-doesn"&gt;&lt;a href="https://gradle.com/blog/developer-productivity-paradox-faster-coding-slower-delivery/" rel="noopener noreferrer"&gt;The developer productivity paradox: Why faster coding doesn&amp;rsquo;t mean faster software delivery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Trisha Gee (Gradle) distills a central theme from DPE Summit 2025: the developer productivity paradox. Nearly every developer now uses AI (~90%) and over 80% believe it makes them more productive, yet organizational delivery metrics have barely budged. The 2025 DORA report shows that AI is neither the problem nor the cure—it is a mirror and an amplifier of whatever strengths and weaknesses an engineering organization already has. Because AI models carry an inherent error rate, generating more code faster actually makes systems &lt;em&gt;less&lt;/em&gt; stable unless the surrounding delivery pipeline is solid enough to catch defects. Context-switching costs also eat up the time saved: every interruption takes 15–20 minutes to recover from, and AI introduces new interruptions of its own as developers verify outputs, tweak prompts, or jump between tools to debug subtle mistakes.&lt;/p&gt;
&lt;p&gt;To overcome the paradox, Gee argues for treating AI adoption as an organization-wide transformation grounded in Developer Productivity Engineering (DPE): invest in platform engineering and shared standards, strengthen rollback mechanisms, and tighten CI/CD feedback loops; shrink batch sizes, eliminate toil, and apply value-stream management; measure end-to-end flow and business outcomes rather than lines of code or pull request counts; and train engineers to critically evaluate AI-generated code instead of blindly clicking &amp;ldquo;Accept.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="what-actually-makes-you-senior"&gt;&lt;a href="https://terriblesoftware.org/2025/11/25/what-actually-makes-you-senior/" rel="noopener noreferrer"&gt;What Actually Makes You Senior&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to the author, the core skill that separates senior engineers from everyone else isn&amp;rsquo;t technical trivia, but the ability to &lt;strong&gt;reduce ambiguity&lt;/strong&gt;. A mid-level engineer can execute a well-defined spec cleanly, but when handed a vague problem like &amp;ldquo;we need to improve performance&amp;rdquo; or &amp;ldquo;users are complaining about the signup flow,&amp;rdquo; a senior engineer digs in: asking questions nobody else thought to ask, separating signal from noise, and deciding what to tackle now versus what to defer. They ask what the real problem is, who the users are and what frustrates them, which assumptions the plan depends on that might be wrong, and what the blast radius looks like if they ship and those assumptions fail. In doing so, they &lt;strong&gt;de-risk the project&lt;/strong&gt;, turning &amp;ldquo;I have no idea what this even is&amp;rdquo; into &amp;ldquo;two small well-scoped projects and one thing we shouldn&amp;rsquo;t build at all.&amp;rdquo; Done well, this work is nearly invisible—projects simply run smoothly with fewer surprises and fewer outages.&lt;/p&gt;
&lt;p&gt;The author criticizes tech hiring for fixating on keyword checklists, years of experience, and LeetCode puzzles, producing &amp;ldquo;senior&amp;rdquo; engineers who can invert a binary tree on a whiteboard but freeze in front of a half-baked spec. The good news is that reducing ambiguity isn&amp;rsquo;t an innate gift, but a skill built through practice: start with the next vague ticket in your queue and spend time clarifying it upfront instead of waiting to be spoon-fed requirements or jumping straight into code.&lt;/p&gt;
&lt;h2 id="becoming-unblockable"&gt;&lt;a href="https://www.seangoedecke.com/unblockable/" rel="noopener noreferrer"&gt;Becoming unblockable&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares practical tactics for becoming &amp;ldquo;unblockable&amp;rdquo;—always finding a way to keep moving forward when obstacles arise. First, keep more than one task in flight at a time, just like a CPU core switching threads while waiting on I/O; avoid juggling two urgent deadlines at once, and pick low-urgency background work like refactoring, performance tuning, or mandatory training rather than grabbing another feature ticket. Second, front-load the parts of a project most likely to get blocked (such as database migrations that require another team&amp;rsquo;s sign-off) or spark design debates. Be ruthless about your tooling: stick to mainstream development setups, treat a broken local environment with the same urgency as a production outage, and when you&amp;rsquo;re truly stuck locally, find workarounds like running tests in CI or deploying to a staging environment.&lt;/p&gt;
&lt;p&gt;When you hit an error coming from another team&amp;rsquo;s service, don&amp;rsquo;t immediately declare yourself blocked—go read their source code and logs yourself; today you can even point AI agents like Codex or Claude Code at their repo, which Goedecke estimates gives the right answer about a third of the time. Beyond code, build goodwill with engineers on other teams by being helpful so you have fast informal backchannels when you need a favor, and secure &amp;ldquo;air cover&amp;rdquo; from directors or VPs by aligning your projects with top company priorities.&lt;/p&gt;
&lt;h2 id="treat-test-code-like-production-code"&gt;&lt;a href="https://blog.ploeh.dk/2025/12/01/treat-test-code-like-production-code/" rel="noopener noreferrer"&gt;Treat test code like production code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mark Seemann argues that test code deserves the same care as production code: the same coding standards, readability, structure, and code-review rigor. In practice, test suites are often treated as second-class citizens—properly indented, yet full of copy-pasted duplication, commented-out &amp;ldquo;zombie&amp;rdquo; tests, and arbitrary &lt;code&gt;sleep&lt;/code&gt; calls in place of proper thread synchronization. Coding standards and design principles don&amp;rsquo;t exist to appease the compiler; they exist so humans—usually your future self—can understand and maintain the system. When a project has strong test coverage, the test suite is huge, making the DRY principle even more important: without it, a minor production API change triggers &amp;ldquo;Shotgun Surgery&amp;rdquo; across dozens of broken tests.&lt;/p&gt;
&lt;p&gt;For test-specific design questions like structure, organization, naming, and determinism, Seemann recommends &lt;em&gt;xUnit Test Patterns&lt;/em&gt; as the definitive reference. He also pushes back against the slogan that tests should be &amp;ldquo;DAMP, not DRY,&amp;rdquo; noting that descriptive, meaningful phrasing is a virtue whether code is duplicated or factored into helpers. There are still sensible exceptions, mostly around security when test code is never deployed: hardcoding dummy test passwords or skipping input validation in test helpers is fine. Platform-specific exceptions make sense too, such as relaxing &lt;code&gt;.NET&lt;/code&gt;&amp;rsquo;s &lt;code&gt;ConfigureAwait&lt;/code&gt; rule in tests or allowing orphan instances in Haskell test suites.&lt;/p&gt;
&lt;h2 id="how-good-engineers-write-bad-code-at-big-companies"&gt;&lt;a href="https://www.seangoedecke.com/bad-code-at-big-companies/" rel="noopener noreferrer"&gt;How good engineers write bad code at big companies&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke explains why big tech companies can hire armies of talented engineers and still produce terrible code. The core reason is that large companies are &lt;strong&gt;full of engineers working outside their area of expertise&lt;/strong&gt;. With average tenure hovering around one to two years and frequent reorgs shuffling teams, many services are a decade old while most code changes are made by relative newcomers—engineers within their first six months at the company, in that codebase, or in that programming language. The few long-tenured veterans who deeply understand the system can catch issues in code review, but that stewardship role is informal and they are perpetually stretched thin by their own deliverables.&lt;/p&gt;
&lt;p&gt;The typical big-company engineer is therefore a capable developer racing to hit a deadline inside an unfamiliar codebase—doing their best in an environment that isn&amp;rsquo;t set up to produce high-craft code. In Goedecke&amp;rsquo;s view, this is a deliberate executive trade-off: leadership prioritizes organizational flexibility and fungible headcount over deep codebase mastery and code quality, and individual engineers have very little power to change it. He contrasts &amp;ldquo;pure engineering&amp;rdquo; (self-contained domains like compilers, where bad code usually reflects low skill) with &amp;ldquo;impure engineering&amp;rdquo; (more like contract electrical or plumbing work under deadline pressure, where messy code is an inevitable byproduct of the environment). At big companies, bad code happens because almost everyone is perpetually working in unfamiliar territory.&lt;/p&gt;
&lt;h2 id="the-success-trap"&gt;&lt;a href="https://mikefisher.substack.com/p/the-success-trap" rel="noopener noreferrer"&gt;The Success Trap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mike Fisher explores how success can quietly narrow your freedom and options. He contrasts a waiter at a neighborhood diner—whose skills are portable enough to switch jobs or careers at any time—with a waiter at a Michelin-starred restaurant, whose mastery is far higher but whose exit options are much narrower without taking a step down. In organizational theory, the &amp;ldquo;success trap&amp;rdquo; describes becoming so good at exploiting your current strengths that you stop exploring new opportunities; it is closely related to Clayton Christensen&amp;rsquo;s &lt;em&gt;Innovator&amp;rsquo;s Dilemma&lt;/em&gt;, except the innovator&amp;rsquo;s dilemma is disruption from the outside, whereas the success trap is rot from within.&lt;/p&gt;
&lt;p&gt;Fisher illustrates this with three examples: an engineer promoted up the management ladder until he no longer built anything himself, who eventually took a pay cut at a startup just to write code again; Kodak inventing the digital camera in 1975 and shelving it to protect its film cash cow; and Radiohead deliberately reinventing their sound with &lt;em&gt;Kid A&lt;/em&gt; right after the massive success of &lt;em&gt;OK Computer&lt;/em&gt;. To escape the trap, organizations need to institutionalize curiosity through dedicated experimentation time, while individuals should regularly put themselves back in the beginner&amp;rsquo;s seat and value learning velocity over comfort. For leaders, it requires a mindset of stewardship—holding success lightly and optimizing for renewal rather than coasting on past wins—because freedom, not achievement, is the true measure of success.&lt;/p&gt;
&lt;h2 id="writing-a-good-claudemd"&gt;&lt;a href="https://www.humanlayer.dev/blog/writing-a-good-claude-md" rel="noopener noreferrer"&gt;Writing a good CLAUDE.md&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide from HumanLayer starts from a simple fact: LLMs are stateless. At the beginning of every session, a coding agent knows nothing about your repository, and &lt;code&gt;CLAUDE.md&lt;/code&gt; (or &lt;code&gt;AGENTS.md&lt;/code&gt;) is the one file injected into every conversation by default. Its job is to onboard Claude into the codebase by answering three questions: &lt;strong&gt;WHAT&lt;/strong&gt; (the tech stack and directory structure, especially in monorepos), &lt;strong&gt;WHY&lt;/strong&gt; (the purpose of each component), and &lt;strong&gt;HOW&lt;/strong&gt; (how to work in the repo—running tests, typechecks, and builds). The author notes that Claude frequently ignores &lt;code&gt;CLAUDE.md&lt;/code&gt; because Claude Code wraps it in a system reminder telling the model to ignore instructions that aren&amp;rsquo;t &amp;ldquo;highly relevant to the current task&amp;rdquo;—so the more task-specific clutter you stuff into the file, the more likely Claude is to tune the whole thing out.&lt;/p&gt;
&lt;p&gt;Key recommendations: fewer instructions are better, since frontier reasoning models reliably follow only about 150–200 instructions in total and Claude Code&amp;rsquo;s system prompt already uses ~50 of them; keep &lt;code&gt;CLAUDE.md&lt;/code&gt; under 300 lines and as short as possible (HumanLayer&amp;rsquo;s own root file is under 60 lines), containing only rules that apply to every single task. Use progressive disclosure: put workflow-specific docs in separate Markdown files and link to them from &lt;code&gt;CLAUDE.md&lt;/code&gt;, and reference &lt;code&gt;file:line&lt;/code&gt; pointers instead of pasting code snippets that quickly go stale. Never use an LLM as an expensive linter—use deterministic linters and formatters wired into hooks or slash commands instead. Finally, don&amp;rsquo;t just run &lt;code&gt;/init&lt;/code&gt; and call it a day: &lt;code&gt;CLAUDE.md&lt;/code&gt; is the highest-leverage point of the entire agent harness, so craft every line deliberately.&lt;/p&gt;
&lt;h2 id="we-should-all-be-using-dependency-cooldowns"&gt;&lt;a href="https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependency-cooldowns" rel="noopener noreferrer"&gt;We should all be using dependency cooldowns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;William Woodruff argues that dependency cooldowns are a free, low-effort, and remarkably effective defense against the vast majority of open-source supply-chain attacks. Most supply-chain attacks follow the same playbook: an attacker compromises a popular project (usually via phished credentials or a CI/CD vulnerability), publishes a malicious release to PyPI, npm, or GitHub, downstream users automatically pull the update, security researchers spot the anomaly, and the registry yanks the malicious package. While the attacker&amp;rsquo;s preparation may take weeks, the window between publishing the malicious version and the registry taking it down is almost always just a few hours to a few days. Out of ten high-profile incidents analyzed, eight had an active compromise window of under a week—the notable outlier being &lt;code&gt;xz-utils&lt;/code&gt; at roughly five weeks.&lt;/p&gt;
&lt;p&gt;A dependency cooldown simply puts a minimum waiting period between when a package version is published and when your tooling considers it eligible for installation, giving the security community time to catch compromises first. Configuring one takes just a couple of lines—such as &lt;code&gt;cooldown: default-days: 7&lt;/code&gt; in Dependabot, or equivalent settings in Renovate and modern package managers. A 7-day cooldown would have blocked almost every attack on the list, and a 14-day cooldown would have stopped all of them except &lt;code&gt;xz-utils&lt;/code&gt;. While it isn&amp;rsquo;t a silver bullet—since supply-chain security is fundamentally a social-trust problem—eliminating 80–90% of the risk at near-zero cost is a no-brainer.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #5</title><link>https://miti99.com/en/post/2025/03/04/</link><pubDate>Tue, 04 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/04/</guid><description>&lt;i&gt;
Hello everyone, MiTi was a bit lazy last weekend and didn't put out a post. Enjoy Newsletter #5!
&lt;/i&gt;
&lt;h2 id="5-advanced-java-reflection-techniques-for-dynamic-programming"&gt;&lt;a href="https://dev.to/nithinbharathwaj/5-advanced-java-reflection-techniques-for-dynamic-programming-4ph1" rel="noopener noreferrer"&gt;5 Advanced Java Reflection Techniques for Dynamic Programming&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article introduces five advanced techniques centered around Java&amp;rsquo;s Reflection API, the toolkit for inspecting and modifying the structure and behavior of classes, interfaces, and objects at runtime. The first technique is accessing private members: retrieving a &lt;code&gt;Field&lt;/code&gt; or &lt;code&gt;Method&lt;/code&gt; via &lt;code&gt;getDeclaredField()&lt;/code&gt;/&lt;code&gt;getDeclaredMethod()&lt;/code&gt; and calling &lt;code&gt;setAccessible(true)&lt;/code&gt; to bypass access checks—handy for testing or working with legacy code, though it breaks encapsulation (and is subject to Java 9+ module system restrictions). The second is dynamic object instantiation from a class name known only at runtime using &lt;code&gt;Class.forName()&lt;/code&gt; and a matching constructor, which forms the backbone of plugin architectures in the spirit of the Open-Closed Principle. The third combines custom annotations with reflection to attach metadata to code and process it at runtime—for instance, logging every method invocation—which is how frameworks implement validation, dependency injection, and ORMs. The fourth uses &lt;code&gt;java.lang.reflect.Proxy&lt;/code&gt; to create dynamic proxies for interfaces, weaving in cross-cutting concerns like logging, transaction management, or access control without modifying the target class. The fifth covers runtime bytecode manipulation with libraries like ByteBuddy (outside the standard Reflection API), generating subclasses that intercept method calls on concrete classes as well as interfaces.&lt;/p&gt;
&lt;p&gt;While the examples illustrate how to build extensible plugins, process metadata, and layer on behaviors like logging, there are important caveats: &lt;code&gt;setAccessible(true)&lt;/code&gt; is still constrained by the Java module system, so it cannot guarantee access to every private member; annotations do not intercept calls on their own unless reflective code explicitly inspects them and invokes the target method; JDK &lt;code&gt;Proxy&lt;/code&gt; only works with interfaces; and the ByteBuddy example works by subclassing and intercepting overridable methods. These mechanisms are powerful when dynamic flexibility is needed, but their impact on encapsulation, maintainability, and runtime performance must be weighed carefully.&lt;/p&gt;
&lt;h2 id="mistakes-you-apparently-just-have-to-make-yourself"&gt;&lt;a href="https://medium.com/@mcfunley/mistakes-you-apparently-just-have-to-make-yourself-cc2dd2bfc25c" rel="noopener noreferrer"&gt;Mistakes You Apparently Just Have to Make Yourself&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan McKinley compiles a list of mistakes he calls &amp;ldquo;non-transferable knowledge&amp;rdquo;: no matter how many times seasoned engineers warn you against them, people apparently still have to touch the hot stove themselves to believe it burns. The list hits on classic industry tropes: the legacy codebase is such a mess that we have to rewrite it from scratch; our software is hard to manage, so adding operational complexity will somehow make it easier; our problem is completely novel, so we must adopt bleeding-edge technology; adding network hops will magically make the system faster; running a production system is just like maintaining an open-source project; writing a thin wrapper around a CLI tool adds real value; coding is the bulk of the work; functional tests are all the testing you need; deploying directly from version control is fine; logical separation requires physical separation; bureaucracy solves everything—or solves nothing; and if two teams use the same noun, they should share the same code.&lt;/p&gt;
&lt;p&gt;The final item is self-deprecating: everyone thinks they are the first person to make all 13 mistakes and that the author is writing specifically about them. The post wraps up with a tongue-in-cheek plug for the author&amp;rsquo;s startup, Skyliner, pitching it as a &amp;ldquo;straitjacket&amp;rdquo; to keep you from hurting yourself. For newer engineers, it&amp;rsquo;s a list worth revisiting whenever you&amp;rsquo;re about to make a major architectural bet.&lt;/p&gt;
&lt;h2 id="service-reliability-mathematics"&gt;&lt;a href="https://addyosmani.com/blog/service-reliability/" rel="noopener noreferrer"&gt;Service Reliability Mathematics&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that service reliability is too often reduced to a single uptime percentage, when reality is far more nuanced. Even with the exact same total annual downtime, a single 8-hour outage has a very different business impact than 480 one-minute blips, and five minutes of downtime during peak traffic can hurt more than an hour in the middle of the night. Each additional &amp;ldquo;nine&amp;rdquo; of availability demands exponentially more engineering effort and operational complexity: at 99.9% (about 8 hours 46 minutes of downtime per year), a single-region deployment with basic failover may suffice; reaching 99.99% typically requires multi-region active-active or automated failover; and 99.999% and beyond demands redundancy at every layer with real-time monitoring. These percentages also quietly assume that failures are uniformly distributed, independent, and immediately detected, while ignoring partial degradation and cascading failures. A service responding in 500ms instead of 5ms may still count as &amp;ldquo;up,&amp;rdquo; yet be practically unusable.&lt;/p&gt;
&lt;p&gt;Pursuing higher reliability always involves trade-offs between feature velocity and stability, infrastructure cost and redundancy, and on-call burnout for the team. Instead of blindly chasing extra nines, engineers should ask which failure modes actually hurt the business; modern practice favors error budgets, SLOs (Service Level Objectives), and user-centric telemetry to deliver dependable value while keeping engineering pace sustainable.&lt;/p&gt;
&lt;h2 id="how-to-write-a-good-design-document"&gt;&lt;del&gt;&lt;a href="https://grantslatton.com/how-to-design-document" rel="noopener noreferrer"&gt;How to write a good design document&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;&lt;del&gt;The article &amp;ldquo;How to Design Document&amp;rdquo; offers practical advice on writing effective design documents. According to the author, a design document is a technical report that outlines the implementation strategy for a system within the context of trade-offs and constraints. Its primary goal is to convince the reader (and most importantly, the author themselves) that the proposed design is optimal given the current situation.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The author compares writing a design document to writing a mathematical proof. To achieve maximum effectiveness, it requires strong organization, much like organizing code. Writers should avoid creating &amp;ldquo;spaghetti design docs&amp;rdquo; by ensuring every sentence connects logically and is easy to follow. The goal is to never surprise the reader, making the solution feel obvious even when it required complex thinking to reach.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;The post also emphasizes the importance of understanding the reader&amp;rsquo;s mindset and anticipating potential objections. Furthermore, writers should edit ruthlessly to remove unnecessary words, because the reader&amp;rsquo;s attention is a scarce resource. The author encourages practicing by critiquing other documents and distilling complex ideas into concise tweets.&lt;/del&gt;&lt;/p&gt;
&lt;p&gt;&lt;del&gt;Finally, the article suggests structuring documents into bullet points that can each be summarized in a single sentence and using footnotes for complex tangents so they don&amp;rsquo;t disrupt the main flow of the document.&lt;/del&gt;&lt;/p&gt;
&lt;h2 id="picking-your-battles-when-you-are-hyper-rational"&gt;&lt;a href="https://newsletter.weskao.com/p/picking-your-battles-hyper-rational" rel="noopener noreferrer"&gt;Picking your battles when you are hyper-rational&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Wes Kao highlights a common habit among hyper-rational people: getting so caught up in proving they are &amp;ldquo;technically correct&amp;rdquo; that they sacrifice practical effectiveness—winning a minor skirmish while losing the war. She illustrates this with two emails she almost sent. In the first example, a recruiter asked to chat &amp;ldquo;this morning&amp;rdquo; when it was already nearly 1:00 PM in Wes&amp;rsquo;s time zone; instead of lecturing on all the ways &amp;ldquo;this morning&amp;rdquo; could be interpreted across time zones, she simply confirmed the time zone and offered a few open slots to lock in the meeting quickly. In the second, a client&amp;rsquo;s finance team told her she didn&amp;rsquo;t need to fill out a vendor onboarding form even though their own billing system had just emailed her demanding it; she nearly wrote a multi-paragraph explanation defending why she had asked, but caught herself and sent a one-line &amp;ldquo;thanks for clarifying.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The lesson is to resist the urge to prove you noticed every nuance or to nitpick someone else&amp;rsquo;s phrasing, which wastes time and makes you look difficult to work with. Before sending a corrective explanation, ask yourself: does this move us closer to the goal, does it actually help the recipient or just prove I&amp;rsquo;m right about an irrelevant detail, and am I serving the conversation or my own ego? There are times when clarifying a misunderstanding matters, of course, but on the small stuff, it&amp;rsquo;s almost always better to let it go and stay focused on the main objective.&lt;/p&gt;
&lt;h2 id="measuring-programmer-influence-kinda-sorta"&gt;&lt;a href="https://tidyfirst.substack.com/p/measuring-programmer-influence-kinda" rel="noopener noreferrer"&gt;Measuring Programmer Influence, Kinda Sorta&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kent Beck asks whether data can tell us who contributes the most on a large engineering team. His blunt answer is no—not if you want certainty—though data can hint at where influence lives. He opens with a clear warning: the first time you tie bonuses, promotions, or layoffs to these metrics is the last time they will ever be trustworthy. Analyzing the Git history of the React repository, he observes that both the number of files created per author and the number of times each file is modified follow a Pareto distribution: most contributors create only a single file, while a small handful create hundreds or thousands. Plotting those two dimensions together—files an author created versus how often other people later modified those files—reveals a clear trend line; the engineers in the upper-right corner, who create foundations that others keep building upon, are strong candidates for high-influence contributors.&lt;/p&gt;
&lt;p&gt;Used well, this kind of analysis helps engineers calibrate themselves against peers, find mentors to learn from, and spot people whose real-world impact exceeds their formal title. Used poorly, it gets weaponized for compensation, quotas, promotions, or stack ranking. The data has obvious blind spots too: many vital contributions never show up in commit graphs, and long-tenured team members naturally accumulate higher numbers. The takeaway: never lose sight of the real goal—making a meaningful impact—and always sanity-check your results, because programming with data is still programming.&lt;/p&gt;
&lt;h2 id="building-personal-software-with-claude"&gt;&lt;a href="https://blog.nelhage.com/post/personal-software-with-claude/" rel="noopener noreferrer"&gt;Building personal software with Claude&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nelson Elhage recounts using Claude to port a bottleneck in Emacs&amp;rsquo;s &lt;code&gt;obsidian.el&lt;/code&gt; package to Rust, speeding it up by more than 1,000x (in one specific benchmark, dropping from 90 seconds to roughly 15ms) while barely writing a line of code himself. The culprit was &lt;code&gt;obsidian-update&lt;/code&gt;, which rescanned his entire note vault in Emacs Lisp and had grown painfully slow. With a single prompt, Claude read roughly 1,000 lines of Elisp, identified the ~200 relevant lines, and wrote a Rust program to extract the note metadata as JSON; the generated Rust code compiled and worked on the first try. Next, Claude wrote the Elisp glue using Emacs&amp;rsquo;s &lt;code&gt;advice&lt;/code&gt; mechanism to patch &lt;code&gt;obsidian.el&lt;/code&gt;, hitting only one minor bug that was fixed in minutes. The entire project took a single afternoon. Even though Elhage works at Anthropic, he had previously thought of Claude mostly as a better Stack Overflow.&lt;/p&gt;
&lt;p&gt;Reflecting on the experience, he draws several conclusions. First, the tooling and UX around LLMs are still lagging behind the raw capabilities of the models themselves. Second, he noticed that he naturally decomposed the problem along clean, easily testable interface boundaries: the human handles system decomposition, while Claude fills in the &amp;ldquo;meat&amp;rdquo; in between. Most importantly, while code is now cheaper than ever to produce, deep understanding, architecture, and good design are only becoming more valuable; writing &amp;ldquo;easy-to-delete&amp;rdquo; code may matter even more when an LLM can regenerate an implementation from scratch on demand. Above all, he rediscovered the joy of building small personal tools now that Claude can shoulder the tedious parts.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1112c07d-db40-484e-917b-0071ed7cf354_1280x1532.gif" alt="Git vs GitHub"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/5fd8bdda-52dd-454f-be79-ad548f17810b_1280x1557.gif" alt="A Cheatsheet on Database Performance"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/35ae3f82-afa0-47b9-a2a0-58b6c6d8cfb1_1280x1476.gif" alt="18 Common Ports Worth Knowing"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #4</title><link>https://miti99.com/en/post/2025/02/27/</link><pubDate>Thu, 27 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/27/</guid><description>&lt;i&gt;
Hello everyone, I found quite a lot of articles last week, and cramming them all into a single issue would have made it way too long. So today I'm posting an extra mid-week newsletter ^^.
&lt;/i&gt;
&lt;h2 id="management-mantras"&gt;&lt;a href="https://blog.staysaasy.com/p/management-mantras" rel="noopener noreferrer"&gt;Management Mantras&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on the Stay SaaSy blog distills four mantras for engineering managers. The first is &amp;ldquo;don&amp;rsquo;t do anyone any favors&amp;rdquo;: everyone at a company should be working on the highest-priority thing they can do, so when someone says &amp;ldquo;let me do you a favor,&amp;rdquo; it&amp;rsquo;s usually either already their job, a broken process, or a subversion of priorities. That leads directly to the second mantra: employees don&amp;rsquo;t need charity. Whatever the company provides to employees is either compensation they have earned or a core responsibility of management—so when you tell a report they got a raise and they thank you, tell them &amp;ldquo;don&amp;rsquo;t thank me, you earned it.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;The third mantra is &amp;ldquo;I can fix it.&amp;rdquo; The larger a company grows, the easier it is to point fingers elsewhere. At good companies, if every project you touch fails, the burden is on you to prove it wasn&amp;rsquo;t your fault; managers must coach their teams to take ownership of anything blocking their results. Finally, management is an everyday job: most of the work consists of uncomfortable tasks like pushing people to do better, resolving conflicts, and delivering tough feedback. A manager&amp;rsquo;s value lies in changing behavior, and that comes from the compounding effect of small daily nudges and coaching moments rather than a few dramatic decisions a year.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-programming-languages-choosing-the-right-tool-for-the-job"&gt;&lt;a href="https://dev.to/mohammad-reza-mahdiani/the-ultimate-guide-to-programming-languages-choosing-the-right-tool-for-the-job-4be2" rel="noopener noreferrer"&gt;The Ultimate Guide to Programming Languages: Choosing the Right Tool for the Job&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This DEV Community article surveys five popular programming languages in 2025 along with their strengths and trade-offs. Python is easy to learn and boasts a rich ecosystem for machine learning, data science, web development, and automation, though it is slower than compiled languages and poorly suited for mobile apps. JavaScript remains the &amp;ldquo;king of the web&amp;rdquo;: running natively in browsers, on servers via Node.js, and across platforms with Electron or React Native, at the cost of dynamic typing pitfalls at runtime. Java is the enterprise workhorse thanks to the JVM, stability, and scalability, despite verbose syntax and slower startup for small apps. C++ excels at raw performance and hardware control—ideal for game engines, embedded systems, and simulations—but has a steep learning curve and manual memory management. Rust is the rising star offering memory safety without a garbage collector, well suited for systems programming, WebAssembly, and cryptography, though its ecosystem is still smaller.&lt;/p&gt;
&lt;p&gt;Looking at broader trends, Python still leads in machine learning even as Julia gains ground in high-performance numerical computing; Solidity and Rust stand out in blockchain development; and Kotlin Multiplatform and Flutter (Dart) are popular for unifying mobile, web, and desktop development. The author&amp;rsquo;s conclusion: there is no silver-bullet language, and the right choice depends on project requirements, team expertise, and long-term goals.&lt;/p&gt;
&lt;h2 id="discovery-coding"&gt;&lt;a href="http://jimmyhmiller.com/discovery-coding" rel="noopener noreferrer"&gt;Discovery Coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jimmy Miller borrows a familiar distinction from fiction writing: some writers outline everything in advance, while others discover the story in the act of writing. He calls the programming equivalent &amp;ldquo;Discovery Coding&amp;rdquo;—understanding a problem by writing code first rather than designing everything up front. A discovery coder asks what the new code needs to accomplish and how different parts of the system interact, and only by writing code and feeling where the system &amp;ldquo;pushes back&amp;rdquo; do they chart a path forward. This style is easily dismissed as messy, especially in a culture that prizes static type systems and rigid upfront constraints, but the author stresses separating the creative process from the finished artifact: discovery coders can still produce clean, rigorous code once they understand the problem.&lt;/p&gt;
&lt;p&gt;Even natural outliners can benefit from this approach: because you don&amp;rsquo;t walk in with a pre-baked solution, exploratory coding helps you avoid forcing a familiar pattern onto a new problem and loads the system&amp;rsquo;s real constraints into your head. Tools that support live programming against a running system (like Clojure or Smalltalk) and instant visual feedback are especially helpful here. The post closes with a call to accept that programmers think in different ways: a less tidy process doesn&amp;rsquo;t mean a worse outcome, and software design is ultimately a human activity.&lt;/p&gt;
&lt;h2 id="building-a-best-selling-game-with-a-tiny-team"&gt;&lt;a href="https://newsletter.pragmaticengineer.com/p/thronefall" rel="noopener noreferrer"&gt;Building a best-selling game with a tiny team&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This episode of The Pragmatic Engineer Podcast features Jonas Tyroller, one of the two developers behind &lt;em&gt;Thronefall&lt;/em&gt;, a minimalist strategy game blending tower defense and kingdom building that sold roughly one million copies in its first year. Jonas built the game using Unity, C#, and Blender, structuring each level as a scene populated with scripted game objects. Surprisingly, the duo did no code reviews, wrote no unit tests, and pushed straight to &lt;code&gt;main&lt;/code&gt;: for a small, ship-once game built by two experienced developers, those practices weren&amp;rsquo;t worth the overhead, even if they matter on larger teams. Bugs were caught primarily through constant playtesting, beta testing, and post-launch player feedback.&lt;/p&gt;
&lt;p&gt;Their workflow started with rapid prototyping—spending just 1–2 days per prototype and prioritizing gameplay feel before visuals—to find an idea that was both commercially viable and fun for them to build. The biggest technical challenge was unit pathfinding: they bought an off-the-shelf A* plugin and customized it so troop movement felt natural. Jonas also used ChatGPT to generate boilerplate code, translate shader code, and get up to speed on unfamiliar topics. Key takeaways: indie game development demands wearing many hats—from design and programming to music composition and marketing; the way to get good at making games is to make lots of them; and with Unity and today&amp;rsquo;s wealth of tutorials, getting started has never been more accessible.&lt;/p&gt;
&lt;h2 id="serving-a-billion-web-requests-with-boring-code"&gt;&lt;a href="https://notes.billmill.org/blog/2024/06/Serving_a_billion_web_requests_with_boring_code.html" rel="noopener noreferrer"&gt;Serving a billion web requests with boring code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bill Mill recounts designing the backend API system for the US government&amp;rsquo;s Medicare Plan Finder, where millions of Americans compare and enroll in health insurance plans. The system serves around 5 million requests a day with an average latency under 10 milliseconds, totaling well over a billion requests. Guided by the &amp;ldquo;Choose Boring Technology&amp;rdquo; philosophy, the team picked PostgreSQL, Go, and React. Their only two architectural bets were splitting the backend into three coarse-grained services (&lt;code&gt;druginfo&lt;/code&gt;, &lt;code&gt;planinfo&lt;/code&gt;, &lt;code&gt;beneinfo&lt;/code&gt;), each with its own database, and using gRPC for inter-service communication. While gRPC provided code-defined interfaces, its tooling proved clunky and the author admits they probably would have been better off without it; on the flip side, &lt;code&gt;grpc-gateway&lt;/code&gt; served over a billion requests without a single outage.&lt;/p&gt;
&lt;p&gt;Several other decisions leaned heavily into simplicity: enforcing strict backward compatibility (only adding fields, never removing them), building multi-criteria search by concatenating SQL strings inside a single long but thoroughly commented function instead of standing up Elasticsearch, and rebuilding the databases from scratch every day via a shell-script-and-cron ETL pipeline that used PostgreSQL&amp;rsquo;s &lt;code&gt;COPY&lt;/code&gt; command to load over 250 million rows. The author&amp;rsquo;s biggest regret was writing brittle SQL-mock unit tests that were painful to maintain instead of testing against a real database instance. The takeaway: high-quality, resilient software can absolutely be built within the constraints of government contracting.&lt;/p&gt;
&lt;h2 id="java-language-evolution-in-2025---inside-java-newscast-84"&gt;&lt;a href="https://www.youtube.com/watch?v=dPzle3EN4CM" rel="noopener noreferrer"&gt;Java Language Evolution in 2025 - Inside Java Newscast #84&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Episode #84 of the Inside Java Newscast reviews how the Java language is evolving in 2025 under Project Amber, the initiative focused on language syntax and developer productivity features. Active preview features include flexible constructor bodies (allowing statements to run before &lt;code&gt;super()&lt;/code&gt; or &lt;code&gt;this()&lt;/code&gt;), simplified &lt;code&gt;main&lt;/code&gt; methods and compact source files for smaller programs, single-statement module imports, and primitive types in &lt;code&gt;instanceof&lt;/code&gt; and &lt;code&gt;switch&lt;/code&gt; pattern matching. The video distinguishes these from earlier-stage explorations such as deconstruction patterns for extracting data from objects, &amp;ldquo;withers&amp;rdquo; for creating modified copies of records, and the redesign of string templates, before touching briefly on serialization improvements.&lt;/p&gt;
&lt;h2 id="valhalla---java"&gt;&lt;a href="https://www.youtube.com/watch?v=Dhn-JgZaBWo" rel="noopener noreferrer"&gt;Valhalla - Java&amp;rsquo;s Epic Refactor&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this Devoxx Belgium 2024 talk, Brian Goetz explains Project Valhalla, the long-running effort to heal the rift between objects and primitives in Java. At the center are value classes, which let developers model data with standard class abstractions while enabling flat, dense memory layouts like primitives. The talk also covers null-restricted types, tearing analysis under concurrent updates, and stricter object initialization rules.&lt;/p&gt;
&lt;h2 id="how-might-ai-change-programming"&gt;&lt;a href="https://registerspill.thorstenball.com/p/how-might-ai-change-programming" rel="noopener noreferrer"&gt;How might AI change programming?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thorsten Ball argues that AI is undeniably going to change programming, pointing to a string of tools Claude wrote for him: a Python script that converts a newsletter RSS feed into Markdown, an MCP server for Tailscale, over 200 lines of Rust, and a small Go server that renders Markdown files—most of which worked on the very first try. Even though AI isn&amp;rsquo;t equally effective across every codebase yet, writing and rewriting certain kinds of code has become dirt cheap, and that shift will reshape software development just as compilers, the Internet, version control, and Stack Overflow did. The real question is how.&lt;/p&gt;
&lt;p&gt;The author poses a series of thought-provoking open questions: will new programming languages struggle to gain traction when LLMs lack training data for them? Will we check prompts into version control alongside source code, or structure systems as collections of tiny programs that fit neatly into an AI&amp;rsquo;s context window? Will &lt;code&gt;CONTEXT.md&lt;/code&gt; become the new &lt;code&gt;robots.txt&lt;/code&gt;, guiding AI agents through a repository? Will we see a new form of technical debt when codebases are over-optimized for the quirks of today&amp;rsquo;s models? Will compilers emit richer, more contextual error messages tailored for AI self-correction, and will function names grow longer and more descriptive because they help LLMs reason better? The post doesn&amp;rsquo;t claim to have the answers, but offers plenty of food for thought about the future of the craft.&lt;/p&gt;
&lt;h2 id="hands-on-career-the-evolution-of-a-java-champion"&gt;&lt;a href="https://blog.vanillajava.blog/2025/01/hands-on-career-evolution-of-java.html" rel="noopener noreferrer"&gt;Hands-On Career: The Evolution of a Java Champion&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Lawrey, founder of Chronicle Software and a ten-year Java Champion, reflects on more than 30 years of coding and what a programming career looks like in the era of generative AI. He outlines eight dimensions of career growth—ranging from technical depth, problem-solving, and collaboration/communication to business acumen and strategic management—and traces how an engineer&amp;rsquo;s focus shifts from junior developer up to principal engineer or solutions architect. When you start your own company, that scope expands further into sales, finance, legal, and HR. Just as ATMs didn&amp;rsquo;t eliminate bank tellers but shifted them toward higher-value relationship work, developers will adapt and gravitate toward problems that still demand human judgment.&lt;/p&gt;
&lt;p&gt;On working with AI, the author emphasizes that LLMs are statistical rather than deterministic, meaning their output is only probabilistically correct and requires domain experts to verify. A practical tip is to ask the AI to produce a plan before writing code, which consistently yields more complete results; maintaining living requirements and design documents alongside the project (documentation-driven development) also keeps AI outputs much more consistent. AI remains weak at self-evaluation, quantitative performance analysis, and aesthetic judgment. His conclusion: the ability to choose the right code matters more than the ability to type it out, and AI cannot replace hard-won experience, domain expertise, or engineering judgment.&lt;/p&gt;
&lt;h2 id="token-bucket-rate-limiter-redis--java"&gt;&lt;a href="https://foojay.io/today/token-bucket-rate-limiter-redis-java/" rel="noopener noreferrer"&gt;Token Bucket Rate Limiter (Redis &amp;amp; Java)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This tutorial walks through implementing the Token Bucket rate-limiting algorithm using Redis and Java. The core idea is a &amp;ldquo;bucket&amp;rdquo; that refills with tokens at a constant rate; each incoming request consumes one token and is rejected if the bucket is empty, while the bucket&amp;rsquo;s maximum capacity allows the system to absorb short bursts of traffic. In Redis, each client has two keys storing its current token count and the timestamp of the last refill; on every request, the application reads both values, calculates how many tokens to add based on elapsed time (capped at the bucket capacity), deducts one token if available, and writes the updated state back inside a &lt;code&gt;MULTI&lt;/code&gt;/&lt;code&gt;EXEC&lt;/code&gt; transaction (because the reads happen outside the transaction, the operation is not strictly atomic under concurrent requests). The author uses Jedis to build a &lt;code&gt;TokenBucketRateLimiter&lt;/code&gt; class and tests it with Redis TestContainers, JUnit 5, and AssertJ across scenarios such as allowing requests within capacity, rejecting when tokens are exhausted, refilling over time, isolating multiple clients, and not counting rejected requests. Full source code in both Java and Kotlin is available on GitHub.&lt;/p&gt;
&lt;p&gt;One subtlety to watch out for: the code floors the number of newly generated tokens using integer division, yet updates the last-refill timestamp on every request—including rejected ones. If requests arrive continuously faster than the time needed to mint a single token, the accumulated fractional time is lost and the bucket fails to refill at the intended rate.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus?&lt;/h2&gt;&lt;p&gt;Boohoo, no bonus items this time around, folks :&amp;lt;&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>