Webapps in Go (Suraj Patil)（Z-Library）

【One-Line Pitch】 A hands-on tour of building real web applications in Go, from language fundamentals through databases, forms, authentication, and APIs. Best for developers who already know another language and want a practical, code-first path into Go web development. 【Book Arc】 - **Opening (~0%–10%)**: Environment setup, Go tooling (`go build`, `go install`, cross-compilation), and the "why Go" rationale—fast, formatter-driven, built for large teams and multi-core/networking era software. - **Early (~10%–32%)**: Core language fundamentals—variables, data structures (arrays, slices, maps), `make` vs `new`, control flow, functions, error handling via `if err != nil`, panic/recover, and structs with embedding. - **Middle (~32%–50%)**: Object-oriented Go—methods, pointer receivers, method inheritance through embedding, interfaces, reflection, and the start of concurrency with goroutines and channels (buffered and unbuffered). - **Late (~50%–75%)**: Applied web work—database access (NULLs, unknown columns, connection pooling, antipatterns, encapsulation), forms with CSRF protection, input validation, and file uploads. - **Ending (~75%–100%)**: Templates and sub-templating, authentication (cookies, sessions, users, files), routing, middleware, and building a JSON API with JWT and API calls. 【Key Takeaways】 - **Go's tooling is a first-class feature** (Opening): `go build` produces statically linked binaries, ignores `*_test.go` files, and supports cross-compilation via `GOOS`—a deliberate design choice for team scalability. - **Slices are reference types with three parts** (Early): pointer, length, and capacity; changes to one slice affect others sharing the underlying array, and expanding beyond capacity requires care. - **`make` vs `new` serve different purposes** (Early): `make` initializes slice/map/channel with usable values; `new` returns a pointer to a zero-value. Confusing them is a common early mistake. - **Error handling is explicit, not exception-based** (Early): Go has no try-catch; you handle errors via `if err != nil` ladders, and `panic`/`recover` are reserved for truly exceptional cases. - **Interfaces are satisfied implicitly** (Middle): a type implements an interface by having the right methods—no declaration needed—enabling flexible, decoupled design. - **Channels synchronize goroutines by blocking** (Middle): unbuffered channels block until sender and receiver meet; buffered channels allow limited queuing, which shapes concurrency patterns. - **Database work has real pitfalls** (Late): NULL handling, unknown columns, connection pool behavior, and database-specific syntax are covered alongside encapsulation patterns. - **Web security is built in, not bolted on** (Late): CSRF protection, input validation, sessions, and JWT-based API auth are treated as core web concerns. 【Reading Tips】 - **Skim the language fundamentals if you know another language**: the early chapters on variables, loops, and functions move fast; focus instead on Go-specific idioms like `:=`, slices, and error handling. - **Deep-read the concurrency and interface sections**: these are where Go's design philosophy pays off and where most cross-language confusion occurs. - **Treat the database and forms chapters as reference**: the antipatterns and limitations sections (resource exhaustion, connection state mismatch, multiple result sets) are worth revisiting when you hit real problems. - **Do the homework exercises**: they appear at chapter ends and reinforce the practical, build-it-yourself approach. - **Follow the API chapter end-to-end**: JWT, routing, and middleware together form the capstone of the book's web application narrative. 【Coverage Limits】 The excerpts cover the table of contents and substantial portions of the language, concurrency, database, and web chapters, but do not include full code for every section or the complete API implementation. Some chapter details (e.g., exact routing/middleware examples) are only partially visible.