Enjoy Newsletter #77.

Stop Forwarding Errors, Start Designing Them

This article argues that most Rust developers merely “forward” 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: std::error::Error assumes a linear chain of causes via source() 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, thiserror categorizes errors by origin rather than by how callers can react, anyhow makes adding context optional so it is routinely skipped, and the dynamic Provide/Request API makes behavior hard to predict.

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’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 #[track_caller] at near-zero cost and enforces adding context across module boundaries through the type system (as in the exn crate). The guiding question when designing errors should be: “If the system breaks at 3 a.m., what do you want the logs to say?”

Clock Synchronization Is a Nightmare

This post explains why synchronizing time across distributed systems is far harder than intuition suggests: there simply is no “global clock.” 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 make 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.

Physical clock synchronization techniques include Cristian’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’s TrueTime returns a bounded uncertainty interval [earliest, latest] 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’s needs.

Java - Learning Roadmap

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.

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.

The Ultimate Guide to Successfully Adopting Kotlin in a Java-Dominated Environment

JetBrains’ 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’t at risk, answering the question, “Is this language genuinely nicer to work with?” 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 “writing Java in Kotlin syntax”: use extension functions instead of static utility classes, nullable types instead of Optional, and data classes instead of boilerplate POJOs.

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.

Rust vs Go

John Arundel compares Rust and Go across performance, simplicity, safety, features, scalability, and concurrency, summing up the trade-off in a single phrase: “Rust for high stakes, Go for low cost.” Both are compiled languages that produce small, fast native binaries and come with great built-in tooling (gofmt, rustfmt). 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.

For error handling, Go uses explicit if err != nil checks, while Rust uses Option/Result types paired with the ? 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 “Should I learn Rust or Go?”, his answer is: learn both.

Thibaut Rousseau sets out to find the most depended-upon library in the Go ecosystem by tapping into Go’s centralized module proxy infrastructure. Instead of cloning individual repositories, he downloaded the full module index from index.golang.org (listing every module version published since the Go proxy launched in 2019), fetched each module’s go.mod file via proxy.golang.org 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.

Topping the leaderboard is testify with 259,237 dependent modules, far ahead of the runners-up: google/uuid (104,877), golang.org/x/crypto (100,633), grpc (97,228), cobra (93,062), pkg/errors (92,491), golang.org/x/net, protobuf, logrus, and viper. Testing and utility libraries dominate the list, alongside Go’s extended standard library packages (golang.org/x/). Notably, even though pkg/errors has been deprecated and archived for years, version v0.9.1 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.

go.sum Is Not a Lockfile

Filippo Valsorda clears up a widespread misconception: many developers treat go.sum as a lockfile analogous to Node’s package-lock.json or Rust’s Cargo.lock, when in reality go.sum is merely a local cache of the Go Checksum Database—a lookup table mapping module versions to their cryptographic hashes. Versions listed in go.sum 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’t even enabled by default because it has no effect on build selection. The sole purpose of go.sum is security: the Checksum Database ensures the entire ecosystem receives identical bytes for a given module version, and go.sum makes that guarantee work locally and offline.

The file you actually want to look at is go.mod, which serves as both manifest and lockfile. Since Go 1.17 (August 2021), go.mod 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 go.mod using golang.org/x/mod/modfile or go mod edit -json, and never parse go.sum.

Forgejo Actions Notification Development

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 go.mod) and packages without a central registry like npm, then walks through Forgejo’s layered architecture consisting of /routers (APIs and web UI), /services (business logic), /models (database access), and /modules (self-contained utilities), where lower layers are forbidden from importing higher layers. To avoid circular dependencies, Forgejo uses a publish–subscribe pattern in forgejo.org/services/notify: packages publish events to a topic, and interested packages subscribe to it.

He split the feature across four pull requests to keep reviews manageable: PR #7510 moved code from /models/actions to /services/actions to respect architectural boundaries, PR #7491 added an ActionRunNowDone 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’ trust in your contributions.

Bonus

Images:

Message Brokers 101 Cloud Load Balancer Cheat Sheet How CQRS Works? How does Docker Work? Containerization Explained: From Build to Runtime Must-Know Message Broker Patterns


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.