Formal Methods for Critical Systems
A bounded, explicit case study in modeling versioned object deletion with TLA+, connecting invariants to Rust and object-storage semantics, and stating what was—and was not—proved.
Engineering notes by Haili Zhang
Notes on building software systems.
Practical writing about Rust, distributed systems, storage engines, and the data structures beneath them.
Posts
ClickHouse Internals
A source-guided tour of ClickHouse columns, MergeTree parts, sparse indexes, query plans, processor pipelines, aggregation, and distributed execution.
Distributed Aggregation in Data Federation
How to push aggregation into heterogeneous sources without losing algebraic, SQL, consistency, or failure semantics.
Ten New and Notable Rust Crate Releases from 2025
A historically versioned review of Rust libraries and frameworks that made meaningful releases in 2025.
Extending Envoy with Rust and Proxy-Wasm
A precise guide to the Proxy-Wasm execution model, a Rust HTTP filter, Envoy configuration, and the production constraints that matter.
Write-Ahead Logs, Commit Indices, and Retention Watermarks
How durability logs, replicated commit boundaries, and retention watermarks work together without conflating persistence, consensus, visibility, and safe log cleanup.
Understanding io_uring in Rust
A systems-level guide to io_uring submission and completion queues, ownership, registered resources, batching, and the Rust abstractions that make completion-based I/O safer.
Zero-Copy in Rust
A practical look at borrowing, shared buffers, memory mapping, zero-copy parsing, and kernel-assisted I/O—and what zero-copy really means at each boundary.
Building Modular Systems with Rust Traits and Generics
A compileable, testable guide to defining stable boundaries with traits, associated types, static dispatch, and trait objects.
Ten Rust Crates That Shaped My 2024
A historically versioned review of ten Rust libraries that shaped practical application, CLI, database, observability, and analytical development in 2024.
Taming the Beast: How Rust Helps Manage Growing Software Complexity
In today's software landscape, systems are becoming increasingly complex. From distributed microservices to real-time data processing pipelines, developers face mounting challenges in maintaining reliable, performant,…
Building Resilient Distributed Storage Systems: The Power of Logging Patterns
In my previous blog posts about LSM Trees , we explored how log-structured storage engines can efficiently handle write-heavy workloads. Today, we'll dive deeper into how various logging patterns serve as the backbone…
The Ultimate Rust Learning Path: From Beginner to Pro
If you've been following my blog, you've probably noticed a series of articles detailing the implementation of various algorithms, data structures, and design patterns in Rust. While these deep dives are undoubtedly…
LSM Trees Unveiled — Part 3: Completing the Rust Implementation
Welcome to the final part of our series on Log-Structured Merge (LSM) trees. In Part 1 , we explored the core concepts of LSM trees. Part 2 dove into the implementation of key components: the MemTable and SSTable. Now,…
LSM Trees Unveiled — Part 2: Efficient Rust Implementation
An efficient Rust implementation of the MemTable and SSTable components of an LSM tree.
LSM Trees Unveiled — Part 1: Core Concepts and Components
Log-Structured Merge (LSM) trees are a powerful data structure that underlies many modern database systems, including LevelDB, RocksDB, Cassandra, and ClickHouse's MergeTree engine. In this two-part blog series, we'll…
Understanding the Gossip Protocol in Distributed Systems
In the world of distributed systems, maintaining consistency and reliability across multiple nodes is a significant challenge. One elegant solution to this problem is the Gossip Protocol. In this blog post, we'll…
Data Sketches: Efficient Algorithms for Big Data Analysis
In the era of big data, processing and analyzing massive datasets has become a significant challenge. Traditional algorithms often struggle with the sheer volume of information, leading to impractical computation times…
Microservice Governance — Deployment Patterns
Traffic channels, pre-release testing, canary rollout, and A/B testing: using isolated instance sets plus dynamic routing to make production change safer.
Microservice Governance — Resilience Patterns — Part 2
Circuit breakers, fallbacks, and bulkheads: how to fail fast, degrade gracefully, and keep one failing dependency from consuming the whole system.
Microservice Governance — Resilience Patterns — Part 1
Client-side load balancing, retries, backoff, jitter, and timeouts: the first layer of containing failure in a distributed microservice system.
Microservice Governance — Routing Patterns
How service discovery and dynamic routing turn a changing fleet of microservice instances into stable, policy-driven service communication.
No posts match that search.
About
SoftWheel is a collection of implementation notes from rebuilding core systems and data structures. The goal is to expose the decisions that polished libraries usually hide.
Topics include storage engines, concurrency, distributed protocols, Rust, and production engineering.