Go in Practice (Matt Butcher, Matt Farina)（Z-Library）

【One-Line Pitch】 A cookbook-style guide to the practical, production-grade side of Go: 70 techniques for package management, concurrency, web services, testing, and cloud-native deployment. Best for developers who already know Go basics and want the dirt-under-the-fingernails patterns for real applications. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's philosophy — Go as a simple, concurrency-first systems language — and sets expectations for a Problem/Solution/Discussion format aimed at production readiness rather than language fundamentals. - **Early (~10%–30%)**: Builds the "solid foundation" layer: goroutines and the scheduler, `go test` tooling, GNU/UNIX-style command-line flags, configuration parsing (INI and similar), and graceful server shutdown. - **Middle (~30%–50%)**: Moves into concurrency mechanics — yielding to the scheduler, `sync.WaitGroup` for coordinating goroutines, and the pitfalls of assuming goroutines have finished — plus URL routing and handler wiring for web servers. - **Late (~50%–90%)**: Shifts toward cloud and network concerns: building for the cloud, cross-compiling, runtime monitoring, and communication between services (excerpts only partially cover this stretch). - **Ending (~90%–100%)**: Culminates in microservices and high availability, including making REST communication faster and connecting distributed services (excerpts are thin here). 【Key Takeaways】 - **Goroutines are the core concurrency primitive** (Early): lightweight functions scheduled across OS threads and cores, making concurrent code feel like ordinary procedural code. - **Don't assume a goroutine has run** (Middle): `runtime.Gosched` only yields; it does not guarantee completion, so `sync.WaitGroup` is the reliable way to wait for workers. - **Graceful shutdown prevents data loss** (Middle): the standard `http` server shuts down abruptly, so packages like `manners` (using `WaitGroup` and OS signals) are needed to drain connections cleanly. - **Use libraries, not forks, for CLI flags** (Early): GNU-style flag parsing is a solved problem — importing packages like `gnuflag` beats maintaining a modified standard `flag` package. - **Configuration parsing maps files to structs** (Early): third-party packages (e.g., `gcfg`) parse INI/JSON into typed structs, mirroring the standard library's JSON approach. - **Testing is built in and cheap** (Early): `go test` runs `Test*` functions, reports failures with file and line, and `go test ./...` covers nested packages. - **Cloud deployment is a first-class concern** (Late): cross-compiling and runtime monitoring are treated as routine production techniques, not afterthoughts. - **Microservice communication shapes architecture** (Ending): high availability and faster REST communication between services are the book's culminating themes. 【Reading Tips】 - Skim the Opening if you already know Go syntax; the real value starts with the foundation and concurrency chapters. - Deep-read the concurrency section (goroutines, `WaitGroup`, scheduler yielding) — these are the concepts most likely to cause subtle production bugs. - Treat the book as a reference: jump to the technique matching your current problem rather than reading linearly. - Pay attention to the Discussion portions, not just Solutions — they explain trade-offs and when a technique is inappropriate. - Note the library recommendations (gnuflag, gcfg, manners) as a starting toolkit for production Go. 【Coverage Limits】 The excerpts cover the book's framing, foundational techniques, and concurrency well, but the cloud, monitoring, and microservice chapters are only partially represented — specific techniques there are not fully detailed in this guide.