Go in Action, Second Edition MEAP V09 (Joel Holmes, Andrew Walker, William Kennedy)（Z-Library）

【One-Line Pitch】 A hands-on guide that takes experienced programmers from Go's core syntax to real-world applications, with a strong emphasis on the type system, concurrency, and idiomatic project structure. Best suited for developers fluent in another object-oriented language who want to write production-grade Go quickly. 【Book Arc】 - **Opening (~0%–10%)**: Makes the case for Go as a bridge between fast-but-tedious languages (C/C++) and quick-but-slow ones (Ruby/Python), then walks through toolchain setup and the modern Go Modules workflow that replaced GOPATH. - **Early (~10%–30%)**: Builds a complete word-counting program from scratch, teaching short variable declarations, scope and shadowing, comments, command-line arguments, and the `io` interface family (Reader, Writer, Seeker, Closer) along the way. - **Early–Middle (~30%–48%)**: Dives into the type system — integer and floating-point literals, arithmetic and bitwise operators, structs, strings and runes, then arrays with their fixed-size semantics and `range` iteration. - **Middle (~48%–60%)**: Moves into slices and slice expressions, showing how to pass subsets of data to functions and why slices are the idiomatic dynamic collection in Go. - **Late (~60%+)**: Excerpts do not cover the later chapters in detail, but the book's stated scope includes concurrency (goroutines and channels), error handling, testing, and observability. - **Ending**: Excerpts do not cover the closing chapters; the blurb indicates the book culminates in building real-world applications such as websites and network servers. 【Key Takeaways】 - **Go trades feature count for clarity** (Opening): Few keywords, a concise syntax, and a type system built on composition rather than rigid inheritance — the language is defined as much by what it omits as what it includes. - **Fast compilation and built-in concurrency are the headline wins** (Opening): The compiler is fast enough to feel invisible, and goroutines plus channels let software scale without third-party threading libraries. - **Go Modules replaced the old GOPATH workflow** (Early): `go mod init` creates a `go.mod` file with module and go directives, and the package/checksum databases make dependency disappearance unlikely — a major improvement over the gb/glide/dep era. - **Shadowing is a subtle, common bug source** (Early): A short declaration inside an `if` block creates a new variable rather than assigning the outer one; many editors warn about this, so heed them. - **The `io` interfaces are the connective tissue of Go I/O** (Early): Reader, Writer, Seeker, Closer, and their combinations establish conventions that let your own types plug into the standard library's I/O machinery. - **Always check slice length before indexing** (Early): The book stresses `len` checks before accessing arbitrary elements — a small habit that prevents panics. - **Arrays are fixed and value-copied; slices are the flexible workhorse** (Middle): Arrays cannot change length or element type after declaration, and `range` yields copies, so modifying loop values does not affect the original. - **Floating-point types force an explicit choice** (Early): There is no architecture-dependent `float`; you must pick `float32` or `float64` because bit size matters for precision. 【Reading Tips】 - **Deep-read the early chapters** (~10%–30%) even if you know another language — the word-count program is where Go's idioms (short declarations, interfaces, error returns) click into place. - **Skim the literal and operator tables** in the type-system chapter if you already know C-family syntax; focus instead on Go-specific quirks like `&^`, no plain `float`, and integer division by zero panicking at runtime. - **Pay close attention to the array vs. slice distinction** — it is a frequent source of bugs for newcomers, especially the value-copy behavior of `range`. - **Treat the `io` interface section as reference material** you will return to when writing file or network code. - **Note that the excerpts stop around the slice chapter**, so plan to read the concurrency, error-handling, and testing chapters directly in the book. 【Coverage Limits】 This guide covers roughly the first half of the book (through slices); the concurrency, error handling, testing, and observability chapters promised in the blurb are not represented in the excerpts and are described only at the level of the book's stated scope.