Stdlib on

Lesson 8: strings and bytes Builders — Stop concatenating in loops

Sat, 05 Jul 2025 00:00:00 +0000

String concatenation with + is one of the most common performance bugs I see in Go code reviews. Not because developers are careless, but because the bug is invisible — the code looks clean and correct. result += piece is obvious. The quadratic memory behavior that follows is not.

The strings and bytes packages are where Go provides the right tools for this job. strings.Builder and bytes.Buffer are both efficient for incremental string construction, but they’re not the same type and the choice between them matters in specific cases. Beyond building strings, these packages contain functions that have non-obvious but significant performance implications: strings.Contains vs strings.Index, strings.Split vs strings.SplitN, and the ones people reach for that they shouldn’t.

Lesson 7: context Internals — How cancellation propagates under the hood

Thu, 22 May 2025 00:00:00 +0000

context.Context is the most important type in Go’s standard library that most people use by convention without fully understanding. You pass it as the first argument to functions. You check ctx.Done() in goroutines. You create derived contexts with context.WithTimeout. It works — until it doesn’t, and you have a goroutine that doesn’t cancel when the parent context does, or a context that leaks forever because you forgot to call the cancel function.

Lesson 6: sync Package Complete Guide — Mutex, Once, Pool, Map — when to use each

Sat, 22 Mar 2025 00:00:00 +0000

The sync package is where Go’s concurrency tools live when channels aren’t the right answer. sync.Mutex, sync.RWMutex, sync.WaitGroup, sync.Once, sync.Pool, sync.Map — each one solves a specific problem, and using the wrong one is a reliable way to introduce bugs or performance regressions. I’ve misused all of them at various points.

The general guidance is channels for communication, mutexes for protecting shared state. But within the mutex family, the choice between Mutex, RWMutex, and sync.Map has performance implications that matter in hot paths. And sync.Pool is frequently misunderstood — it’s not a general-purpose object pool; it’s a GC-aware buffer recycler.

Lesson 5: os and filepath — Cross-platform file operations that actually work

Wed, 22 Jan 2025 00:00:00 +0000

Go’s os and path/filepath packages are among the most underappreciated in the standard library. Most developers know os.Open, os.Create, and os.ReadFile. Far fewer know os.MkdirAll, os.CreateTemp, filepath.WalkDir, or the difference between path and path/filepath — which is the difference between code that works everywhere and code that silently breaks on Windows.

I maintain a CLI tool that runs on macOS, Linux, and Windows. The file operation bugs I’ve shipped have taught me exactly which parts of these packages require care.

Lesson 4: time Package Gotchas — Timezones, monotonic clocks, and the bug in your cron

Mon, 18 Nov 2024 00:00:00 +0000

The time package looks straightforward right up until the moment a bug report arrives saying “the nightly job didn’t run last Sunday.” It never runs on the Sunday when daylight saving time ends. Because that Sunday has 25 hours, and the cron expression fires twice at the ambiguous time, and the second firing is skipped because the code thinks it already ran. I’ve debugged this exact bug, and the root cause is always the same: someone — usually me — assumed time is simpler than it is.

Lesson 10: Conversion Traits — From, Into, TryFrom, AsRef

Tue, 08 Oct 2024 15:30:00 +0000

I used to litter my Rust code with .to_string(), as, and manual conversion functions everywhere. Then I learned the conversion traits properly and my APIs went from clunky to clean. These traits are the glue that makes Rust code feel ergonomic — and understanding when to implement each one is the difference between a library that’s pleasant to use and one that makes people curse your name.

From and Into — Infallible Conversion

From<T> defines how to create a type from another type. It can’t fail. If there’s any possibility of failure, you want TryFrom instead.

Lesson 9: std::sync — Mutex, RwLock, Once, Barrier

Fri, 04 Oct 2024 13:25:00 +0000

I shipped a data race to production exactly once. Go program, shared map, no lock. Took three weeks to reproduce — only happened under heavy load when two goroutines hit the same key simultaneously. The crash dump was useless. In Rust, that code wouldn’t have compiled. That’s not marketing — it’s literally how the type system works.

Arc — Shared Ownership Across Threads

Before we talk about locks, we need Arc. You can’t share data between threads with just Rc — it’s not thread-safe. Arc (Atomic Reference Counted) is the thread-safe version.

Lesson 8: std::time — Duration, Instant, SystemTime

Tue, 01 Oct 2024 07:50:00 +0000

A few months ago I tracked down a bug where a cache TTL check was wrong because someone compared SystemTime values that had been serialized and deserialized across a system clock adjustment. The cached timestamps jumped backward, and suddenly entries that should’ve expired were “fresh” again. That’s the kind of lesson that teaches you the difference between monotonic clocks and wall clocks.

Two Clocks, Two Types

Rust gives you two time types because computers have two fundamentally different clocks:

Lesson 3: encoding/json Beyond Basics — Custom marshalers, streaming, and the traps

Mon, 30 Sep 2024 00:00:00 +0000

encoding/json is one of the first packages every Go developer uses and one of the last they fully understand. The basic json.Marshal / json.Unmarshal API is approachable. But the package contains a whole layer of capabilities — custom marshaling, streaming decoders, json.RawMessage for deferred parsing, interface-type fields, and a surprising number of edge cases — that separate the code that works in demos from the code that works in production with adversarial inputs.

Lesson 7: std::process — Running external commands

Sun, 29 Sep 2024 19:15:00 +0000

I once wrote a deployment script in Bash that grew to 800 lines with nested conditionals, string interpolation bugs, and error handling that amounted to “hope for the best.” Rewrote it in Rust using std::process::Command — same functionality, but with actual error handling and type safety. The number of failed deployments dropped to zero.

Command — The Builder

std::process::Command is a builder for spawning child processes. You construct the command, configure it, then either run it to completion or spawn it and interact with its I/O.

Lesson 6: std::net — TCP, UDP, sockets

Fri, 27 Sep 2024 09:40:00 +0000

The first network program I ever wrote — a chat server in college — had a bug where it would block forever waiting for one client’s message while all the other clients hung. Classic single-threaded socket mistake. Rust’s std::net module gives you the same low-level socket primitives, but the ownership system actually helps you avoid some of those pitfalls.

TCP — The Reliable One

TCP gives you ordered, reliable byte streams. You connect, you send bytes, they arrive in order (or the connection dies trying). That’s the deal.

Lesson 5: std::fmt — Formatting internals

Tue, 24 Sep 2024 11:05:00 +0000

I once shipped a monitoring dashboard where all the latency values showed up as “Duration { secs: 0, nanos: 234000000 }” because I’d used {:?} instead of implementing Display. That’s the kind of thing that makes you sit down and actually learn how formatting works.

Display vs. Debug

These two traits are the foundation of everything in std::fmt. Every time you use println!, format!, or write!, you’re invoking one of them.

Lesson 4: std::fs and std::path — Filesystem operations done right

Sat, 21 Sep 2024 16:10:00 +0000

A colleague once deployed a script that used string concatenation for file paths: dir + "/" + filename. Worked perfectly on Linux, blew up on Windows, and silently corrupted paths when dir ended with a slash. Rust’s Path type exists specifically to prevent this class of bug.

Path vs. PathBuf — The &str/String Split

Just like Rust has &str (borrowed) and String (owned), it has &Path (borrowed) and PathBuf (owned). The duality is identical:

Lesson 3: std::io — Read, Write, BufRead, Seek

Thu, 19 Sep 2024 08:30:00 +0000

Early in my Rust journey, I wrote a log parser that read a 2GB file byte by byte using read() without buffering. It took forty minutes. Adding a BufReader wrapper — one line of code — brought it down to three seconds. That’s when I learned that understanding std::io isn’t optional.

The Four Core Traits

Rust’s I/O system is built on four traits. Everything — files, network sockets, stdin, pipes, in-memory buffers — implements some combination of these:

Lesson 2: Iterator Trait and Adapters — The full picture

Tue, 17 Sep 2024 14:45:00 +0000

The moment Rust iterators clicked for me was when I realized they’re not loops with extra steps — they’re a completely different way of expressing data transformations. I’d been writing imperative loops for fifteen years, and the first time I refactored a gnarly nested-loop function into an iterator chain, the result was half the lines and twice as readable.

The Iterator Trait

Everything starts here. The Iterator trait is shockingly simple:

Lesson 1: Collections Deep Dive — Vec, VecDeque, BTreeMap and when to use which

Sun, 15 Sep 2024 10:22:00 +0000

I spent two days debugging a performance cliff in a data pipeline — turns out I’d been using a HashMap where a BTreeMap would’ve cut iteration time in half because I needed sorted output downstream. The collection you pick matters more than most people think.

The Big Picture

Rust’s standard library ships a small but deliberate set of collections. Unlike languages that give you seventeen flavors of list, Rust gives you a few well-designed options and expects you to understand the trade-offs. That’s actually a feature — fewer choices means you can develop genuine intuition about when to use what.

Lesson 2: io Patterns — Reader, Writer, and the composability that makes Go great

Fri, 16 Aug 2024 00:00:00 +0000

The io package is three hundred lines of interface definitions and a handful of utility functions. It is also the spine of the entire Go standard library. Every package that reads or writes data — os, net, compress/gzip, crypto/tls, encoding/json, bufio — does it through io.Reader and io.Writer. Once you understand these two interfaces, the standard library clicks into place as one coherent system.

I spent my first few months with Go treating io.Reader as the thing that HTTP response bodies happen to be. It wasn’t until I built a streaming CSV processor — piping data from S3 through gzip decompression into a CSV parser, all without loading the file into memory — that I understood what the interfaces were actually designed for.

Lesson 1: net/http Deep Dive — The most important package you use wrong

Tue, 02 Jul 2024 00:00:00 +0000

Every Go web service I’ve reviewed starts with net/http. Most of them use it correctly for the obvious parts and incorrectly for the subtle ones. The package API is deceptively simple — http.HandleFunc, http.ListenAndServe, and you’re serving HTTP. But the design decisions underneath — how request routing works, what a Handler actually is, how the server manages connections, what the default timeouts are — contain enough traps to keep a senior engineer busy for a week.