# Golang Tutorial

> Practical Go tutorials from a first program to production backend systems.
> Tutorial pages state their supported Go version and link to their author and learning path.

## Tutorials
- [Go Context: Cancellation, Deadlines, and Request Values](https://golangtutorial.com/golang-context/): Learn Go context with practical cancellation, timeout, HTTP request, and goroutine examples.
- [Golang Hello World and Your First Go Program](https://golangtutorial.com/golang-hello-world-writing-your-first-go-program/): Build a Golang Hello World program, understand package main and func main, accept an argument, then run and compile it with Go 1.24.7.
- [JSON in Go: Encoding, Decoding, and Validation](https://golangtutorial.com/golang-json/): Encode and decode JSON safely in Go with struct tags, validation, unknown-field checks, and HTTP examples.
- [Testing in Go: Table Tests, HTTP, Fakes, and Coverage](https://golangtutorial.com/golang-testing/): Write effective Go tests with table-driven cases, subtests, httptest, fakes, race detection, benchmarks, and useful coverage.
- [Go net/http: Build an HTTP Server from Scratch](https://golangtutorial.com/golang-http-server/): Build a production golang http server with net/http: Go 1.22 routing, PathValue, timeouts, graceful shutdown and static files, every example tested.
- [Golang Interfaces: What They Are and How to Use Them](https://golangtutorial.com/golang-interfaces/): Learn Go interfaces with real examples: implicit satisfaction, the nil interface trap, type switches, io.Reader, and refactoring for testable code.
- [Go Mutex: Protecting Shared State from Race Conditions](https://golangtutorial.com/golang-mutex/): A golang mutex tutorial that proves the race first, then teaches Lock/Unlock, RWMutex, the copy bug, atomics, and the frank mutex-vs-channel call.
- [Writing Unit Tests in Go: A Practical Guide](https://golangtutorial.com/golang-unit-tests/): Write golang unit tests that catch bugs: test structure, error checks, table cases, fakes, injected clocks, and coverage, with real go test output.
- [Go Type Parameters: Syntax and Constraints Explained](https://golangtutorial.com/golang-type-parameters/): Learn golang type parameters by example: the [T Constraint] syntax, what each constraint unlocks, type inference, the ~ token, and the method limitation.
- [Go HTTP Client: Timeouts, JSON, and Reliable Requests](https://golangtutorial.com/golang-http-client/): Build reliable outbound HTTP requests in Go with client timeouts, context, JSON, status checks, body limits, and transport reuse.
- [Table-Driven Tests in Go: The Idiomatic Way](https://golangtutorial.com/golang-table-tests/): Golang table driven tests done right: subtests with t.Run, parallel cases, error tables with errors.Is, and golden files, with real tested output.
- [sync.WaitGroup in Go: Coordinating Multiple Goroutines](https://golangtutorial.com/golang-waitgroup/): A tested golang waitgroup guide: the Add/Done/Wait counter model, the copy-by-value deadlock, the Add-inside-goroutine race, and Go 1.25's WaitGroup.Go.
- [Generic Functions in Go: Writing Reusable Code](https://golangtutorial.com/golang-generic-functions/): Write golang generic functions the right way: Map, Filter, Reduce, and a drop-in utilities package. Every example tested on Go 1.24 with real output.
- [Why Learn Golang and What Is Go Used For?](https://golangtutorial.com/why-learn-golang-what-is-golang-used-for/): Why learn Golang? See where Go fits, what teams build with it, its tradeoffs, and a tested concurrency example before choosing it.
- [What Is Go and How Does a Go Program Work?](https://golangtutorial.com/go-the-language-for-building-fast-reliable-and-efficient-software/): What is Go? Understand packages, compilation, garbage collection, concurrency, HTTP tooling, tradeoffs, and a tested service handler.
- [Go Benchmarking: Measuring Performance with testing.B](https://golangtutorial.com/golang-benchmarks/): Learn Go benchmarking with testing.B: read ns/op, B/op and allocs/op, avoid the dead-code trap, use b.Loop, and compare implementations you can trust.
- [Go HTTP Middleware: Build a Production Chain](https://golangtutorial.com/golang-middleware/): Build composable Go HTTP middleware for logging, recovery, request IDs, authentication, and timeouts.
- [Go select Statement: Multiplexing Channels Explained](https://golangtutorial.com/golang-select/): Learn Go's select statement with tested code: the random-choice rule, non-blocking default, timeouts, the nil-channel trick, and context cancellation.
- [Go Constraints: comparable, Ordered and Custom Sets](https://golangtutorial.com/golang-constraints/): Master Go generic constraints: type sets vs method sets, comparable, the ~ token, cmp.Ordered, and writing your own Number constraint. Tested on Go 1.24.
- [Mocking in Go: Test Doubles Without Magic](https://golangtutorial.com/golang-mocking/): Learn golang mocking the idiomatic way: small interfaces plus hand-written fakes, spies, and httptest, with generated mocks only when they earn it.
- [Building a REST API with Go: The Complete Tutorial](https://golangtutorial.com/golang-rest-api/): Build a production-ready REST API in Go with only the standard library: net/http routing, JSON, middleware, context, graceful shutdown, and tests.
- [Go Worker Pool Pattern: Bounded Concurrency at Scale](https://golangtutorial.com/golang-worker-pool/): Build a Go worker pool with tested code: bounded concurrency, error propagation, context cancellation, correct channel closing, and how to size the pool.
- [How to Download and Install Golang Safely](https://golangtutorial.com/how-to-download-and-install-golang/): Download and install Golang on Windows, macOS, or Linux, verify the active toolchain, and avoid PATH and multiple-installation problems.
- [Golang IDEs: Choose an Editor for Your Workflow](https://golangtutorial.com/golang-ides-overview/): Compare Golang IDE workflows and choose an editor by navigation, testing, debugging, remote work, and team needs instead of feature counts.
- [Integration Testing in Go: Testing Real Boundaries](https://golangtutorial.com/golang-integration-tests/): Write Go integration tests that hit real boundaries: HTTP with httptest, a real Postgres, plus build tags and -short to keep go test ./... fast.
- [Goroutines in Go: Concurrency Without Leaks](https://golangtutorial.com/goroutines-tutorial/): Learn how goroutines run, how to wait for them, propagate errors, cancel work, and prevent leaks.
- [Go Channels: Communication Between Goroutines](https://golangtutorial.com/golang-channels/): Learn Go channels, buffering, closing, range, ownership, pipelines, and cancellation with practical examples.
- [Golang File Structure for Modules and Applications](https://golangtutorial.com/golang-file-structure/): Learn a practical Golang file structure that starts small, separates commands from domain packages, and uses internal boundaries only when useful.
- [Fuzz Testing in Go: Finding Bugs Automatically](https://golangtutorial.com/golang-fuzz/): Learn golang fuzz testing with the native toolchain: write a FuzzXxx target, run go test -fuzz, and watch the engine find a real bug end to end.
- [Golang Compilation and Execution Explained](https://golangtutorial.com/golang-compilation-and-execution/): Understand Golang compilation and execution with go run, go build, and go install, then produce and verify a reusable application binary.
- [Goroutine Leaks in Go: How to Detect and Prevent Them](https://golangtutorial.com/goroutine-leaks/): Detect and fix golang goroutine leaks with tested code: runtime.NumGoroutine, the pprof goroutine profile, go test leak checks, and per-cause fixes.
- [Go Tools You Need for a Reliable Development Loop](https://golangtutorial.com/go-tools-you-didnt-know-you-needed/): Use essential Go tools to format, test, inspect, and build code with a repeatable local workflow that catches problems before review.
- [Fan-Out Fan-In in Go: Parallel Work with Channels](https://golangtutorial.com/golang-fanout-fanin/): Learn Go fan-out fan-in with tested code: parallelize work across workers, merge results, restore order, cancel on failure, and carry per-item errors.
- [Go Channel Patterns: Advanced Recipes That Work](https://golangtutorial.com/golang-channel-patterns/): Advanced Go channel patterns with tested code and real output: or-done, tee, bridge, semaphores, heartbeats, and exactly when to reach for each.
- [How to Learn Golang with a Focused Study Plan](https://golangtutorial.com/how-to-learn-golang-a-study-guide/): Learn Golang with a focused eight-week study plan built around tested programs, deliberate practice, projects, and production skills.
- [Go Concurrency Patterns: A Practical Catalogue](https://golangtutorial.com/golang-concurrency-patterns/): A tested catalogue of Go concurrency patterns: generator, fan-out, pipeline, worker pool, semaphore, or-done, and graceful shutdown, with use-when notes.
- [Learn Golang with a Practical Beginner Course](https://golangtutorial.com/learn-golang-a-beginners-course/): Learn Golang through a practical course that moves from syntax to tested programs, modules, errors, concurrency, HTTP, and a final service.
- [Go's Type System Deep Dive: Static Typing Done Right](https://golangtutorial.com/golang-type-system/): A tested tour of the Golang type system: named types vs aliases, assignability, comparability, untyped constants, and making illegal states unrepresentable.
- [Go Interview Questions: 25 Answers That Show Understanding](https://golangtutorial.com/golang-interview-questions/): Prepare for Go interviews with concise answers about slices, interfaces, errors, concurrency, context, HTTP, testing, and performance.
- [Go Tutorial: From First Program to Backend Foundations](https://golangtutorial.com/golang-tutorial/): Learn Go fundamentals through a practical path covering setup, types, functions, structs, errors, concurrency, testing, and HTTP.
- [Golang Developer Salary 2026: US, UK and Remote](https://golangtutorial.com/golang-developer-salary/): What a Golang developer salary really looks like in 2026: US, UK, EU and India ranges by seniority, with named sources, dates and frank caveats.
- [Go defer: Cleanup, Ordering, and Common Traps](https://golangtutorial.com/golang-defer/): Understand Go defer ordering, argument evaluation, named returns, resource cleanup, and loop pitfalls.
- [Error Handling in Go: Wrapping, Classification, and APIs](https://golangtutorial.com/golang-error-handling/): Handle errors idiomatically in Go with wrapping, errors.Is, errors.As, sentinel errors, typed errors, and API mapping.

## Reference
- [Learning roadmap](https://golangtutorial.com/golang-roadmap/)
- [Cheatsheet](https://golangtutorial.com/golang-cheatsheet/)
- [Editorial policy](https://golangtutorial.com/editorial-policy/)