Core Go Programming Course

Lesson 1 • Installing and Configuring Go

Covers Go installation, workspace layout, and toolchain setup. Provides the operational foundation every subsequent chapter depends on.

Lesson 2 • Operators and Expressions

Covers arithmetic, comparison, logical, and bitwise operators. Students gain the ability to construct correct expressions in any Go context.

Lesson 3 • Variables, Constants, and Data Types

Teaches variable declaration styles, zero values, and built-in primitive types. Builds type awareness required for every subsequent coding task.

Lesson 4 • Using the Go Toolchain

Explores go build, go fmt, go vet, and go doc commands. Equips students with the daily workflow tools used in professional Go development.

Lesson 1 • Defining and Calling Functions

Introduces function signatures, parameters, and return values. Establishes the building block for modular Go code used throughout the course.

Lesson 2 • Loops and Iteration

Covers the for loop in all its forms, including range-based iteration. Provides the iteration tools needed to process collections and streams.

Lesson 3 • Defer, Panic, and Recover

Explains deferred calls, panic propagation, and recovery patterns. Students learn Go's idiomatic approach to resource cleanup and error containment.

Lesson 4 • First-Class Functions and Closures

Treats functions as values, covering anonymous functions and closures. Prepares students for higher-order patterns used in later chapters.

Lesson 1 • Arrays in Go

Covers fixed-length array declaration, indexing, and value semantics. Establishes the memory model that underpins slice behavior in later sections.

Lesson 2 • Common Slice Patterns

Demonstrates filtering, deduplication, and in-place modification idioms. Builds a practical toolkit for slice manipulation used in real codebases.

Lesson 3 • Slices: Internals and Operations

Explains slice headers, backing arrays, and growth behavior. Mastery here prevents common bugs in data manipulation throughout the course.

Lesson 4 • Structs as Composite Records

Introduces struct declaration, field access, embedding, and anonymous fields. Lays the groundwork for the type system explored in the next chapter.

Lesson 1 • Adding and Managing Dependencies

Teaches go get, go mod tidy, and dependency version selection. Students maintain clean, reproducible dependency graphs in real projects.

Lesson 2 • Publishing and Versioning Modules

Explains tagging releases, major version suffixes, and module proxies. Prepares students to share reusable libraries with the Go ecosystem.

Lesson 3 • Go Modules and go.mod

Explains module initialization, the go.mod file, and semantic versioning. Establishes the dependency contract that governs all modern Go projects.

Lesson 4 • Package Organization Principles

Covers package naming, exported vs. unexported identifiers, and cohesion. Guides students toward package structures that scale with project size.

Lesson 1 • Methods on Types

Covers value and pointer receivers, method sets, and promotion via embedding. Establishes how behavior is attached to types in Go.

Lesson 2 • Interface Design Best Practices

Covers small interfaces, accept interfaces/return concretes, and interface pollution. Guides students toward maintainable, testable API boundaries.

Lesson 3 • Standard Library Interfaces

Examines io.Reader, io.Writer, fmt.Stringer, and error interfaces. Connects interface theory to the interfaces students encounter daily.

Lesson 4 • Type Assertions and Type Switches

Teaches safe and unsafe type assertions and type-switch dispatch. Enables runtime type inspection needed for generic handler patterns.

Lesson 1 • Logging and Observability Basics

Introduces structured logging with the log and log/slog packages. Connects error handling to operational visibility in production systems.

Lesson 2 • Error Wrapping and Unwrapping

Covers error chains, errors.Is, errors.As, and unwrap trees. Students learn to inspect layered errors without breaking encapsulation.

Lesson 3 • Panic and Recover Patterns

Revisits panic and recover in the context of library boundary safety. Students know when to convert panics to errors at API surfaces.

Lesson 4 • The Error Model in Go

Explains the error interface, nil checks, and idiomatic error propagation. Establishes the mental model that governs all error handling in Go.

Lesson 1 • Synchronization with sync Package

Covers Mutex, RWMutex, WaitGroup, and Once for shared-state safety. Complements channel-based concurrency for scenarios requiring shared memory.

Lesson 2 • Goroutines and the Go Scheduler

Explains goroutine creation, the M:N scheduler, and goroutine lifecycle. Provides the conceptual model needed to reason about concurrent execution.

Lesson 3 • Common Concurrency Patterns

Demonstrates worker pools, pipelines, and fan-out/fan-in architectures. Students apply these patterns to build scalable concurrent programs.

Lesson 4 • Select Statement and Multiplexing

Teaches the select statement for multiplexing channel operations. Enables timeout, cancellation, and fan-in patterns used in production services.

Lesson 1 • Test Helpers and Test Fixtures

Teaches helper functions, TestMain, and temporary resource setup. Reduces boilerplate and improves test readability across large test suites.

Lesson 2 • Benchmarking and Profiling

Covers benchmark functions, B.N loops, and pprof integration. Students identify and eliminate performance bottlenecks with data-driven evidence.

Lesson 3 • Writing Unit Tests with testing Package

Covers test file conventions, T.Error, T.Fatal, and subtests. Establishes the baseline testing discipline required for all Go projects.

Lesson 4 • Code Coverage and Quality Gates

Explains coverage reports, go test -cover, and linter integration. Connects testing to continuous integration pipelines for automated quality enforcement.