Go by Example (Inanc Gumus)（Z-Library）

# Go by Example — Reading Guide ## 【One-Line Pitch】 A practical, project-driven guide for experienced developers who want to master idiomatic Go through building, testing, and refining a real-world HTTP client tool — ideal for those ready to move beyond syntax into Go's philosophy of simplicity, composition, and testability. ## 【Book Arc】 - **Opening (~0%–10%)**: Establishes the book's audience and philosophy — experienced developers from Java, C++, Python, or JavaScript who need to "unlearn" habits that conflict with Go's design. Introduces core concepts like goroutines, channels, and the "share memory by communicating" principle, setting the foundation for idiomatic thinking. - **Early (~10%–23%)**: Dives deep into testing fundamentals — table-driven tests, subtests, coverage measurement, and benchmarking. Uses a URL parsing package as the working example, showing how to structure tests, measure coverage with `coverprofile`, and compare benchmark results using `benchstat`. - **Early (~23%–32%)**: Transitions to building the HIT tool — a command-line HTTP client. Starts with manual flag parsing using `os.Args` to explore language mechanics, then adopts the `flag` package. Refactors the tool to decouple from global state using `io.Writer` interfaces, making it testable without changing behavior. - **Middle (~32%–42%)**: Introduces iterators and concurrent pipelines. Shows how to design a `Results` iterator using closures and yield functions, then refactors the HIT client to use a concurrent pipeline with producer, throttler, and dispatcher stages connected through channels. - **Middle (~42%–48%)**: Covers panic testing with `recover`, then moves into HTTP client testing — using `httptest`, `RoundTripper` for intercepting requests, and testing clients against servers. Emphasizes cancellation propagation using the `context` package to prevent goroutine leaks. - **Late (~48%–end)**: Focuses on structuring packages and services — avoiding import cycles, organizing code into core/service layers, and building HTTP servers with handlers, routing via `ServeMux`, health checks, and proper status codes. The excerpts do not cover the final chapters in detail. ## 【Key Takeaways】 - **Idiomatic Go requires unlearning** (Early): Code should be pragmatic, explicit, and testable — not speculative or over-abstracted. The book's core message is that simplicity is hard to achieve but essential for maintainable Go programs. - **Table-driven tests are the idiomatic standard** (Early): Separating test data from logic reduces duplication and makes adding new cases trivial. Subtests ensure one failure doesn't halt the entire test suite, as each subtest runs independently. - **Benchmarking requires comparison, not absolutes** (Early): Use `benchstat` to compare old and new implementations statistically. Coverage tools like `coverprofile` help identify untested code paths, but coverage alone doesn't guarantee quality. - **Decoupling from global state enables testability** (Early): Injecting dependencies like `io.Writer` (instead of using `os.Stdout` directly) allows the same code to run with real or fake outputs. This pattern is central to writing testable CLI tools. - **Iterators invert control flow** (Middle): Using closures as iterators — where the producer pushes values to a consumer's yield function — enables lazy, composable data processing. The Go compiler's built-in support for iterators simplifies this pattern. - **Concurrent pipelines need explicit cancellation** (Middle): Without `context` propagation, pipelines can leak goroutines when consumers stop early. Passing a `Context` through pipeline stages enables graceful shutdown, such as handling Ctrl+C. - **Panic and recover are test-only tools** (Middle): Use `recover` in tests to verify panic behavior, but avoid it in production code — explicit error handling is more maintainable than disrupting control flow. - **Package structure prevents import cycles** (Late): Organizing code into core, service, and HTTP layers with clear boundaries avoids circular imports and keeps dependencies flowing in one direction. ## 【Reading Tips】 - **Skim the opening philosophy sections** (~0%–5%) if you're already convinced about Go's value — the real substance starts with testing in section 2. - **Deep-read the testing chapters** (~10%–23%) — they're foundational for everything that follows. Pay special attention to table-driven tests and subtests; these patterns recur throughout the book. - **Follow the HIT tool project closely** (~23%–48%) — it's the book's spine. Each refactoring step (flag parsing → dependency injection → iterators → pipelines → context) builds on the previous one, so skipping ahead will confuse you. - **Watch for "Deep Dive" boxes** — they explain language mechanics (like variadic function backing arrays and closure memory management) that clarify why Go behaves as it does. - **Try the exercises at each chapter's end** — the book is explicitly practical, and the exercises reinforce the patterns before you move to the next layer of complexity. ## 【Coverage Limits】 This guide covers the book's progression through testing, CLI tooling, iterators, concurrent pipelines, HTTP testing, and package structuring. The excerpts do not cover the final chapters on advanced HTTP server patterns, routing details, or the book's concluding exercises in depth. ##