Go on Software Engineering Learning Paths

Go Fundamentals

Mon, 01 Jan 0001 00:00:00 +0000

Go Fundamentals#

Go is deliberately simple. The language specification fits in a few dozen pages. There are no classes, no inheritance, no exceptions, no operator overloading, and no implicit type conversions. This is not a limitation — it is the design.

Philosophy#

Go was born from frustration with the compile times, complexity, and dependency management of C++ and Java at Google scale. Its design principles:

Principle	Manifestation
Simplicity	25 keywords, one loop construct, no ternary operator
Readability	`gofmt` enforces a single style — no formatting debates
Fast compilation	Compiles a million lines of code in seconds
Explicit over implicit	No hidden constructors, no magic methods, no implicit conversions
Composition over inheritance	Struct embedding instead of class hierarchies
Concurrency as a first-class concept	Goroutines and channels built into the language
Batteries included	Standard library covers HTTP, JSON, crypto, testing, profiling

The Go Proverbs#

From Rob Pike’s 2015 talk, distilled wisdom:

Types & Variables

Mon, 01 Jan 0001 00:00:00 +0000

Types & Variables#

Go is statically typed with type inference. Every variable has a fixed type determined at compile time, but you rarely need to write types explicitly thanks to the := short declaration.

Declaring Variables#

Long Form#

var name string = "Alice"
var age int = 30
var active bool = true

Short Declaration (Most Common)#

name := "Alice" // type inferred as string
age := 30 // type inferred as int
active := true // type inferred as bool

:= declares and assigns in one step. It only works inside functions (not at package level).

Control Flow

Mon, 01 Jan 0001 00:00:00 +0000

Control Flow#

Go has minimal control flow constructs: if, for, switch, and defer. There is no while, no do-while, no ternary operator, and no try/catch. This simplicity is intentional.

If/Else#

if x > 0 {
 fmt.Println("positive")
} else if x == 0 {
 fmt.Println("zero")
} else {
 fmt.Println("negative")
}

If with Init Statement#

Go allows a short statement before the condition — scoped to the if/else block:

if err := doSomething(); err != nil {
 return fmt.Errorf("failed: %w", err)
}
// err is not accessible here

This is the idiomatic error-checking pattern. You will write it hundreds of times.

Functions

Mon, 01 Jan 0001 00:00:00 +0000

Functions#

Functions in Go are first-class values. They can be assigned to variables, passed as arguments, returned from other functions, and defined inline as closures. Go functions support multiple return values — the foundation of Go’s error handling model.

Basic Functions#

func add(a int, b int) int {
 return a + b
}

// Shortened: consecutive params of same type
func add(a, b int) int {
 return a + b
}

Multiple Return Values#

Go functions can return multiple values. The dominant pattern is (result, error):

Structs & Methods

Mon, 01 Jan 0001 00:00:00 +0000

Structs & Methods#

Go has no classes. Structs are the primary way to define custom data types, and methods are functions with a receiver parameter that give structs behaviour.

Defining Structs#

type User struct {
 ID int
 FirstName string
 LastName string
 Email string
 CreatedAt time.Time
}

Creating Instances#

// Named fields (preferred — order-independent, self-documenting)
u := User{
 ID: 1,
 FirstName: "Alice",
 LastName: "Chen",
 Email: "alice@example.com",
 CreatedAt: time.Now(),
}

// Positional (fragile — breaks if fields are reordered)
u := User{1, "Alice", "Chen", "alice@example.com", time.Now()}

// Zero value
var u User // all fields are zero values

// Pointer
u := &User{ID: 1, FirstName: "Alice"}

Accessing Fields#

fmt.Println(u.FirstName)
u.Email = "new@example.com"

// Pointer access — Go auto-dereferences
p := &u
fmt.Println(p.FirstName) // same as (*p).FirstName

Methods#

A method is a function with a receiver — it binds the function to a type:

Interfaces

Mon, 01 Jan 0001 00:00:00 +0000

Interfaces#

Interfaces are Go’s primary abstraction mechanism. Unlike Java or C#, Go interfaces are satisfied implicitly — a type implements an interface simply by having the right methods. No implements keyword. No declaration of intent.

Defining Interfaces#

type Reader interface {
 Read(p []byte) (n int, err error)
}

type Writer interface {
 Write(p []byte) (n int, err error)
}

type ReadWriter interface {
 Reader
 Writer
}

An interface is a set of method signatures. Any type that has those methods satisfies the interface.

Concurrency

Mon, 01 Jan 0001 00:00:00 +0000

Concurrency#

Go was designed with concurrency as a first-class feature. Goroutines are lightweight threads managed by the Go runtime, and channels are typed conduits for communication between them. The motto: “Don’t communicate by sharing memory; share memory by communicating.”

Goroutines#

A goroutine is a lightweight concurrent function invocation. Starting one costs ~2 KB of stack (grows as needed) and is scheduled by the Go runtime, not the OS.

go doWork() // starts doWork as a goroutine

go func() {
 // anonymous goroutine
 fmt.Println("running concurrently")
}()

Goroutines vs Threads#

	Goroutine	OS Thread
Stack size	~2 KB (grows dynamically)	~1 MB (fixed)
Creation cost	~1 μs	~100 μs
Scheduling	Go runtime (M:N)	OS kernel
Practical count	Millions	Thousands
Communication	Channels (safe by design)	Shared memory + locks

Channels#

Channels are typed conduits for sending and receiving values between goroutines:

Error Handling

Mon, 01 Jan 0001 00:00:00 +0000

Error Handling#

Go does not have exceptions. Errors are values — returned from functions, inspected by callers, and handled explicitly. This is a deliberate design choice that makes error paths visible and forces you to think about failure at every call site.

The `error` Interface#

type error interface {
 Error() string
}

Any type with an Error() string method is an error. The most common way to create errors:

import "errors"
import "fmt"

// Simple error
err := errors.New("something went wrong")

// Formatted error
err := fmt.Errorf("user %d not found", userID)

The Error Return Pattern#

Functions that can fail return an error as the last value:

Generics

Mon, 01 Jan 0001 00:00:00 +0000

Generics#

Go 1.18 (2022) added generics — type parameters that let you write functions and types that work with multiple types while preserving type safety. Go’s generics are deliberately simpler than those in Java, Rust, or Haskell.

The Problem Generics Solve#

Before generics, you had three options for type-agnostic code:

// 1. Copy-paste for each type
func MinInt(a, b int) int { ... }
func MinFloat64(a, b float64) float64 { ... }
func MinString(a, b string) string { ... }

// 2. Use interface{}/any — loses type safety
func Min(a, b any) any { ... } // caller must type-assert

// 3. Code generation — complex tooling
//go:generate ...

With generics:

Standard Library

Mon, 01 Jan 0001 00:00:00 +0000

Standard Library#

Go’s standard library is one of its greatest strengths — comprehensive enough that many production services run with zero third-party dependencies. This section covers the packages you will use most often.

`fmt` — Formatted I/O#

fmt.Println("Hello") // print with newline
fmt.Printf("Name: %s, Age: %d\n", name, age) // formatted output
s := fmt.Sprintf("User %d", id) // format to string
fmt.Fprintf(w, "Response: %s", body) // format to writer

Format Verbs#

Verb	Description	Example
`%v`	Default format	`{Alice 30}`
`%+v`	With field names	`{Name:Alice Age:30}`
`%#v`	Go-syntax representation	`main.User{Name:"Alice", Age:30}`
`%T`	Type	`main.User`
`%d`	Integer (decimal)	`42`
`%b`	Integer (binary)	`101010`
`%x`	Integer (hex)	`2a`
`%f`	Float	`3.140000`
`%.2f`	Float (2 decimals)	`3.14`
`%s`	String	`hello`
`%q`	Quoted string	`"hello"`
`%p`	Pointer	`0xc000012080`
`%w`	Wrap error (Errorf only)	—

`net/http` — HTTP Server and Client#

HTTP Server#

mux := http.NewServeMux()

mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
 w.WriteHeader(http.StatusOK)
 w.Write([]byte("ok"))
})

mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
 id := r.PathValue("id") // Go 1.22+ path parameters
 fmt.Fprintf(w, "User: %s", id)
})

mux.HandleFunc("POST /users", func(w http.ResponseWriter, r *http.Request) {
 var user User
 if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
 http.Error(w, "bad request", http.StatusBadRequest)
 return
 }
 // process user
 w.WriteHeader(http.StatusCreated)
})

server := &http.Server{
 Addr: ":8080",
 Handler: mux,
 ReadTimeout: 5 * time.Second,
 WriteTimeout: 10 * time.Second,
 IdleTimeout: 120 * time.Second,
}
log.Fatal(server.ListenAndServe())

HTTP Client#

client := &http.Client{
 Timeout: 10 * time.Second,
}

resp, err := client.Get("https://api.example.com/users")
if err != nil {
 return err
}
defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {
 return fmt.Errorf("unexpected status: %d", resp.StatusCode)
}

var users []User
if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
 return err
}

Always set a timeout on http.Client. The default client has no timeout and will hang forever on a slow server.

Modules & Tooling

Mon, 01 Jan 0001 00:00:00 +0000

Modules & Tooling#

Go ships with a comprehensive toolchain — dependency management, testing, linting, profiling, and cross-compilation are all built in or a single go install away.

Modules#

go.mod#

module github.com/yourname/myproject

go 1.22

require (
 github.com/gorilla/mux v1.8.1
 github.com/lib/pq v1.10.9
)

require (
 // indirect dependencies
 golang.org/x/text v0.14.0 // indirect
)

Common Module Commands#

go mod init github.com/you/project # create go.mod
go mod tidy # add missing, remove unused
go mod download # download dependencies
go mod verify # verify checksums
go mod vendor # copy deps into ./vendor
go mod graph # show dependency graph
go get github.com/pkg@v1.2.3 # add/update specific version
go get -u ./... # update all direct deps

Version Selection#

Go uses Minimum Version Selection (MVS): if A requires lib@v1.2 and B requires lib@v1.3, Go picks v1.3 (the minimum version that satisfies all requirements). No SAT solver, deterministic, reproducible.

Patterns & Idioms

Mon, 01 Jan 0001 00:00:00 +0000

Patterns & Idioms#

Go has a strong culture of idiomatic code. These patterns are not in the language specification but are universally understood and expected by the Go community.

Project Layout#

Standard Layout (for Libraries and Services)#

myservice/
├── cmd/
│ └── myservice/
│ └── main.go # entry point
├── internal/
│ ├── handler/ # HTTP handlers
│ │ └── handler.go
│ ├── service/ # business logic
│ │ └── service.go
│ ├── repository/ # data access
│ │ └── repository.go
│ └── model/ # domain types
│ └── model.go
├── pkg/ # importable by other modules (optional)
│ └── client/
│ └── client.go
├── api/ # API specs (OpenAPI, protobuf)
│ └── openapi.yaml
├── migrations/ # database migrations
│ └── 001_create_users.sql
├── go.mod
├── go.sum
├── Makefile
├── Dockerfile
└── README.md

Small Tool / CLI#

mytool/
├── main.go
├── go.mod
└── go.sum

Key Directory Rules#

Directory	Visibility	Purpose
`cmd/`	—	Each subdirectory is a separate binary
`internal/`	Module-private	Cannot be imported by other modules
`pkg/`	Public	Can be imported — use only when you intend external use
No `/src`	—	Go does not use a `src/` directory (unlike Java)

Table-Driven Tests#

The canonical Go testing pattern:

Go on Software Engineering Learning Paths

Go Fundamentals

Go Fundamentals#

Philosophy#

The Go Proverbs#

Types & Variables

Types & Variables#

Declaring Variables#

Long Form#

Short Declaration (Most Common)#

Control Flow

Control Flow#

If/Else#

If with Init Statement#

Functions

Functions#

Basic Functions#

Multiple Return Values#

Structs & Methods

Structs & Methods#

Defining Structs#

Creating Instances#

Accessing Fields#

Methods#

Interfaces

Interfaces#

Defining Interfaces#

Concurrency

Concurrency#

Goroutines#

Goroutines vs Threads#

Channels#

Error Handling

Error Handling#

The error Interface#

The Error Return Pattern#

Generics

Generics#

The Problem Generics Solve#

Standard Library

Standard Library#

fmt — Formatted I/O#

Format Verbs#

net/http — HTTP Server and Client#

HTTP Server#

HTTP Client#

Modules & Tooling

Modules & Tooling#

Modules#

go.mod#

Common Module Commands#

Version Selection#

Patterns & Idioms

Patterns & Idioms#

Project Layout#

Standard Layout (for Libraries and Services)#

Small Tool / CLI#

Key Directory Rules#

Table-Driven Tests#

The `error` Interface#

`fmt` — Formatted I/O#

`net/http` — HTTP Server and Client#