Go (Golang) for the Absolute Beginners: Hands-On Course

Lesson 1 • Writing and Running Your First Program

Walks through the anatomy of a minimal Go program and the build-run cycle. Connects language syntax to observable output immediately.

Lesson 2 • What Go Is and Why It Matters

Covers Go's origin, design goals, and use cases in modern software. Establishes context for every technical decision made throughout the course.

Lesson 3 • Installing Go and Setting Up Tools

Installs the Go toolchain and configures a productive editor environment. Ensures every student has a consistent, working setup before writing code.

Lesson 1 • Operators and Expressions

Explains arithmetic, comparison, logical, and bitwise operators with precedence rules. Enables students to write correct, predictable expressions.

Lesson 2 • Type Conversions and fmt Formatting

Demonstrates explicit type conversion and formatted output with fmt verbs. Prevents type mismatch errors and teaches readable print statements.

Lesson 3 • Numeric, Boolean, and String Types

Covers int, float, bool, and string types with their sizes and limits. Equips students to choose the right type for any data they encounter.

Lesson 1 • Variadic Functions and Closures

Introduces variadic parameters and anonymous functions that capture scope. Prepares students for higher-order patterns used in Go's standard library.

Lesson 2 • Defer, Panic, and Recover

Explains deferred calls, panic propagation, and recovery for error handling. Gives students tools to write robust cleanup and fault-tolerant code.

Lesson 3 • Defining and Calling Functions

Teaches function signatures, parameters, and multiple return values. Establishes the building block for all code organization going forward.

Lesson 4 • Loops in Go

Explains Go's single loop keyword, for, used in all iteration patterns. Covers range-based loops that appear in every Go program.

Lesson 1 • Arrays: Fixed-Length Collections

Defines array syntax, value semantics, and size constraints. Contrasts arrays with slices so students understand when each is appropriate.

Lesson 2 • Maps: Key-Value Storage

Teaches map creation, CRUD operations, and safe key lookup. Maps are Go's primary associative data structure and appear in most real programs.

Lesson 3 • Common Slice Patterns and Pitfalls

Addresses shared-backing-array bugs, nil slices, and idiomatic filtering. Prevents the most frequent slice-related bugs seen in beginner Go code.

Lesson 1 • Composition Over Inheritance

Uses struct embedding and interface composition to build complex types. Replaces class hierarchies with Go's idiomatic, flat composition model.

Lesson 2 • Defining and Using Structs

Covers struct declaration, field access, and struct literals. Structs are Go's primary mechanism for grouping related data into meaningful types.

Lesson 3 • Pointers and Value Receivers

Explains pointer semantics, address-of operator, and dereferencing. Clarifies when to use pointer vs. value receivers on methods.

Lesson 4 • Methods on Custom Types

Attaches methods to struct and non-struct types to encapsulate behavior. Demonstrates how Go achieves object-oriented patterns without classes.

Lesson 1 • Error Wrapping and Unwrapping

Uses fmt.Errorf %w and errors.As to wrap and inspect error chains. Teaches the modern Go 1.13+ error wrapping model used in production code.

Lesson 2 • Custom Error Types

Creates struct-based errors with additional context fields. Enables callers to inspect error details and respond with fine-grained logic.

Lesson 3 • Idiomatic Error Handling Patterns

Covers guard clauses, early returns, and error aggregation strategies. Produces clean, readable error-handling code that follows community conventions.

Lesson 1 • Mutexes and the sync Package

Protects shared state with sync.Mutex and sync.RWMutex. Covers sync.Once and sync.Map for common concurrent data patterns.

Lesson 2 • Channels: Communicating Between Goroutines

Covers channel creation, send/receive operations, and blocking behavior. Channels are Go's primary tool for safe data sharing across goroutines.

Lesson 3 • Select Statement and Timeouts

Uses select to multiplex channel operations and implement timeouts. Enables responsive concurrent programs that handle multiple event sources.

Lesson 4 • Goroutines: Lightweight Threads

Explains goroutine creation, scheduling, and lifecycle. Demonstrates how Go multiplexes thousands of goroutines onto OS threads efficiently.

Lesson 1 • Essential Standard Library Packages

Surveys fmt, strings, strconv, math, time, and os packages. Reduces reliance on third-party libraries for common programming tasks.

Lesson 2 • Testing with the testing Package

Writes unit tests, table-driven tests, and benchmarks using the built-in testing package. Establishes a test-first mindset for all future Go development.

Lesson 3 • Organizing Code into Packages

Explains package naming, exported vs. unexported identifiers, and import paths. Proper package design is the foundation of maintainable Go projects.

Lesson 4 • Go Modules and Dependency Management

Covers go get, go mod tidy, versioning, and replacing dependencies. Ensures students can manage third-party libraries in real-world projects.