Frontend Labs
⋯
Read as one page Original HTML edition ↗ Markdown source ↗
🐹

Runs alongside the series

Go — The Complete Field Guide (Beginner → Expert)

A practical, example-driven path through Go: what the language actually gives you, why it's shaped the way it is, and how to use it to build real terminal tools, GUI apps, network services, and security infrastructure.

76 chapters · 1 h 49 min of reading

Contents

76 chapters, one page each. Prefer one long page? Read the whole book on one page.

  1. How to use this guide1 min
  2. The series: OS → networking → security → HTTPS, in Go3 min
  3. Table of contents3 min
  4. Part I — Foundations: the Go way
  5. 1. What Go is, and why it exists2 min
  6. 2. The toolchain and workspace1 min
  7. 3. Variables, types, zero values, constants2 min
  8. 4. Control flow: if , switch , for , defer2 min
  9. 5. Functions: multiple returns, variadics, closures1 min
  10. 6. Arrays and slices: the internals that explain the bugs3 min
  11. 7. Maps: internals and idioms1 min
  12. 8. Structs and methods: value vs. pointer receivers, embedding1 min
  13. 9. Interfaces: implicit satisfaction, any , type switches2 min
  14. 10. Error handling: the pattern that shapes all Go code1 min
  15. 11. Packages and modules1 min
  16. 12. Strings, runes, bytes, and Unicode1 min
  17. 13. Terminal project: a system-info CLI and unit converter1 min
  18. 14. Terminal project: a JSON config server1 min
  19. Part II — Intermediate: concurrency and the standard library
  20. 15. Goroutines: Go's answer to "what is a thread"2 min
  21. 16. Channels: pipelines, select , and the closing convention2 min
  22. 17. The sync package: mutexes, WaitGroup , Once , atomics1 min
  23. 18. context : cancellation, deadlines, and request-scoped values2 min
  24. 19. Testing in Go: table-driven tests and subtests1 min
  25. 20. Benchmarks and a first look at pprof1 min
  26. 21. Generics: type parameters and constraints1 min
  27. 22. I/O: io.Reader / Writer , bufio , and os1 min
  28. 23. encoding/json and reflection, briefly1 min
  29. 24. net/http fundamentals: client, server, middleware1 min
  30. 25. Terminal project: a concurrent URL health-checker (worker pool)1 min
  31. 26. Terminal project: an LRU cache library and CLI cache server3 min
  32. Part III — Advanced: systems Go
  33. 27. The Go memory model and the garbage collector2 min
  34. 28. The scheduler deep dive: GMP and work-stealing1 min
  35. 29. Concurrency patterns: fan-in/fan-out, pipelines, rate limiting, errgroup1 min
  36. 30. Advanced error handling: errors.Join , custom types, panic boundaries1 min
  37. 31. Advanced generics: constraints, generic algorithms, inference limits1 min
  38. 32. Reflection and unsafe : when, and why rarely1 min
  39. 33. cgo and syscalls, briefly1 min
  40. 34. Networking deep dive: net.Conn , TCP/UDP, framing your own protocol2 min
  41. 35. TLS in Go: crypto/tls , mutual TLS1 min
  42. 36. Structured logging and observability: log/slog , metrics, tracing1 min
  43. 37. Performance tuning: pprof , trace , and benchmark methodology1 min
  44. 38. Terminal project: a TCP chat server with rooms1 min
  45. 39. Terminal project: a rate-limited reverse proxy (mini API gateway)1 min
  46. Part IV — Real-world builds: terminal
  47. 40. Building production CLIs: flag , subcommands, config precedence1 min
  48. 41. Capstone: a distributed-style job queue with persistence3 min
  49. 42. Capstone: a streaming log analyzer for multi-GB files2 min
  50. Part V — Real-world builds: GUI
  51. 43. GUI options in Go: Fyne, Gio, Wails, Walk, and "just serve HTML"1 min
  52. 44. Building a Fyne desktop app: a live system-resource monitor1 min
  53. 45. Building a Wails app: a Go backend behind a web-based to-do board2 min
  54. 46. Packaging and distributing GUI apps1 min
  55. Part VI — Security-focused Go
  56. 47. Secure coding practices in Go2 min
  57. 48. Auth service: password hashing and JWT issuing/verification1 min
  58. 49. A WAF-style middleware: rate limiting and IP blocklists2 min
  59. 50. mTLS: client-certificate authentication end to end2 min
  60. Part VII — Expert: internals and design
  61. 51. What's really behind an interface value1 min
  62. 52. What's really behind a slice, a map, and a string1 min
  63. 53. Goroutine stacks and the scheduler, revisited1 min
  64. 54. Designing APIs: the Go proverbs, applied1 min
  65. 55. Dependency injection without a framework: functional options1 min
  66. 56. Capstone: a tiny embedded database engine (Bitcask-style)4 min
  67. 57. Shipping it: cross-compilation, Docker, systemd, graceful shutdown1 min
  68. Part VIII — Professional Go: debugging, refactoring, operations
  69. 58. Debugging Go in production: Delve, pprof, traces, stack dumps, GODEBUG2 min
  70. 59. Refactoring Go codebases: package seams, APIs, and compatibility1 min
  71. 60. Testing beyond tables: fuzzing, httptest, golden files, integration tests1 min
  72. 61. Production database access with database/sql and pgx2 min
  73. 62. Production HTTP APIs: validation, timeouts, middleware, shutdown1 min
  74. 63. Modules and releases: MVS, private modules, versioning, binaries1 min
  75. 64. Professional workflow: linting, vuln checks, CI, and quality gates1 min
  76. 65. Observability in Go services: logs, metrics, traces, health, profiling1 min
  77. 66. Architecture and package boundaries: services, workers, and seams1 min
  78. 67. Running Go in containers and Kubernetes2 min
  79. Continue the series1 min
  80. Appendices
  81. Appendix A — Go proverbs and idioms cheat sheet1 min
  82. Appendix B — Common pitfalls and how to catch them1 min
  83. Appendix C — Glossary1 min
  84. Appendix D — Further reading1 min
  85. Appendix E — Command cheat sheet1 min

Generated from real-life-golang-guide.md · 8 Oct 2026 16:36