Effective Go Recipes Fast Solutions to Common Tasks (Miki Tebeka)（Z-Library）

# Effective Go Recipes: Fast Solutions to Common Tasks ## 【One-Line Pitch】 A practical recipe book for Go developers who want to move beyond syntax and master idiomatic patterns for real-world tasks—from file I/O and serialization to concurrency and text processing. Perfect for intermediate Go programmers who learn best by solving concrete problems. ## 【Book Arc】 - **Opening (~0%–6%)**: Introduces the book's philosophy—Go is simple but has an "art" to using it effectively—then dives straight into file operations with a janitor utility that compresses and verifies log files, establishing the recipe-based, task-first format. - **Early (~6%–19%)**: Covers I/O patterns (building SQL queries with bytes.Buffer, implementing custom io.Writer types) and serialization (JSON, gob, custom types, struct tags), showing how to handle data transformation and streaming. - **Early (~19%–28%)**: Moves into HTTP servers—timeouts, API versioning, and protecting against malicious input—then transitions to text processing with logging, encoding detection, and string normalization. - **Early (~28%–34%)**: Explores first-class functions as a core design tool, including function registries for extensible systems and passing functions for task execution and notification patterns. - **Middle (~38%–47%)**: Covers advanced topics like compiler directives (go:linkname), the comma-ok paradigm for maps/channels/type assertions, and memory management patterns for slices and stacks, including append growth behavior and leak prevention. ## 【Key Takeaways】 - **Task-first learning format** (Opening): Each recipe presents a realistic business scenario (like an ops team requesting a log janitor) before the solution, making patterns memorable and immediately applicable to your own work. - **bytes.Buffer for string building** (Early): When generating SQL or similar structured output, bytes.Buffer with fmt.Fprintln is cleaner and more efficient than string concatenation—plus it naturally handles edge cases like trailing commas. - **Custom io.Writer implementations** (Early): Implementing the Writer interface (like the DigitsFreq example) lets you process streaming data incrementally without loading everything into memory, a pattern useful for parsing and analysis. - **JSON field tags and anonymous structs** (Early): Use struct tags to map between Go and JSON naming conventions, and prefer anonymous structs for one-off API responses to avoid namespace pollution. - **Custom MarshalJSON/UnmarshalJSON** (Early): When your Go type doesn't map naturally to JSON (like a linked-list stack), convert to a JSON-compatible type first, then use the built-in marshaler—and remember to implement UnmarshalJSON on a pointer receiver. - **Function registries for extensibility** (Early): Storing functions in a map keyed by format (JSON, CSV, XML) lets you add new output formats without touching core handler code—the same pattern powers http.HandleFunc and database/sql drivers. - **Comma-ok paradigm** (Middle): The `value, ok :=` pattern works for maps, channel receives, and type assertions—it's the only reliable way to distinguish zero values from missing data and prevents panics. - **Slice capacity management** (Middle): append grows slices by doubling up to 1024 elements, then ~1/3 thereafter; pre-allocating with make(len, cap) avoids memory bloat, and shrinking slices when len < cap/2 prevents memory leaks. ## 【Reading Tips】 - **Skim the task descriptions, focus on solutions**: Each recipe opens with a business scenario—read these quickly to understand the problem, then study the code and discussion sections where the real insights live. - **Deep-read the "Discussion" sections**: These contain the transferable wisdom (like why comma-ok matters or how append growth works) that separates recipe-following from actual understanding. - **Watch for the "code smell" warnings**: The author flags anti-patterns (like using `any` unnecessarily) and explains why—these are the lessons that will improve your code review skills. - **Try the exercises mentally**: Before reading each solution, think about how you'd approach the task; the gap between your approach and the author's is where learning happens. - **Skip around by topic**: The book is modular—if you're working on serialization, jump to that chapter; if concurrency is your focus, find those recipes without reading linearly. ## 【Coverage Limits】 The excerpts cover roughly the first half of the book (through basic types and memory management). Later chapters on concurrency, Unicode handling, and advanced networking—mentioned in the blurb—are not represented in this guide's source material. ##