Golang Language Course

Lesson 1 • Go Workspace and Module System

Explains the module-based project structure introduced in Go 1.11 and how go.mod manages dependencies. Students create their first module and understand package organization.

Lesson 2 • Writing and Running Your First Program

Introduces the main package, the main function, and the fmt package for output. Students write, compile, and execute a Hello World program end-to-end.

Lesson 3 • Installing and Configuring Go

Walks through downloading the Go toolchain, setting GOPATH and GOROOT, and verifying installation. Ensures a consistent environment for all subsequent exercises.

Lesson 1 • Operators and Expressions

Covers arithmetic, comparison, logical, and bitwise operators along with operator precedence. Students write correct expressions and avoid common precedence pitfalls.

Lesson 2 • Control Flow Structures

Teaches if/else, switch, for loops, and defer in idiomatic Go style. Students replace complex branching with clean, readable control flow patterns.

Lesson 3 • Pointers and Memory Addressing

Introduces pointer syntax, dereferencing, and the new function. Students understand when Go passes by value vs. by pointer and avoid common nil pointer errors.

Lesson 4 • Variables, Constants, and Zero Values

Covers var declarations, short variable declarations, typed and untyped constants, and Go's zero-value guarantee. Builds the foundation for all subsequent data manipulation.

Lesson 1 • Panic, Recover, and Defensive Coding

Distinguishes panic from error returns, demonstrates recover inside deferred functions, and sets guidelines for when panics are appropriate. Prevents unhandled runtime crashes.

Lesson 2 • The Error Interface and Idiomatic Handling

Introduces the built-in error interface, the errors package, and the if err != nil pattern. Students adopt Go's explicit error-handling philosophy from the start.

Lesson 3 • Anonymous Functions and Closures

Explains how closures capture variables from enclosing scopes and how anonymous functions enable callbacks and deferred logic. Students use closures to write flexible, concise code.

Lesson 4 • Defining and Calling Functions

Covers function signatures, parameter passing, named return values, and variadic functions. Establishes the building blocks for all modular Go code.

Lesson 1 • Type Assertions and Type Switches

Covers safe and unsafe type assertions and the type switch construct for dispatching on dynamic types. Students handle polymorphic values without reflection overhead.

Lesson 2 • Interfaces and Implicit Implementation

Introduces Go's structural typing, interface declaration, and the empty interface. Students write code that accepts any type satisfying a contract without explicit declarations.

Lesson 3 • Methods on Structs

Explains value receivers vs. pointer receivers, method sets, and method chaining. Students attach behavior to types and understand when each receiver type is appropriate.

Lesson 4 • Composition Over Inheritance

Demonstrates struct embedding as Go's alternative to inheritance and shows how promoted methods work. Students build flexible type hierarchies without class-based coupling.

Lesson 1 • Standard Library Tour

Surveys the most-used standard library packages: fmt, os, io, strings, strconv, and time. Students leverage built-in functionality before reaching for third-party libraries.

Lesson 2 • Writing and Publishing Packages

Guides students through documenting packages with godoc comments, tagging releases, and publishing to a public module registry. Enables open-source contribution and reuse.

Lesson 3 • Package Design Principles

Covers naming conventions, cohesion, and the single-responsibility principle for packages. Students structure projects so packages are independently testable and importable.

Lesson 1 • Goroutines and the Go Scheduler

Explains how goroutines are lightweight threads managed by the Go runtime and how the M:N scheduler works. Students launch goroutines and understand their lifecycle.

Lesson 2 • Context for Cancellation and Deadlines

Teaches the context package for propagating cancellation signals and deadlines across goroutine trees. Students build services that shut down cleanly under timeout or cancellation.

Lesson 3 • Detecting and Fixing Race Conditions

Demonstrates the Go race detector, common data race patterns, and atomic operations via sync/atomic. Students eliminate races before code reaches production.

Lesson 4 • Synchronization Primitives

Introduces sync.Mutex, sync.RWMutex, sync.WaitGroup, and sync.Once for coordinating goroutines. Students choose the right primitive for each synchronization scenario.

Lesson 1 • Debugging with Delve and Logging

Covers the Delve debugger for breakpoints and stack inspection, and structured logging with the log/slog package. Students diagnose bugs efficiently in both local and remote environments.

Lesson 2 • Unit Testing with the testing Package

Covers test file conventions, the testing.T type, table-driven tests, and subtests. Students write maintainable test suites that document expected behavior.

Lesson 3 • Code Coverage and Quality Gates

Explains go test -cover, coverage HTML reports, and integrating coverage thresholds into CI pipelines. Students enforce quality standards automatically on every commit.

Lesson 4 • Benchmarking and Profiling

Introduces testing.B for micro-benchmarks, pprof for CPU and memory profiling, and trace for goroutine analysis. Students identify and eliminate real performance bottlenecks.

Lesson 1 • Database Access with database/sql

Introduces the database/sql interface, connection pooling, prepared statements, and transaction management. Students write safe, efficient database code that avoids SQL injection.

Lesson 2 • Containerizing and Deploying Go Services

Covers multi-stage Docker builds for minimal Go images, graceful shutdown patterns, and deployment to container orchestration platforms. Students ship Go services reliably.

Lesson 3 • HTTP Servers and REST APIs

Builds HTTP servers using net/http, defines routes, parses requests, and writes JSON responses. Students create fully functional REST APIs without third-party frameworks.

Lesson 4 • Observability: Metrics, Tracing, and Logging

Integrates structured logging, distributed tracing, and metrics exposition into a Go service. Students make applications observable and diagnosable in production environments.