Introduction to Google Go Programming

Lesson 1 • Understanding the Go Workspace

Explains the traditional workspace layout and the modern module-based project structure. Connects directory conventions to how Go resolves packages.

Lesson 2 • Choosing and Configuring an Editor

Surveys popular editors and IDEs with Go support and configures language-server features. Productive tooling accelerates learning throughout the course.

Lesson 3 • Core Go CLI Commands

Introduces the essential go command subcommands used daily. Students gain confidence running, building, and testing code from the terminal.

Lesson 1 • Variables, Constants, and Zero Values

Covers var declarations, short variable syntax, and typed constants. Introduces Go's zero-value guarantee as a safety feature.

Lesson 2 • Formatted Input and Output

Teaches fmt package verbs for printing and scanning user input. Connects syntax knowledge to visible program behavior.

Lesson 3 • Type Conversions and Iota

Explains explicit type conversion rules and the iota enumerator for constants. Prevents common type-mismatch bugs early in the learning journey.

Lesson 4 • Program Structure and Packages

Examines the anatomy of a Go source file, including package declarations and imports. Establishes the structural rules every Go program must follow.

Lesson 1 • Defer, Panic, and Recover

Introduces deferred calls for cleanup and the panic/recover mechanism for error containment. Builds safe resource-management habits from the start.

Lesson 2 • Closures and Higher-Order Functions

Explores how closures capture variables and how functions accept or return other functions. Prepares students for functional patterns used in Go libraries.

Lesson 3 • Loops and Iteration

Explains Go's single loop keyword for and its three forms. Connects iteration patterns to later use with slices and maps.

Lesson 4 • Defining and Calling Functions

Teaches function signatures, multiple return values, and named returns. Establishes Go's function conventions used throughout the rest of the course.

Lesson 1 • Arrays: Fixed-Length Collections

Defines array syntax, value semantics, and size constraints. Contrasts arrays with slices to motivate why slices dominate Go code.

Lesson 2 • Maps: Key-Value Storage

Explains map creation, CRUD operations, and the comma-ok idiom. Maps are the primary associative data structure in Go programs.

Lesson 3 • Iterating Collections with Range

Teaches the range keyword across slices, arrays, strings, and maps. Reinforces idiomatic Go iteration introduced in the control flow chapter.

Lesson 4 • Slices: Dynamic Sequences

Covers slice internals (pointer, length, capacity) and common operations. Slice mastery is essential for nearly every Go program.

Lesson 1 • Unsafe Package and Low-Level Access

Surveys unsafe.Pointer, Sizeof, and Alignof for systems-level tasks. Emphasizes when and why to avoid unsafe in application code.

Lesson 2 • Go's Garbage Collector

Describes the tri-color mark-and-sweep GC, GOGC tuning, and GC pauses. Students learn to profile and reduce GC pressure in production programs.

Lesson 3 • Stack vs. Heap Allocation

Explains how the compiler decides where variables live using escape analysis. Understanding allocation helps students write low-latency, GC-friendly code.

Lesson 1 • Defining and Using Structs

Covers struct declaration, field access, embedding, and anonymous structs. Structs are Go's primary mechanism for grouping related data.

Lesson 2 • Composition Over Inheritance

Demonstrates how embedding structs and interfaces replaces classical inheritance. Students design flexible, maintainable type hierarchies without subclassing.

Lesson 3 • Common Standard Library Interfaces

Surveys io.Reader, io.Writer, fmt.Stringer, and error interfaces. Implementing these unlocks seamless integration with the Go standard library.

Lesson 4 • Interfaces and Implicit Implementation

Explains interface declaration, implicit satisfaction, and polymorphic dispatch. Interfaces are the cornerstone of Go's extensibility model.

Lesson 1 • Shared State and the sync Package

Introduces Mutex, RWMutex, Once, and atomic operations for shared-memory concurrency. Complements channel-based patterns for performance-critical sections.

Lesson 2 • Select Statement and Timeouts

Teaches multiplexing channel operations with select and implementing timeouts. Enables responsive concurrent programs that handle multiple event sources.

Lesson 3 • Common Concurrency Patterns

Demonstrates worker pools, pipelines, and fan-out/fan-in architectures. Students apply primitives to real-world concurrent workload designs.

Lesson 4 • Channels: Typed Communication Pipes

Covers unbuffered and buffered channels, directional types, and closing semantics. Channels are Go's primary tool for safe data sharing between goroutines.

Lesson 1 • Unit Testing with the testing Package

Introduces test functions, table-driven tests, and subtests. Automated tests are the primary quality gate for Go projects.

Lesson 2 • Idiomatic Error Handling

Covers the error interface, sentinel errors, and custom error types. Idiomatic error handling is central to Go's reliability philosophy.

Lesson 3 • Context Package for Cancellation

Teaches context.Background, WithCancel, WithTimeout, and value propagation. Context is the standard mechanism for deadline and cancellation across API boundaries.

Lesson 4 • Go Modules and Dependency Management

Explains go.mod, go.sum, versioning, and the module proxy. Reproducible builds depend on correct module configuration.