Go Language Course

Lesson 1 • Control Flow Essentials

Covers if/else, for loops, and switch statements as Go's complete control flow toolkit. Highlights Go's deliberate omission of while and do-while.

Lesson 2 • Go History and Design Philosophy

Covers Go's origins at Google, its goals of simplicity and performance, and how those goals shape every language decision. Sets context for all subsequent syntax choices.

Lesson 3 • Program Structure and Entry Points

Explains package declarations, the main function, and import statements. Provides the structural skeleton every Go program must follow.

Lesson 4 • Installing and Configuring the Toolchain

Walks through downloading Go, setting GOPATH and GOROOT, and verifying the installation. Establishes the working environment needed for every later exercise.

Lesson 1 • First-Class and Higher-Order Functions

Treats functions as values: assigning, passing, and returning them. Prepares students for closures and functional patterns used in later chapters.

Lesson 2 • Defining and Calling Functions

Covers function signatures, parameter passing, and return values. Establishes the calling conventions that underpin all Go code organization.

Lesson 3 • Multiple Return Values

Explains how Go functions return multiple values and why this pattern replaces exceptions. Directly enables the idiomatic error-handling covered next.

Lesson 4 • Idiomatic Error Handling

Covers the error interface, sentinel errors, and wrapping with fmt.Errorf. Establishes the explicit error-checking discipline central to production Go code.

Lesson 1 • Maps

Covers map creation, CRUD operations, and zero-value behavior. Maps are used extensively in configuration, caching, and lookup patterns throughout the course.

Lesson 2 • Arrays and Slices

Distinguishes fixed-size arrays from dynamic slices and explains the underlying array model. Slice mastery is prerequisite for idiomatic Go data manipulation.

Lesson 3 • Structs and Struct Tags

Defines structs as Go's primary record type and introduces field tags for serialization. Structs are the foundation for methods and interfaces in the next chapter.

Lesson 4 • Pointers and Memory Addressing

Explains pointer syntax, dereferencing, and when to use pointers versus values. Correct pointer use is essential for methods with receiver types and efficient data passing.

Lesson 1 • Defining and Implementing Interfaces

Introduces implicit interface satisfaction and the power of small interfaces. Students implement standard interfaces like io.Reader and fmt.Stringer.

Lesson 2 • Type Assertions and Type Switches

Covers runtime type inspection via assertions and switches. These techniques are required for working with interface values returned by standard library functions.

Lesson 3 • The Empty Interface and Generics Preview

Explains interface{} and any as universal types, then previews type parameters. Bridges classical Go polymorphism with the generics system introduced in Go 1.18.

Lesson 4 • Methods and Receiver Types

Attaches functions to types using value and pointer receivers. Receiver choice directly affects mutation semantics and interface satisfaction covered next.

Lesson 1 • Package Organization Principles

Covers naming conventions, exported versus unexported identifiers, and package cohesion. Good package design prevents the coupling problems addressed in later architecture topics.

Lesson 2 • Build System and Toolchain Commands

Surveys go build, go install, go vet, and go fmt as the core build pipeline. Automation of these commands is foundational for CI/CD pipelines covered later.

Lesson 3 • Writing and Running Tests

Introduces the testing package, table-driven tests, and go test flags. Testing discipline established here is extended in the advanced testing supplementary chapter.

Lesson 4 • Adding and Managing Dependencies

Walks through adding, upgrading, and removing third-party packages. Covers the go get and go mod tidy commands used in daily development workflows.

Lesson 1 • Detecting and Preventing Data Races

Uses the race detector and explains the Go memory model to identify and fix data races. Race-free code is a prerequisite for the concurrent patterns in the next chapter.

Lesson 2 • Synchronization Primitives

Introduces sync.Mutex, sync.RWMutex, sync.WaitGroup, and sync.Once. These primitives handle shared-state scenarios where channels are not the right fit.

Lesson 3 • Channels for Communication

Covers unbuffered and buffered channels, send/receive semantics, and channel direction. Channels are Go's primary mechanism for safe data sharing between goroutines.

Lesson 4 • Select Statement and Multiplexing

Teaches the select statement for waiting on multiple channel operations simultaneously. Enables timeout patterns and fan-in designs used in real services.

Lesson 1 • JSON and Data Encoding

Teaches encoding/json for marshaling and unmarshaling structs. JSON handling is required for every REST API and configuration system built in later chapters.

Lesson 2 • Context for Cancellation and Deadlines

Explains context.Context, cancellation, and deadline propagation across API boundaries. Context is mandatory for production HTTP handlers and database calls.

Lesson 3 • Logging and Environment Configuration

Covers the log package, structured logging with log/slog, and reading environment variables. Proper observability and configuration are essential for deployable services.

Lesson 4 • HTTP Client and Server Basics

Introduces net/http for making requests and serving responses. Provides the foundation for the full REST API development covered in the applied chapter.

Lesson 1 • Containerizing and Deploying Go Services

Builds minimal Docker images using multi-stage builds and discusses deployment targets. Completes the path from source code to a running, observable production service.

Lesson 2 • Database Access with database/sql

Covers connection pooling, prepared statements, and transaction management using database/sql. Provides the data persistence layer required by most production services.

Lesson 3 • REST API Design and Implementation

Builds a full REST API using net/http and a router, applying middleware and handler patterns. Consolidates HTTP, JSON, and context skills from previous chapters.

Lesson 4 • Graceful Shutdown and Signal Handling

Implements OS signal handling and server shutdown with context deadlines. Prevents data loss and connection errors when containers or processes are restarted.