Go Programming Course

Lesson 1 • Variables, Types, and Constants

Introduces static typing, type inference, and constant declarations. Grounds students in Go's strict type system before complex data structures appear.

Lesson 2 • Operators and Expressions

Covers arithmetic, comparison, logical, and bitwise operators. Prepares students to write meaningful conditional and computational logic.

Lesson 3 • Basic Syntax and Program Structure

Covers packages, imports, the main function, and statement syntax. Provides the structural skeleton for all Go programs written in the course.

Lesson 4 • Control Flow Structures

Teaches if, for, switch, and defer statements as Go's complete control toolkit. Enables students to write programs with branching and iterative logic.

Lesson 1 • Recursion and Function Values

Explores recursive algorithms and functions as first-class values. Prepares students for higher-order patterns and callback-based designs.

Lesson 2 • Panic, Recover, and Defer Patterns

Covers panic propagation, recovery mechanics, and defer-based cleanup. Equips students to handle unexpected failures without crashing production services.

Lesson 3 • Variadic Functions and Closures

Introduces variadic parameters and function literals that capture scope. Enables flexible APIs and functional programming patterns in Go.

Lesson 4 • Defining and Calling Functions

Covers function signatures, parameters, and return values. Establishes the reusable code unit that all later abstractions build upon.

Lesson 1 • Slice Patterns and Pitfalls

Addresses copy semantics, shared backing arrays, and common bugs. Prevents memory and correctness issues that arise in real slice-heavy code.

Lesson 2 • Structs and Struct Tags

Introduces struct declaration, field access, embedding, and tags. Provides the custom type foundation for domain modeling and serialization.

Lesson 3 • Arrays and Slices

Distinguishes fixed arrays from dynamic slices and covers slice internals. Provides the workhorse collection type used in virtually every Go program.

Lesson 4 • Maps

Covers map creation, CRUD operations, and iteration semantics. Enables key-value data modeling essential for configuration, caching, and lookup tables.

Lesson 1 • Methods on Types

Teaches value and pointer receivers, method expressions, and promotion. Connects struct definitions to behavioral contracts expressed through interfaces.

Lesson 2 • Type Assertions and Type Switches

Covers safe and unsafe type assertions and the type switch construct. Enables runtime type inspection needed for generic-style dispatch patterns.

Lesson 3 • Defining and Implementing Interfaces

Covers interface declaration, implicit satisfaction, and method sets. Establishes the polymorphism mechanism central to idiomatic Go design.

Lesson 4 • Interface Composition and Design Patterns

Explores composing small interfaces and applying dependency injection. Produces loosely coupled, testable code architectures.

Lesson 1 • Documentation and Code Generation

Teaches godoc conventions, example functions, and go generate. Produces self-documenting packages and automates repetitive code tasks.

Lesson 2 • Linting and Code Quality Tools

Introduces staticcheck, golangci-lint, and formatting enforcement. Embeds professional quality standards into every project from day one.

Lesson 3 • Package Organisation Principles

Covers naming conventions, exported identifiers, and internal packages. Establishes the structural discipline that keeps large codebases navigable.

Lesson 4 • Build, Test, and Vet Commands

Covers go build, go test, go vet, and build tags. Integrates quality checks into the development workflow from the start.

Lesson 1 • Select Statement and Timeouts

Teaches the select statement for multiplexing channel operations. Enables non-blocking I/O patterns and timeout-controlled concurrent workflows.

Lesson 2 • Sync Primitives: Mutex and WaitGroup

Introduces sync.Mutex, sync.RWMutex, and sync.WaitGroup for shared state. Complements channel-based design with low-level synchronisation tools.

Lesson 3 • 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 4 • Race Detection and Concurrency Patterns

Uses the race detector and covers pipelines, fan-out, and worker pools. Produces verified, production-grade concurrent architectures.

Lesson 1 • I/O Primitives and File Operations

Covers io, bufio, and os packages for reading and writing data. Provides the I/O foundation for file processing and stream-based programs.

Lesson 2 • HTTP Client and Server Basics

Introduces net/http for building servers and making HTTP requests. Provides the networking foundation expanded in the applied chapter ahead.

Lesson 3 • Strings, Bytes, and Unicode

Teaches strings, bytes, unicode, and strconv packages for text processing. Enables correct handling of UTF-8 data in international applications.

Lesson 4 • Time, Dates, and Timers

Explores the time package for parsing, formatting, and scheduling. Enables time-aware logic in APIs, jobs, and event-driven systems.

Lesson 1 • Unit Testing with the testing Package

Covers test functions, table-driven tests, and subtests. Establishes the core testing discipline applied to every package in the course.

Lesson 2 • Integration and End-to-End Testing

Covers httptest, in-memory databases, and test containers. Validates system behaviour across component boundaries in realistic conditions.

Lesson 3 • Benchmarking and Profiling

Uses Benchmark functions, pprof, and trace to find bottlenecks. Produces data-driven performance improvements grounded in measurement.

Lesson 4 • Debugging Techniques and Tools

Covers Delve debugger, log-based tracing, and runtime diagnostics. Equips students to locate and fix defects efficiently in any Go program.