<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Error Handling on miti99</title><link>https://miti99.com/en/tags/error-handling/</link><description>Recent content in Error Handling 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/error-handling/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #89</title><link>https://miti99.com/en/post/2026/03/14/</link><pubDate>Sat, 14 Mar 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/03/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #89.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="hybrid-quota-linear-rate-limiter"&gt;&lt;a href="https://dotat.at/@/2026-01-12-hqlr.html" rel="noopener noreferrer"&gt;Hybrid Quota-Linear Rate Limiter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tony Finch points out an underappreciated quirk of linear rate limiters like the leaky bucket or GCRA: they are slow to clamp down on clients that exceed the limit only modestly. Given a quota of &lt;code&gt;q&lt;/code&gt; requests per time window &lt;code&gt;w&lt;/code&gt;, a client sending requests at &lt;code&gt;a&lt;/code&gt; times the allowed rate can still get roughly &lt;code&gt;q*a/(a-1)&lt;/code&gt; requests through before being blocked—double the quota when &lt;code&gt;a=2&lt;/code&gt;. The reason is that the bucket starts full of tokens and continuously refills another quota&amp;rsquo;s worth over the first window. Fixed-window quota-reset limiters enforce a stricter cap, but they use more memory and encourage clients to dump traffic in bursts at window boundaries.&lt;/p&gt;
&lt;p&gt;The author proposes a hybrid algorithm with two modes: a bursty mode for low-volume clients, which allows bursts but refills at most one quota per window; and a smooth mode for heavy clients, which starts with an empty bucket (plus a negative penalty) and forces requests to be paced evenly. The limiter switches to smooth mode when a client drains its last token, and returns to bursty mode once the bucket recovers a full quota. The behavior matches running a quota-reset limiter and a linear limiter side by side, while using less memory. Even so, the author advises against actually using it: a linear rate limiter only looks &amp;ldquo;too generous&amp;rdquo; if you ignore the fact that the client was idle during the previous window. It is better to reframe the requirement and stick with a simple linear limiter like GCRA, which naturally rewards steady traffic.&lt;/p&gt;
&lt;h2 id="go-is-the-best-language-for-ai-agents"&gt;&lt;a href="https://getbruin.com/blog/go-is-the-best-language-for-agents/" rel="noopener noreferrer"&gt;Go is the Best Language for AI Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Burak Karakan, who has worked professionally with Go for eight years and is building Bruin—an open-source ETL tool written in Go—argues that Go is the best language for coding with AI agents. First, Go is compiled: agents generate lots of plausible-looking code, and a fast compiler with static types lets the agent iterate in a tight loop until entire classes of type and argument errors are eliminated. Compared with Rust, Go has simpler syntax and concepts, compiles faster for a tighter feedback loop, and has a larger corpus of existing code. That simplicity also makes it easy for humans to review diffs and spot when an agent is heading down a strange design path.&lt;/p&gt;
&lt;p&gt;Go is also strongly opinionated: there is one standard way to run tests, format code, and build binaries, so an agent can just invoke &lt;code&gt;gofmt&lt;/code&gt; instead of wrestling with the toolchain sprawl common in JavaScript. Easy cross-compilation lets agents verify builds across operating systems after every change (even if running the tests still requires the target environment or an emulator)—a major advantage when running background agents inside sandboxes whose environment you don&amp;rsquo;t fully control. In the author&amp;rsquo;s experience, agents write working Go on the first try roughly 95% of the time—not because there is more training data than for Python, but because Go usually has one obvious way to do things. He acknowledges this is anecdotal and may matter less as models improve.&lt;/p&gt;
&lt;h2 id="your-agent-needs-a-harness-not-a-framework"&gt;&lt;a href="https://x.com/djfarrelly/status/2028556984396452250" rel="noopener noreferrer"&gt;Your Agent Needs a Harness, Not a Framework&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Dan Farrelly from Inngest argues that AI agents need a &amp;ldquo;harness,&amp;rdquo; not a framework. Across engineering disciplines, a harness connects, protects, and coordinates components without doing their job for them—like a wiring harness linking an engine to sensors, or a climbing harness catching you when you fall. For an agent, the LLM is the engine, tools are peripherals, and memory is storage; what you need around them is something that handles an LLM timing out on loop iteration five or two user messages colliding. Agent frameworks keep reinventing retries, state persistence, queues, and event routing from scratch, when durable event-driven infrastructure already solves those problems: every LLM or tool call becomes an independently retryable &amp;ldquo;step,&amp;rdquo; so if a process crashes on iteration five, the first four iterations are already checkpointed.&lt;/p&gt;
&lt;p&gt;To prove the point, the team built Utah (Universally Triggered Agent Harness)—a conversational agent over Telegram or Slack with tools, memory, sub-agent delegation via &lt;code&gt;step.invoke()&lt;/code&gt;, and fault tolerance, written in compact TypeScript with no agent framework, just Inngest functions, steps, and events wrapped around a think → act → observe loop. Their biggest lesson: context management is the real challenge, because bloated tool outputs disorient the model and send it into endless tool-calling loops. They solved this with two-tier pruning of old tool outputs, session history compaction, warnings as the step budget runs low, and automatic re-compaction on context-window overflow errors.&lt;/p&gt;
&lt;h2 id="an-interactive-intro-to-quadtrees"&gt;&lt;a href="https://growingswe.com/blog/quadtrees" rel="noopener noreferrer"&gt;An Interactive Intro to Quadtrees&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This interactive guide explains quadtrees—a spatial data structure for fast two-dimensional queries, inspired by seeing Uber use spatial indexing in system design write-ups. In a mapping app with millions of places, the naive approach to finding nearby points is computing the distance from the user to every single location, costing millions of operations per query. A quadtree reorganizes space itself: it splits a rectangular region into four quadrants, and whenever a quadrant exceeds its point capacity, it subdivides again. Dense areas get finely divided while sparse areas stay coarse, so looking up a point simply walks down the tree, eliminating three-quarters of the remaining space at each level—roughly 10 steps for a million points.&lt;/p&gt;
&lt;p&gt;The capacity parameter shapes the tree: a low capacity builds a deeper tree that prunes more aggressively but uses more memory; a high capacity builds a shallower tree where leaf nodes scan more points linearly, with 4 to 16 being a good starting range. Range queries only descend into nodes whose bounding boxes intersect the search region, pruning entire subtrees at once; nearest-neighbor search tracks the best distance found so far to prune increasingly aggressively. Beyond geospatial search, quadtrees power broad-phase collision detection in games—avoiding pairwise checks between distant objects—and region-based image compression, where uniform areas are stored as large blocks and detailed regions are subdivided.&lt;/p&gt;
&lt;h2 id="agentic-engineering-patterns"&gt;&lt;a href="https://simonwillison.net/guides/agentic-engineering-patterns/" rel="noopener noreferrer"&gt;Agentic Engineering Patterns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison has launched a guide to patterns for getting the most out of coding agents like Claude Code and OpenAI Codex. He draws a sharp line between &amp;ldquo;agentic engineering&amp;rdquo; and &amp;ldquo;vibe coding&amp;rdquo;: vibe coding means letting an LLM write code without paying attention to the code itself, whereas agentic engineering is professional engineers using agents to amplify their existing expertise rather than replace it. The guide is organized into sections covering core principles, working with coding agents (how they work, using Git, sub-agents), testing and quality assurance, understanding codebases through linear walkthroughs and interactive explanations, annotated prompts, and an appendix of prompts he uses regularly.&lt;/p&gt;
&lt;p&gt;A few standout patterns: &amp;ldquo;Writing code is cheap now&amp;rdquo;—the cost of generating code has dropped to near zero, but &lt;em&gt;good&lt;/em&gt; code with tests, documentation, and proper error handling still takes discipline, requiring new habits; &amp;ldquo;Hoard things you know how to do&amp;rdquo;—maintain a collection of working examples you can recombine and feed to agents as reference input; and &amp;ldquo;Red/green TDD&amp;rdquo;—have the agent write a failing test first and verify it fails before implementing the fix, along with running the test suite right at the start of every session. The guide also calls out anti-patterns to avoid—most notably filing unreviewed agent-generated pull requests for teammates to review—and continues to grow with new chapters.&lt;/p&gt;
&lt;h2 id="things-i-miss-about-spring-boot-after-switching-to-go"&gt;&lt;del&gt;&lt;a href="https://sushantdhiman.dev/things-i-miss-about-spring-boot-after-switching-to-go/" rel="noopener noreferrer"&gt;Things I Miss About Spring Boot After Switching to Go&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;After spending a year and a half building production Java and Spring Boot systems at a startup and then switching to Go, Sushant Dhiman reflects on what he misses from the Spring ecosystem. First is the &amp;ldquo;batteries included&amp;rdquo; philosophy: Spring Boot ships with nearly everything needed for production out of the box, whereas Go favors minimalism and a collection of small libraries over a monolithic framework. Specifically, he misses declarative dependency injection via annotations like &lt;code&gt;@Service&lt;/code&gt; and &lt;code&gt;@Autowired&lt;/code&gt;; in Go you wire dependencies manually through constructors—explicit, but startup code balloons once a service has hundreds of dependencies. Similarly, declarative validation with &lt;code&gt;@NotNull&lt;/code&gt; or &lt;code&gt;@Email&lt;/code&gt; avoids chains of manual &lt;code&gt;if/else&lt;/code&gt; checks and regexes.&lt;/p&gt;
&lt;p&gt;Spring&amp;rsquo;s mature ecosystem is another big loss: Spring Security handles JWT, OAuth, and form logins out of the box; Spring Data derives queries directly from method names like &lt;code&gt;findByEmail&lt;/code&gt;; Spring Boot Actuator exposes health checks and metrics with a few lines of configuration; and Spring Cloud provides a full toolkit for microservices. Still, the author is fair to Go: it gives you complete control and transparency over SQL queries, which is much easier to debug than complex multi-table ORM joins. Go also wins on operational simplicity—compiling to a single static binary with no JVM or garbage-collector tuning, near-instant startup, and first-class concurrency built right into the language.&lt;/p&gt;
&lt;h2 id="design-first-collaboration-with-ai"&gt;&lt;a href="https://martinfowler.com/articles/reduce-friction-ai/design-first-collaboration.html" rel="noopener noreferrer"&gt;Design-First Collaboration with AI&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Writing on martinfowler.com, Rahul Garg diagnoses the &amp;ldquo;Implementation Trap&amp;rdquo; when working with AI coding assistants: AI generates code so fast that the natural pause between design thinking and coding disappears. The AI still makes design decisions about scope, component boundaries, data flow, and error handling, but buries them quietly inside the implementation. Reviewers have to evaluate too many concerns at once and easily miss flaws, even though fixing a misunderstanding at the design stage is far cheaper than after code is written. Worse, AI assistants routinely slip in unrequested features—what the author calls &amp;ldquo;technical debt injection.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;His solution is to recreate the whiteboard design session across five progressive levels of abstraction: Capabilities (core requirements), Components (building blocks), Interactions (data flow and communication), Contracts (function signatures, types, interfaces), and finally Implementation. The golden rule is no production code until Level 5 is approved. In a notification-service example, reviewing at the Components level let the author scrap an unnecessary &lt;code&gt;RetryQueue&lt;/code&gt; class because BullMQ already handles retries; and once Contracts are agreed upon, the AI can write tests before writing the implementation. Not every task needs all five levels: a simple utility can start at Level 4, while a multi-component feature starts at Level 1. The process takes more upfront time and isn&amp;rsquo;t worth it for throwaway tasks, but pays off handsomely for complex, long-lived features.&lt;/p&gt;
&lt;h2 id="the-two-kinds-of-error"&gt;&lt;a href="https://evanhahn.com/the-two-kinds-of-error/" rel="noopener noreferrer"&gt;The Two Kinds of Error&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Evan Hahn divides software errors into two categories. &lt;em&gt;Expected&lt;/em&gt; errors happen during normal operation and aren&amp;rsquo;t bugs in the program: invalid user input, flaky networks, missing file permissions. These are recoverable—you shouldn&amp;rsquo;t &lt;code&gt;throw&lt;/code&gt;, &lt;code&gt;raise&lt;/code&gt;, or &lt;code&gt;panic&lt;/code&gt;, but instead return an explicit error value (like a &lt;code&gt;Result&lt;/code&gt; type) that forces the caller to handle it, logging at &lt;code&gt;WARN&lt;/code&gt; or &lt;code&gt;INFO&lt;/code&gt; at most. &lt;em&gt;Unexpected&lt;/em&gt; errors should never happen—failed assertions, logic bugs, corrupt data from a database you control—and indicate a bug in the code. Rather than limping along, the program should crash immediately and log at &lt;code&gt;ERROR&lt;/code&gt; or &lt;code&gt;FATAL&lt;/code&gt;; crashing is annoying in the moment, the author argues, but makes software far more reliable over time.&lt;/p&gt;
&lt;p&gt;Where the boundary falls depends on context: in a quick prototype or one-off script, almost every error can be treated as unexpected; in flight software for a 50-year deep-space probe, almost every error—including hardware faults—must be treated as expected. Making software more reliable generally means moving more errors from the unexpected column into the expected one. He also notes that languages like Rust and Zig nudge developers to treat many errors as expected, whereas JavaScript and Python do the opposite, and he prefers stricter compiler enforcement for production systems.&lt;/p&gt;
&lt;h2 id="secure-go-error-handling-best-practices"&gt;&lt;a href="https://blog.jetbrains.com/go/2026/03/02/secure-go-error-handling-best-practices/" rel="noopener noreferrer"&gt;Secure Go Error Handling Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post on the JetBrains GoLand blog focuses on the security side of error handling in Go. Because Go errors are plain values rather than exceptions, letting them bubble up and return directly to clients can easily leak file paths, SQL queries, credentials, or stack traces. The first rule is a strict separation between what the system sees and what the user sees: define a custom error type carrying both an internal cause and a public message, where &lt;code&gt;Error()&lt;/code&gt; returns only the safe message while technical details go exclusively to internal logs. Next, instead of logging entire request structs that might contain passwords, use a builder or helper that whitelists safe metadata fields; and when you don&amp;rsquo;t want callers inspecting the underlying cause via &lt;code&gt;errors.Is&lt;/code&gt; or &lt;code&gt;errors.As&lt;/code&gt;, wrap errors opaquely rather than using &lt;code&gt;fmt.Errorf&lt;/code&gt; with &lt;code&gt;%w&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;As errors cross architectural boundaries, control them at three levels: between internal layers, translate raw database errors into domain errors; between microservices, map them to standard status codes like gRPC codes or a uniform JSON error schema; and at the user-facing edge, return only predefined static strings or error codes paired with a request ID—never dynamically concatenated error text. For logging, use structured loggers like &lt;code&gt;log/slog&lt;/code&gt;, zap, or zerolog, project only the fields needed for debugging, and implement a &lt;code&gt;Redactor&lt;/code&gt; interface to mask sensitive fields whenever a full request payload must be logged.&lt;/p&gt;
&lt;h2 id="ai-coding-tools-java--compounding-engineering"&gt;&lt;a href="https://www.the-main-thread.com/p/ai-coding-tools-java-compounding-engineering" rel="noopener noreferrer"&gt;AI Coding Tools, Java &amp;amp; Compounding Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Markus Eisele distills Aleksander Stensby&amp;rsquo;s talk from NDC Manchester 2025 around a central thesis: if AI is generating bad code for you, it&amp;rsquo;s usually a workflow problem, not a model problem. Stensby calls the fix &lt;em&gt;Compounding Engineering&lt;/em&gt;—investing in your tools over time the way you mentor a junior developer. Context is both precious and scarce: too little and the model hallucinates, too much and it loses focus, so clear the chat frequently and persist architectural decisions, constraints, and rejected alternatives in markdown files so you can reload only what matters. Rule files like &lt;code&gt;CLAUDE.md&lt;/code&gt; serve as a living knowledge base: every time you fix a subtle bug, update the rules so the agent never makes that mistake again.&lt;/p&gt;
&lt;p&gt;Other habits include always planning before coding to catch bad ideas early, breaking work into small single-responsibility tasks, picking models deliberately (fast models for routine edits, deep reasoning models for architecture), automating repetitive flows with slash commands and sub-agents, using MCP so the AI can inspect real systems, and keeping a Git safety net of frequent checkpoints. Background agents still require thorough human review before merging. An engineer&amp;rsquo;s enduring value lies in taste and judgment—spotting that something is wrong even when all the tests pass—which AI still lacks. Invest in your workflow and the gains compound; skip that investment and you just get &amp;ldquo;faster mediocrity.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="yaml-that"&gt;&lt;a href="https://lab174.com/blog/202601-yaml-norway/" rel="noopener noreferrer"&gt;YAML? That&amp;rsquo;s Norway Problem&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This piece digs into YAML&amp;rsquo;s infamous &amp;ldquo;Norway problem&amp;rdquo;: the two-letter country code &lt;code&gt;NO&lt;/code&gt; getting parsed by popular libraries like PyYAML as the boolean &lt;code&gt;false&lt;/code&gt; instead of a string. The root cause is implicit typing for unquoted scalars: the final draft of YAML 1.0 (2004) and YAML 1.1 (2005) treated words like &lt;code&gt;yes/no&lt;/code&gt; and &lt;code&gt;on/off&lt;/code&gt; as booleans. YAML 1.2 (2009) dropped that behavior, yet PyYAML and LibYAML—the two &amp;ldquo;official&amp;rdquo; libraries, with open issues requesting v1.2 support dating back to 2016–2017—still implement v1.1. Because LibYAML sits deep inside the dependency tree of countless tools, changing it is slow and risky.&lt;/p&gt;
&lt;p&gt;Most articles stop at &amp;ldquo;just quote &lt;code&gt;&amp;quot;NO&amp;quot;&lt;/code&gt;,&amp;rdquo; but the author shows the ecosystem reality is messier. In Go, the most downloaded library (&lt;code&gt;gopkg.in/yaml.v3&lt;/code&gt;) is unmaintained and mixes v1.1 and v1.2 behaviors, whereas the most popular actively maintained library defaults to v1.2; the &lt;code&gt;yq&lt;/code&gt; CLI also defaults to v1.2, and in 2025 Kubernetes introduced KYAML, a safer, less ambiguous subset of YAML. Online documentation routinely confuses spec versions while users argue over whether the bug is &amp;ldquo;already fixed.&amp;rdquo; The takeaway: the YAML ecosystem is fragmented but gradually migrating toward stricter specs; new projects will likely pick newer v1.2-compliant libraries free of the Norway problem, while older, more widely deployed libraries remain stuck on v1.1.&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 #77</title><link>https://miti99.com/en/post/2026/01/24/</link><pubDate>Sat, 24 Jan 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/01/24/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #77.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="stop-forwarding-errors-start-designing-them"&gt;&lt;a href="https://fast.github.io/blog/stop-forwarding-errors-start-designing-them/" rel="noopener noreferrer"&gt;Stop Forwarding Errors, Start Designing Them&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article argues that most Rust developers merely &amp;ldquo;forward&amp;rdquo; errors rather than truly handling them: catching an error, wrapping it thinly, and propagating it up the call stack as fast as possible. The original low-level message survives intact, but almost all higher-level context is lost. The author points out the limitations of familiar tools: &lt;code&gt;std::error::Error&lt;/code&gt; assumes a linear chain of causes via &lt;code&gt;source()&lt;/code&gt; even though real-world failures often have multiple contributing causes; stack traces are expensive, misleading in async code, and only show where an error originated rather than the logical path execution took. Meanwhile, &lt;code&gt;thiserror&lt;/code&gt; categorizes errors by origin rather than by how callers can react, &lt;code&gt;anyhow&lt;/code&gt; makes adding context optional so it is routinely skipped, and the dynamic &lt;code&gt;Provide&lt;/code&gt;/&lt;code&gt;Request&lt;/code&gt; API makes behavior hard to predict.&lt;/p&gt;
&lt;p&gt;The proposed solution is to design errors for two distinct audiences. For machines, use a flat error struct categorized by error kind (similar to Apache OpenDAL&amp;rsquo;s design) with explicit retryability status—such as permanent, temporary, or persistent—so code can decide whether to retry or abort without walking nested error chains. For humans, use tree-structured context tracking that automatically records call sites via &lt;code&gt;#[track_caller]&lt;/code&gt; at near-zero cost and enforces adding context across module boundaries through the type system (as in the &lt;code&gt;exn&lt;/code&gt; crate). The guiding question when designing errors should be: &amp;ldquo;If the system breaks at 3 a.m., what do you want the logs to say?&amp;rdquo;&lt;/p&gt;
&lt;h2 id="clock-synchronization-is-a-nightmare"&gt;&lt;a href="https://arpitbhayani.me/blogs/clock-sync-nightmare/" rel="noopener noreferrer"&gt;Clock Synchronization Is a Nightmare&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post explains why synchronizing time across distributed systems is far harder than intuition suggests: there simply is no &amp;ldquo;global clock.&amp;rdquo; Every computer keeps time using a quartz crystal oscillating at 32,768 Hz, but manufacturing tolerances and temperature swings cause clocks to drift; two machines started at the exact same instant can drift hundreds of milliseconds apart after a single day. Instantaneous clock skew between two machines leads to subtle bugs: in a distributed &lt;code&gt;make&lt;/code&gt; build, a compiled object file can appear newer than a freshly edited source file and fail to recompile; in banking, a withdrawal timestamped earlier than a preceding deposit can make an account appear overdrawn.&lt;/p&gt;
&lt;p&gt;Physical clock synchronization techniques include Cristian&amp;rsquo;s algorithm (estimating one-way network delay as half the round-trip time), the Berkeley algorithm (averaging time across nodes and sending relative adjustments), hierarchical NTP backed by atomic or GPS clocks (achieving millisecond accuracy over the internet), and PTP using hardware timestamping on network interface cards for sub-microsecond accuracy. Google Spanner&amp;rsquo;s TrueTime returns a bounded uncertainty interval &lt;code&gt;[earliest, latest]&lt;/code&gt; instead of a single point in time. Logical clocks include Lamport Timestamps, Vector Clocks that capture causality rather than wall-clock time, and Hybrid Logical Clocks (used in CockroachDB) that combine both. The takeaway: there is no perfect clock sync, only trade-offs between accuracy, latency, and complexity depending on your system&amp;rsquo;s needs.&lt;/p&gt;
&lt;h2 id="java---learning-roadmap"&gt;&lt;a href="https://nemorize.com/roadmaps/java" rel="noopener noreferrer"&gt;Java - Learning Roadmap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is a structured Java learning roadmap on the Nemorize platform that guides learners from foundational setup through enterprise application development. It begins with prerequisites like basic Linux, Git version control, and choosing an IDE, then moves into object-oriented programming (classes, objects, inheritance, polymorphism, encapsulation, abstraction), and covers core language features including the Collections Framework, exception handling, and Streams. Advanced topics include concurrency and multithreading, JVM internals, design patterns, and Dependency Injection.&lt;/p&gt;
&lt;p&gt;The final sections focus on professional engineering skills: testing (unit, integration, contract), build tools like Maven and Gradle, working with databases, Spring Boot for enterprise applications, and principles like Clean Code, SOLID, API design, and system monitoring. Each topic follows a three-step loop: read the lesson, practice with quizzes, and track progress (requires sign-in). At the time of writing, roughly 14 of the 44 topics have full lessons available with the rest being added progressively, making it a useful reference roadmap for beginners wondering what order to learn Java in.&lt;/p&gt;
&lt;h2 id="the-ultimate-guide-to-successfully-adopting-kotlin-in-a-java-dominated-environment"&gt;&lt;a href="https://blog.jetbrains.com/kotlin/2025/12/the-ultimate-guide-to-successfully-adopting-kotlin-in-a-java-dominated-environment/" rel="noopener noreferrer"&gt;The Ultimate Guide to Successfully Adopting Kotlin in a Java-Dominated Environment&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;JetBrains&amp;rsquo; guide frames introducing Kotlin into a predominantly Java organization not as flipping a switch or rewriting everything from scratch, but as a challenge of people, timing, risk management, and trust. The roadmap spans five stages. First, get comfortable with Kotlin in test suites (using Kotest and MockK) where production isn&amp;rsquo;t at risk, answering the question, &amp;ldquo;Is this language genuinely nicer to work with?&amp;rdquo; Next, evaluate Kotlin in real production work by building a small new service or adding a Kotlin module to an existing system while avoiding the trap of &amp;ldquo;writing Java in Kotlin syntax&amp;rdquo;: use extension functions instead of static utility classes, nullable types instead of &lt;code&gt;Optional&lt;/code&gt;, and data classes instead of boilerplate POJOs.&lt;/p&gt;
&lt;p&gt;Stage three is building internal momentum through short demos, starter template repositories, and pair programming. Stage four is making the business case to management: less code to maintain, fewer bugs thanks to null safety, 100% Java interoperability so no big-bang rewrite is required, and predictable ramp-up costs. Finally, when scaling adoption across the organization, treat each system according to its lifecycle: leave sunsetting applications alone, default to Kotlin for greenfield projects, and migrate active systems incrementally with the help of IDE conversion tools, JSpecify nullability annotations, and AI-assisted refactoring.&lt;/p&gt;
&lt;h2 id="rust-vs-go"&gt;&lt;a href="https://bitfieldconsulting.com/posts/rust-vs-go" rel="noopener noreferrer"&gt;Rust vs Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;John Arundel compares Rust and Go across performance, simplicity, safety, features, scalability, and concurrency, summing up the trade-off in a single phrase: &amp;ldquo;Rust for high stakes, Go for low cost.&amp;rdquo; Both are compiled languages that produce small, fast native binaries and come with great built-in tooling (&lt;code&gt;gofmt&lt;/code&gt;, &lt;code&gt;rustfmt&lt;/code&gt;). Their difference lies in philosophy: Go is a small, easy-to-learn, fast-compiling garbage-collected language that prioritizes developer velocity and stability, with goroutines and channels making concurrency remarkably approachable. Rust prioritizes correctness, peak performance, and low-level control, using its borrow checker to eliminate memory bugs at compile time without a garbage collector, at the cost of a steeper learning curve.&lt;/p&gt;
&lt;p&gt;For error handling, Go uses explicit &lt;code&gt;if err != nil&lt;/code&gt; checks, while Rust uses &lt;code&gt;Option&lt;/code&gt;/&lt;code&gt;Result&lt;/code&gt; types paired with the &lt;code&gt;?&lt;/code&gt; operator. Go shines when fast onboarding, rapid prototyping, and cost-effective delivery matter most—such as web services, microservices, infrastructure tooling, and business automation. Rust shines when reliability, predictable latency, and resource efficiency are mission-critical—such as automotive, aerospace, medical devices, and industrial systems. He views the two languages as complementary tools rather than rivals, and to the question &amp;ldquo;Should I learn Rust or Go?&amp;rdquo;, his answer is: learn both.&lt;/p&gt;
&lt;h2 id="the-most-popular-go-dependency-is"&gt;&lt;a href="https://blog.thibaut-rousseau.com/blog/the-most-popular-go-dependency-is/" rel="noopener noreferrer"&gt;The most popular Go dependency is…&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thibaut Rousseau sets out to find the most depended-upon library in the Go ecosystem by tapping into Go&amp;rsquo;s centralized module proxy infrastructure. Instead of cloning individual repositories, he downloaded the full module index from &lt;code&gt;index.golang.org&lt;/code&gt; (listing every module version published since the Go proxy launched in 2019), fetched each module&amp;rsquo;s &lt;code&gt;go.mod&lt;/code&gt; file via &lt;code&gt;proxy.golang.org&lt;/code&gt; to extract its dependencies, and loaded everything into a Neo4j graph database. The resulting graph contains roughly 40 million nodes and 400 million relationships, averaging about 10 direct dependencies per module version node in the dataset.&lt;/p&gt;
&lt;p&gt;Topping the leaderboard is &lt;code&gt;testify&lt;/code&gt; with 259,237 dependent modules, far ahead of the runners-up: &lt;code&gt;google/uuid&lt;/code&gt; (104,877), &lt;code&gt;golang.org/x/crypto&lt;/code&gt; (100,633), &lt;code&gt;grpc&lt;/code&gt; (97,228), &lt;code&gt;cobra&lt;/code&gt; (93,062), &lt;code&gt;pkg/errors&lt;/code&gt; (92,491), &lt;code&gt;golang.org/x/net&lt;/code&gt;, &lt;code&gt;protobuf&lt;/code&gt;, &lt;code&gt;logrus&lt;/code&gt;, and &lt;code&gt;viper&lt;/code&gt;. Testing and utility libraries dominate the list, alongside Go&amp;rsquo;s extended standard library packages (&lt;code&gt;golang.org/x/&lt;/code&gt;). Notably, even though &lt;code&gt;pkg/errors&lt;/code&gt; has been deprecated and archived for years, version &lt;code&gt;v0.9.1&lt;/code&gt; alone still had 16,001 transitive dependents in 2025. The post also demonstrates how to query Neo4j with Cypher to trace direct and transitive dependencies, showing how naturally graph databases fit dependency analysis. He shares the dataset dump via BitTorrent so the community can run their own queries and plans to enrich it with metadata like GitHub stars.&lt;/p&gt;
&lt;h2 id="gosum-is-not-a-lockfile"&gt;&lt;a href="https://words.filippo.io/gosum/" rel="noopener noreferrer"&gt;go.sum Is Not a Lockfile&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Filippo Valsorda clears up a widespread misconception: many developers treat &lt;code&gt;go.sum&lt;/code&gt; as a lockfile analogous to Node&amp;rsquo;s &lt;code&gt;package-lock.json&lt;/code&gt; or Rust&amp;rsquo;s &lt;code&gt;Cargo.lock&lt;/code&gt;, when in reality &lt;code&gt;go.sum&lt;/code&gt; is merely a local cache of the Go Checksum Database—a lookup table mapping module versions to their cryptographic hashes. Versions listed in &lt;code&gt;go.sum&lt;/code&gt; may or may not actually be used in a build, and the file plays zero role in version resolution; in the original Go modules design, it wasn&amp;rsquo;t even enabled by default because it has no effect on build selection. The sole purpose of &lt;code&gt;go.sum&lt;/code&gt; is security: the Checksum Database ensures the entire ecosystem receives identical bytes for a given module version, and &lt;code&gt;go.sum&lt;/code&gt; makes that guarantee work locally and offline.&lt;/p&gt;
&lt;p&gt;The file you actually want to look at is &lt;code&gt;go.mod&lt;/code&gt;, which serves as both manifest and lockfile. Since Go 1.17 (August 2021), &lt;code&gt;go.mod&lt;/code&gt; records every transitive dependency needed to build the main module and run its tests, pinned to exact versions in a single human-readable file. Combined with Minimal Version Selection (MVS), this lets Go avoid diamond dependency conflicts, prevents accidentally relying on features from newer transitive versions than declared, and never silently pulls the latest (potentially compromised) version of a package when adding a new dependency—all while making dependency resolution so fast that nobody even notices it. To analyze a Go dependency graph, parse &lt;code&gt;go.mod&lt;/code&gt; using &lt;code&gt;golang.org/x/mod/modfile&lt;/code&gt; or &lt;code&gt;go mod edit -json&lt;/code&gt;, and never parse &lt;code&gt;go.sum&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="forgejo-actions-notification-development"&gt;&lt;a href="https://chris-besch.com/articles/forgejo_actions_notification/" rel="noopener noreferrer"&gt;Forgejo Actions Notification Development&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christopher Besch shares his experience contributing to Forgejo, a self-hosted software forge similar to GitHub and GitLab. He needed email and webhook notifications when CI workflows failed—a feature Forgejo lacked—so he built it himself. The post explains how Go projects organize code into modules (via &lt;code&gt;go.mod&lt;/code&gt;) and packages without a central registry like npm, then walks through Forgejo&amp;rsquo;s layered architecture consisting of &lt;code&gt;/routers&lt;/code&gt; (APIs and web UI), &lt;code&gt;/services&lt;/code&gt; (business logic), &lt;code&gt;/models&lt;/code&gt; (database access), and &lt;code&gt;/modules&lt;/code&gt; (self-contained utilities), where lower layers are forbidden from importing higher layers. To avoid circular dependencies, Forgejo uses a publish–subscribe pattern in &lt;code&gt;forgejo.org/services/notify&lt;/code&gt;: packages publish events to a topic, and interested packages subscribe to it.&lt;/p&gt;
&lt;p&gt;He split the feature across four pull requests to keep reviews manageable: PR #7510 moved code from &lt;code&gt;/models/actions&lt;/code&gt; to &lt;code&gt;/services/actions&lt;/code&gt; to respect architectural boundaries, PR #7491 added an &lt;code&gt;ActionRunNowDone&lt;/code&gt; hook to the pub-sub notifier, PR #7509 subscribed the mailer service to send emails when workflows fail or recover, and PR #7508 added webhook delivery. He also recounts having to rename a struct due to a merge conflict with a parallel PR. The final section walks through setting up a local development environment: compiling Forgejo with debug symbols, running the Forgejo Runner, spinning up a MailDev SMTP server in Docker, writing a tiny Node.js webhook receiver script, and running unit tests, integration tests, and the Delve debugger. His takeaway: thorough tests are the key to earning maintainers&amp;rsquo; trust in your contributions.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;&lt;/p&gt;
&lt;p&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%2F3ec94ed4-46b2-40bd-8d28-a25fdde639c8_2250x2624.png" alt="Message Brokers 101"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!hXRV!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fe99863c7-7ab7-4f61-9961-af7e4c6ee64f.png" alt="Cloud Load Balancer Cheat Sheet"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!XvtW!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F1ded3402-4eb5-4818-861f-7661f1cefe82.tif" alt="How CQRS Works?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!SUjA!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fd91a5538-a69e-468c-bf83-058bb78753ca_2360x2770.png" alt="How does Docker Work?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!4qBZ!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Ff0945414-9cea-4e64-8dd4-3abcc404f73e_2360x2960.png" alt="Containerization Explained: From Build to Runtime"&gt;
&lt;img src="https://substackcdn.com/image/fetch/$s_!n8BK!,w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2Fa51a75cc-09a9-4fed-af8a-c32a64f8ab60_2250x2624.png" alt="Must-Know Message Broker Patterns"&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>