<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Game Development on miti99</title><link>https://miti99.com/en/tags/game-development/</link><description>Recent content in Game Development on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/tags/game-development/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #86</title><link>https://miti99.com/en/post/2026/03/01/</link><pubDate>Sun, 01 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #86.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="do-not-surrender-to-the-tech-tree"&gt;&lt;a href="https://www.macroscience.org/p/do-not-surrender-to-the-tech-tree" rel="noopener noreferrer"&gt;Do Not Surrender to the Tech Tree&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tao Burga defends &amp;ldquo;strong technological determinism&amp;rdquo;: technology unfolds according to the internal logic of a &amp;ldquo;tech tree,&amp;rdquo; driven more by prerequisites, market incentives, and efficiency than by lone genius. The evidence is that independent, near-simultaneous invention is pervasive (Hall–Héroult aluminum smelting, the jet engine, calculus), and isolated societies still converge on the wheel, intensive agriculture, metallurgy, and writing. Yet the author rejects &amp;ldquo;Technocalvinism&amp;rdquo;—the fatalistic belief that humans are powerless before this progression. In the short run, deliberate choices, especially altering the order in which technologies arrive, can have lasting consequences: non-proliferation efforts kept the number of nuclear-armed states at nine, Permissive Action Links prevented unauthorized detonations, and COVID-19 vaccines arrived in 10 months instead of 10–15 years.&lt;/p&gt;
&lt;p&gt;Turning to AI, the author stresses that it is a dual-use technology: useful for both cyber defense and cyber offense, for discovering vaccines and for engineering dangerous pathogens. Rather than accepting the default branch of the tree, we need differential technological development that builds risk-mitigating technologies in parallel—like inventing seatbelts alongside the automobile. The essay highlights &amp;ldquo;The Launch Sequence,&amp;rdquo; a portfolio of 16 concrete projects including Operation Patchlight and The Great Refactor (using AI to harden critical software infrastructure before AI-powered attacks hit), hardware-based verification, and defenses against &amp;ldquo;sleeper agents&amp;rdquo; embedded in models. In the author&amp;rsquo;s view, AI is right inside such a window of agency now, and that window is closing fast.&lt;/p&gt;
&lt;h2 id="how-to-make-architecture-decisions-rfcs-adrs-and-getting-everyone-aligned"&gt;&lt;a href="https://lukasniessen.medium.com/how-to-make-architecture-decisions-rfcs-adrs-and-getting-everyone-aligned-ab82e5384d2f" rel="noopener noreferrer"&gt;How to Make Architecture Decisions: RFCs, ADRs, and Getting Everyone Aligned&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Lukas Niessen shares an architecture decision-making process designed to avoid two familiar failure modes: decisions rushed through in a hallway chat, or polished documents nobody reads—both of which lead to months of rework. The process has four steps: write an RFC (1–2 days), gather asynchronous feedback (2–3 days), hold a decision meeting (30–60 minutes), and write the ADR the same day. The RFC lays out context, options (including &amp;ldquo;do nothing&amp;rdquo;), stakeholders, and open questions; the crucial trick is explicitly ranking priorities rather than just listing pros and cons, because once priorities are clear, the right choice is usually obvious. The async review phase gives everyone time to think and research, and gives quieter teammates a voice.&lt;/p&gt;
&lt;p&gt;The decision meeting is not a presentation: everyone has already read the RFC, the group is kept to 5–8 people, and the time is spent resolving open questions, debating, and committing—whether by consensus, consent (no paramount objections), or a single accountable decision-maker. An ADR is the short, permanent record of what was decided and why; the RFC explores options, while the ADR captures the outcome. The author advises including an incremental rollout plan in the RFC, using LLMs as thinking partners rather than ghostwriters, and avoiding common traps: analysis paralysis, too many cooks, skipping the ADR, and ignoring quiet voices.&lt;/p&gt;
&lt;h2 id="the-cost-of-a-function-call"&gt;&lt;a href="https://lemire.me/blog/2026/02/08/the-cost-of-a-function-call/" rel="noopener noreferrer"&gt;The cost of a function call&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniel Lemire measures the overhead of a function call and the payoff of inlining, an optimization where the compiler copies a function&amp;rsquo;s body directly into the call site. Function calls are cheap but not free: they may require saving and restoring registers on the stack, jumping into and back out of the function, plus prologue and epilogue instructions. On an M4 MacBook with LLVM, a loop summing an integer array through a non-inlined &lt;code&gt;add&lt;/code&gt; function takes 0.7 ns per element, versus just 0.03 ns when inlined—over 20 times faster. The reason: once the call is inlined, the compiler vectorizes the loop with SIMD instructions, processing 16 integers in 8 instructions, or half an instruction per number instead of six. Even with SIMD disabled, the inlined version is still roughly 10 times faster.&lt;/p&gt;
&lt;p&gt;For a more complex function like counting spaces in a string, the outcome depends on input size. On a 1,000-character string, call overhead is negligible and the inlined version is even slightly slower (115 ns vs. 111 ns); on short strings of 0–6 characters, inlining is noticeably faster (1.0 ns vs. 1.6 ns). The takeaway: tiny, simple functions should be inlined when performance matters, whereas for functions with variable runtime, the inlining decision should be guided by realistic input sizes.&lt;/p&gt;
&lt;h2 id="the-perfect-code-review-how-to-reduce-cognitive-load-while-improving-quality"&gt;&lt;a href="https://bastrich.tech/perfect-code-review/" rel="noopener noreferrer"&gt;The PERFECT Code Review: How to Reduce Cognitive Load While Improving Quality&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Daniil Bastrich introduces PERFECT, a framework of principles to make code reviews less cognitively taxing. Without structure, reviews easily devolve into vague, subjective commentary—causing delays, bike-shedding over trivia, or rubber-stamp approvals. PERFECT orders seven principles by priority: Purpose (the code solves the right problem—a prerequisite), Edge Cases (handling boundary conditions, including &amp;ldquo;impossible&amp;rdquo; ones), Reliability (no performance or security regressions), Form (sound design principles, centered on high cohesion and low coupling), Evidence (tests and CI pass), Clarity (the code clearly expresses intent), and Taste (personal preferences are noted as non-blocking).&lt;/p&gt;
&lt;p&gt;The author stresses that code review isn&amp;rsquo;t an all-or-nothing checklist, but a spectrum of techniques that can be applied independently; even a lightweight, structured review delivers high value for little effort. To make it stick, teams should maintain a living written review guide (turning recurring review comments into documented conventions), require self-review before requesting peers, build review into the workflow with clear ownership and SLAs, automate everything possible, stop rubber-stamping with &amp;ldquo;LGTM,&amp;rdquo; and practice reviewing regularly. Good review comments state the issue, explain the reasoning, and suggest a concrete alternative.&lt;/p&gt;
&lt;h2 id="semantic-search-without-embeddings"&gt;&lt;a href="https://softwaredoug.com/blog/2026/01/08/semantic-search-without-embeddings.html" rel="noopener noreferrer"&gt;Semantic Search Without Embeddings&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Doug Turnbull argues that semantic search is not synonymous with vector search. Semantic search requires three ingredients: a shared representation for queries and documents, a similarity function, and a matching criterion to decide whether a result actually belongs in the user&amp;rsquo;s intended scope. Embeddings handle the first two well but struggle with the third: there is no universal similarity threshold across queries, so searching for &amp;ldquo;fruit that grows on trees&amp;rdquo; can still return a baseball. Instead, the author proposes using a controlled vocabulary or taxonomy—a hierarchy of domain concepts, like the category tree in the Wayfair WANDS dataset. A taxonomy provides all three: the category tree is the representation, exact category matches rank above parent and sibling categories, and anything beyond a chosen tree distance can be filtered out.&lt;/p&gt;
&lt;p&gt;Best of all, no vector index is required: you simply use hierarchical path tokenization (emitting the full ancestor path for every category) inside a standard BM25 index. Because BM25 rewards rarer terms, broad root categories appear frequently and score low, while specific leaf categories are rare and score high—naturally ranking exact matches above parents and grandparents. Taxonomies should start simple and split incrementally as categories grow, and LLMs make classifying both products and queries easier and cheaper than ever. In the author&amp;rsquo;s view, embeddings may be most useful for building classifiers rather than for direct retrieval and ranking.&lt;/p&gt;
&lt;h2 id="my-ai-adoption-journey"&gt;&lt;a href="https://mitchellh.com/writing/my-ai-adoption-journey" rel="noopener noreferrer"&gt;My AI Adoption Journey&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mitchell Hashimoto—creator of Vagrant, Terraform, and Ghostty—shares his pragmatic journey toward finding real value in AI tools. Adopting any tool, he notes, goes through three phases: inefficiency, adequacy, and finally workflow-changing discovery. His early steps included: dropping chat interfaces in favor of agents that can read files, run programs, and make HTTP requests; forcing himself to reproduce every manual commit with an agent to learn principles like breaking work into small tasks, separating planning sessions from execution sessions, and giving agents a way to verify their own work; spending the last 30 minutes of each day kicking off agents for deep research, fuzzy ideation, and issue/PR triage; and delegating slam-dunk tasks to agents while focusing on deep work himself with notifications turned off to avoid context switching.&lt;/p&gt;
&lt;p&gt;Step five is &amp;ldquo;harness engineering&amp;rdquo;: whenever the agent makes a mistake, add instructions to &lt;code&gt;AGENTS.md&lt;/code&gt; or build custom tooling so it never repeats that error. The final step is keeping one agent running in the background as much as possible, paired with slower, more thorough models. Right now he runs just a single agent at a time—striking a balance between the deep manual craft he loves and babysitting a machine—and reaches that background-agent goal for about 10–20% of his workday. He emphasizes never running an agent just for the sake of it, only when there is genuinely useful work, and notes that whatever you delegate to an agent is a skill you stop practicing yourself.&lt;/p&gt;
&lt;h2 id="software-engineering-is-back"&gt;&lt;a href="https://blog.alaindichiappari.dev/p/software-engineering-is-back" rel="noopener noreferrer"&gt;Software Engineering is back&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alain Di Chiappari argues that &amp;ldquo;automatic programming&amp;rdquo;—Antirez&amp;rsquo;s term in place of the shallow label &amp;ldquo;vibe coding&amp;rdquo;—is bringing real software engineering back. Building products ranging from network configuration to pricing engines with frontier models and coding agents every day, the author noticed a decisive shift starting in December 2025. Thinking through architecture, trade-offs, and edge cases still belongs to humans; what vanished is the manual labor of typing out every line of code. He gets to be the architect without laying every brick by hand, while still drawing on twenty years of bricklaying experience to understand and fix things when needed.&lt;/p&gt;
&lt;p&gt;In his view, frameworks historically solved three problems. &amp;ldquo;Simplification&amp;rdquo; was often intellectual surrender: buying someone else&amp;rsquo;s thinking instead of sharpening your own mental models, like wrapping a broken leg in silk. Automating boilerplate was the only legitimate reason, and agents now make custom code cheaper than ever—he builds small purpose-built tools tailored to the problem, where a simple Makefile covers most needs. The third, rarely spoken reason is labor commoditization: companies hire interchangeable &amp;ldquo;React Developers&amp;rdquo; instead of software engineers. Meanwhile, agents excel at battle-tested tools like Bash (born in 1989), which is becoming a universal adapter. The essay is a call to stop letting Google, Meta, or Vercel be your architect and start building things you truly own.&lt;/p&gt;
&lt;h2 id="art-of-roads-in-games"&gt;&lt;a href="https://sandboxspirit.com/blog/art-of-roads-in-games/" rel="noopener noreferrer"&gt;Art of Roads in Games&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Fascinated by road systems ever since playing SimCity 2000, the author examines why roads in city-building games, despite steady progress, still look subtly wrong: highway ramps kink or wobble unnaturally, high-speed lanes bend too sharply, and intersection corner radii look off. The root cause is the Bézier curve, game developers&amp;rsquo; go-to tool: elegant and flexible, yet unable to preserve its shape and curvature under parallel offsetting. In the real world, two wheels on the same axle stay a fixed distance apart, tracing parallel paths; a curve parallel to a Bézier curve is no longer a Bézier curve, so on tight turns the road mesh distorts or self-intersects.&lt;/p&gt;
&lt;p&gt;The solution is circular arcs: offset an arc in parallel (as long as the radius stays valid) and you get another circular arc concentric with the original, and chaining arcs of different radii can form complex shapes that follow real civil-engineering principles. Circular arcs also allow O(1) closed-form intersection math instead of the expensive iterative solvers Bézier curves require. Their limitation is constant curvature, which causes lateral acceleration to jump abruptly when entering a turn at high speed; highway engineers use transition curves like clothoids whose curvature ramps up linearly, though the math is much heavier. For lower-speed urban roads, circular arcs are more than good enough. The author built his own road system out of curiosity and because resources for indie developers were so scarce, and hopes to share a better foundation with the community.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7712ce10-d199-49ef-94f9-e983e47a92d9_2360x2852.png" alt="12 Architectural Concepts Developers Should Know"&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>