Go (Golang): Functions and Methods Course

Lesson 1 • Variadic Functions

Introduces the ... syntax for variadic parameters and how to forward them. Variadic functions appear throughout the standard library and are essential to master.

Lesson 2 • Calling Functions and Passing Arguments

Explains call syntax, argument evaluation order, and pass-by-value semantics. Understanding value copying prevents common mutation bugs early on.

Lesson 3 • Declaring and Naming Functions

Covers the func keyword, naming conventions, and package-level vs. local scope. Correct naming directly affects exported visibility and code readability.

Lesson 4 • Parameters and Return Values

Teaches typed parameter lists, single and multiple return values, and blank identifier usage. These patterns are the backbone of every Go function signature.

Lesson 1 • Handling and Propagating Errors

Teaches if err != nil checks, error wrapping with %w, and unwrapping. Proper propagation keeps error context intact across call stacks.

Lesson 2 • Named Return Values

Covers named result parameters, their zero-value initialization, and naked returns. Named returns improve clarity in complex functions but carry readability trade-offs.

Lesson 3 • Custom Error Types

Shows how to implement the error interface on custom structs for richer diagnostics. Custom types enable callers to inspect error details programmatically.

Lesson 4 • The Error Interface and Idiomatic Errors

Introduces the built-in error interface and the convention of returning errors last. This pattern is the foundation of all Go error-handling code.

Lesson 1 • Lexical Scope in Go

Explains block scope, shadowing, and how the compiler resolves identifiers. Scope rules determine which variables a function can read and modify.

Lesson 2 • Returning Functions from Functions

Shows factory functions, partial application, and memoization patterns using returned functions. Returning functions enables powerful abstraction and deferred computation.

Lesson 3 • Closures: Capturing Variables

Explains how closures capture variables by reference and the implications for mutation. Mastering capture semantics prevents subtle bugs in concurrent and iterative code.

Lesson 4 • Anonymous Functions and Literals

Covers inline function literals, immediate invocation, and common use cases. Anonymous functions are the building blocks of closures and callbacks.

Lesson 1 • The defer Statement

Introduces defer semantics, LIFO execution order, and argument evaluation timing. Defer is Go's primary tool for guaranteed resource cleanup.

Lesson 2 • Panic: Causes and Behaviour

Describes what triggers a panic, stack unwinding, and when panics are appropriate. Understanding panic behaviour is essential before attempting recovery.

Lesson 3 • Common defer Patterns

Covers file closing, mutex unlocking, and span finishing as canonical defer use cases. These patterns appear in virtually every production Go codebase.

Lesson 4 • defer and Named Return Interaction

Explains how deferred functions can modify named return values before the caller receives them. This interaction is a common source of subtle bugs and clever patterns.

Lesson 1 • Defining Methods on Types

Covers method declaration syntax, receiver naming, and attaching methods to named types. Methods transform plain structs into behavioural objects in Go.

Lesson 2 • Method Sets and Interfaces

Explains how receiver type determines the method set and interface satisfaction. Method sets are the link between concrete types and Go's interface system.

Lesson 3 • Promoted Methods and Embedding

Shows how embedding a type promotes its methods to the outer struct. Embedding is Go's composition mechanism and a substitute for inheritance.

Lesson 4 • Method Expressions and Values

Demonstrates method values and method expressions as callable function values. These features bridge methods and first-class function patterns from earlier chapters.

Lesson 1 • Composing Interfaces

Shows interface embedding to build larger contracts from smaller ones. Composed interfaces keep individual interfaces small and focused.

Lesson 2 • Common Standard Library Interfaces

Surveys io.Reader, io.Writer, fmt.Stringer, and error as canonical interface examples. Familiarity with these interfaces accelerates real-world Go development.

Lesson 3 • The Empty Interface and Type Assertions

Explains any (interface{}), type assertions, and type switches for dynamic dispatch. These tools handle heterogeneous data but require careful use.

Lesson 4 • Using Interfaces as Function Parameters

Teaches accepting interfaces in function signatures to decouple callers from implementations. This pattern is the primary way Go achieves dependency inversion.

Lesson 1 • Function Composition

Demonstrates composing functions into pipelines and building compose helpers. Composition enables building complex behaviour from simple, tested units.

Lesson 2 • Options and Functional Configuration

Covers the functional options pattern for configuring structs without constructor overloads. This pattern is widely used in Go libraries for flexible, backward-compatible APIs.

Lesson 3 • Map, Filter, and Reduce Patterns

Implements map, filter, and reduce as generic-style helpers using function parameters. These patterns reduce boilerplate and improve code expressiveness.

Lesson 4 • Middleware and Decorator Patterns

Shows wrapping functions with decorators for logging, timing, and retry logic. Middleware patterns are ubiquitous in HTTP servers and CLI tools.

Lesson 1 • Function Caching and Memoization

Implements memoization with maps and closures to cache expensive function results. Caching is a critical optimisation for pure functions with repeated inputs.

Lesson 2 • Testing Functions and Methods Effectively

Covers table-driven tests, subtests, and testing unexported functions in Go. Rigorous testing practices ensure function contracts are verified and maintained.

Lesson 3 • Method Chaining and Fluent APIs

Demonstrates returning the receiver from methods to enable fluent builder APIs. Chaining improves readability for configuration-heavy object construction.

Lesson 4 • Inlining, Escape Analysis, and Performance

Explains compiler inlining decisions, heap escape, and how function design affects allocations. These insights enable writing high-performance Go without sacrificing clarity.