Author of the rpcx microservice framework, original book author, and chair of Baidu's Go CMC committee.
The article explains the distinction between a data race—simultaneous unsynchronized memory access by goroutines—and a race condition—logic errors caused by timing dependencies—using Go code examples, demonstrates how to reproduce each issue, and shows how mutexes or atomic operations can resolve them.
This article presents a comprehensive, step‑by‑step analysis of Go naming conventions, explaining why each rule matters, illustrating each point with concrete code snippets and real‑world examples, and showing how to apply the guidelines to variables, functions, packages, structs, interfaces, errors, constants, enums and comments for truly clean Go code.
This comprehensive guide walks through Go’s net package, detailing how Listener functions create servers, how Dial functions initiate client connections, the nuances of network and address formats, and the behavior of various Conn types such as TCPConn, UDPConn, IPConn, and RawConn, complete with code examples and best‑practice tips.
This article outlines a comprehensive guide to Go's concurrency model, covering fundamental concepts, goroutine scheduling, synchronization primitives, channel communication, common patterns, deadlock avoidance techniques, and performance‑optimizing mechanisms with concrete code examples and step‑by‑step explanations.
This article distills Chris Zimmeman's "Programming Rules" into twenty concrete guidelines—covering simplicity, bug containment, naming, generalization, deferred optimization, code reviews, debugging, refactoring, conventions, and more—each explained with its rationale and core takeaway for developers.
This article outlines a Rust programming book that starts with fundamental syntax, variables, and memory management, then progressively explores ownership, lifetimes, error handling, concurrency, async programming, traits, macros, and practical examples, providing code snippets and core concepts for each topic.
This article distills the key design patterns behind distributed systems—covering replication, partitioning, consensus, and fault‑tolerance—by presenting each pattern’s problem statement, concrete solution, trade‑offs, and technical considerations, all illustrated with real‑world examples from projects like Kafka and Cassandra.
This article walks through a Rust‑based implementation of classic Unix command‑line utilities—hello world, echo, cat, head, uniq, wc, find, grep, comm, ls, and more—showing project setup, Cargo usage, argument parsing with clap, error handling with Result, testing strategies, and code snippets for each tool.
This article examines five Go implementations of a broadcast notifier—using sync.Cond, channels, context, sync.WaitGroup, and sync.RWMutex—detailing their code, execution flow, and trade‑offs so readers can understand how each primitive achieves notification broadcasting.
The article compares Go’s stackful, green‑thread model with Rust’s stackless, future‑based approach, explaining how each runtime schedules tasks, the memory overhead of goroutine stacks (2 KiB minimum in Go 1.22), the challenges of async‑await integration, and why Rust’s performance gains come with a fragmented ecosystem.
