Introduction to Go

🎯 Learning Objectives

🐹 What is Go?

Go (also known as Golang) is a statically typed, compiled, garbage-collected, concurrent systems programming language designed at Google. It was created to solve real engineering problems at scale — not as an academic exercise.

Here's what each of those properties actually means in practice:

Go by the Numbers

📜 History of Go

Go was born out of frustration. In 2007, engineers at Google were working with enormous codebases written in C++ and Java. Build times were catastrophically long — a full C++ build could take 45 minutes. The code was complex, hard to reason about, and concurrent programming was a nightmare.

The Creators

🧘 The Go Philosophy

Understanding Go's philosophy is essential — it explains why the language is designed the way it is, and why experienced Go programmers make certain decisions. The Go team is famously opinionated.

Simplicity First

Go has exactly 25 keywords. Python has 35. Java has 67. C++ has over 80. This is not an accident — it's a core design goal. Rob Pike has said repeatedly:

The 25 Keywords

Here are all 25 Go keywords — memorise them. This is a common interview question:

// Go's complete set of 25 reserved keywords

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Compare this to other languages: Python 3: 35 keywords, Java: 67, C++: 84, Rust: 39. Go's minimal keyword set means less to learn and less cognitive overhead.

❓ Why Does Go Exist?

Go was created to solve three specific problems that Google faced at scale. Understanding these problems helps you understand every design decision in the language.

Problem 1: Compilation Speed

Google's C++ codebase took 45+ minutes to build. Go was designed from the start to compile enormous codebases in seconds. How?

• No header files: C and C++ require #include directives that cause repeated parsing. Go imports are explicit and compiled once.
• Strict unused import rule: If you import a package and don't use it, it's a compile error. This prevents bloated dependency graphs.
• Dependency-free compilation: To compile package A that imports B, you only need the compiled output of B — not all of B's dependencies. This enables parallel compilation.

// This will NOT compile — unused imports are a compile error
package main

import (
    "fmt"
    "os"    // ← error: "os" imported and not used
)

func main() {
    fmt.Println("Hello")
    // os is imported but never used — Go refuses to compile this
}

Problem 2: Complexity at Scale

Large codebases with many engineers become unmaintainable over time. C++ templates, Java class hierarchies, and Python's dynamic typing all create complexity that grows faster than the codebase. Go's answer:

• No classes: No inheritance hierarchies that grow out of control
• Implicit interfaces: Any type can satisfy an interface without declaring it — no coupling between packages
• One formatter: gofmt means every Go file looks the same, everywhere, always
• No exceptions: Errors are values; you cannot silently swallow them

Problem 3: Concurrency

Modern servers need to handle thousands of concurrent connections. Threads are expensive (typically 1–8 MB stack each). Callback-based async code (Node.js-style) is hard to reason about. Go's answer: goroutines.

// Launching 100,000 goroutines is perfectly normal in Go
// This would crash most systems using OS threads

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 100_000; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            // Each goroutine does work concurrently
            _ = id * 2
        }(i)
    }

    wg.Wait()
    fmt.Println("All 100,000 goroutines completed!")
}
// Memory used: ~800 MB (8KB × 100,000)
// Using OS threads: would require ~100 GB just for stacks

⚖️ Advantages & Disadvantages

Every language involves trade-offs. Go is no exception. Understanding what Go does well — and where it falls short — makes you a more effective programmer.

⚙️ How Go Compiles

Understanding how Go compiles code helps you reason about performance, binary sizes, and deployment strategies.

The Compilation Pipeline

1. Parsing: The source files are tokenised and parsed into an Abstract Syntax Tree (AST). Go's parser is extremely fast because the grammar is simple and unambiguous.
2. Type checking: The AST is type-checked. All types are resolved, method calls are verified, interfaces are checked. This is where most Go errors are caught.
3. Escape analysis: The compiler determines which variables can live on the stack (fast) vs which must escape to the heap (GC-managed).
4. SSA generation: The AST is converted to Static Single Assignment form — an intermediate representation (IR) used for optimisation.
5. Optimisation passes: Inlining, dead code elimination, bounds check elimination, and many other optimisations are applied.
6. Code generation: The SSA IR is translated to machine code for the target architecture (amd64, arm64, etc.).
7. Linking: All compiled packages are linked into a single binary. The Go runtime (scheduler, GC, stack management) is embedded in the binary.

Static vs Dynamic Linking

// Build a simple program
$ go build -o myapp main.go
$ file myapp
myapp: Mach-O 64-bit executable arm64

// Check binary size
$ ls -lh myapp
-rwxr-xr-x 1.8M myapp   ← includes the Go runtime

// Cross-compile for Linux from macOS
$ GOOS=linux GOARCH=amd64 go build -o myapp-linux main.go

// Inspect what's inside the binary
$ go version -m myapp
myapp: go1.22.0  ← embedded Go version info

🔄 The Go Runtime

Unlike C/C++, Go includes a runtime that is embedded in every binary. This runtime is responsible for three critical subsystems:

The GMP Model (Goroutine Scheduler)

The Go scheduler implements the GMP model:

Garbage Collection in Go

Go uses a concurrent tri-color mark-and-sweep garbage collector. Here's how it works at a conceptual level:

1. Mark setup (STW, ~100µs): The world is briefly stopped to enable write barriers — tiny hooks that track pointer changes during GC.
2. Concurrent marking: GC goroutines scan the heap concurrently with your program. Objects are coloured: white (not yet seen), grey (found but children not scanned), black (fully scanned).
3. Mark termination (STW, ~100µs): Final phase to ensure all objects are accounted for. Very short.
4. Concurrent sweeping: White objects (unreachable) are swept. Memory is returned to the allocator. Done concurrently — your program keeps running.

package main

import (
    "fmt"
    "runtime"
)

func main() {
    // Inspect runtime info
    fmt.Printf("Go Version: %s\n", runtime.Version())
    fmt.Printf("OS/Arch:    %s/%s\n", runtime.GOOS, runtime.GOARCH)
    fmt.Printf("CPUs:       %d\n", runtime.NumCPU())
    fmt.Printf("Goroutines: %d\n", runtime.NumGoroutine())

    // Inspect memory stats
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("HeapAlloc:  %d bytes\n", m.HeapAlloc)
    fmt.Printf("NumGC:      %d\n", m.NumGC)
    fmt.Printf("PauseTotal: %d ns\n", m.PauseTotalNs)
}

🔨 The Go Toolchain

The go command is a powerful Swiss Army knife. Understanding these commands is essential for every Go developer.

🌍 The Go Ecosystem

Go's ecosystem is one of its strongest assets. Many of the world's most important infrastructure tools are written in Go.

Famous Projects Written in Go

Where Go Excels

• 🌐 Web services & APIs — HTTP servers, REST/gRPC microservices
• 🔧 CLI tools — Single binary, cross-platform, fast startup
• ☁️ Cloud infrastructure — Kubernetes operators, Terraform providers
• 🗄️ Databases & storage — CockroachDB, InfluxDB, etcd
• 🔒 Security tools — Vault, Consul, Packer (all HashiCorp)
• ⚡ High-performance services — Anything needing low latency + high throughput

Where Go Is Less Suitable

• 🖥️ GUIs — No mature native GUI toolkit
• 🤖 Machine Learning — Python + TensorFlow/PyTorch dominate
• 🎮 Game development — GC pauses and lack of game engines
• 🔬 Scientific computing — NumPy/SciPy ecosystem is unmatched

✅ Best Practices for New Go Developers

1. Always run gofmt on your code — or better, configure your editor to run it on save.
2. Always run go vet before committing — it catches subtle bugs gofmt won't.
3. Use go mod from day one — never put production code in $GOPATH/src.
4. Read the official Effective Go guide — it encodes the philosophy of idiomatic Go.
5. Use the standard library first — Go's stdlib is exceptional. Reach for third-party packages only when the stdlib is genuinely insufficient.
6. Understand the difference between go run (development) and go build (production).
7. Learn to read error messages — Go's compiler errors are precise and helpful.

🎤 Interview Questions

🧪 Chapter Quiz

✏️ Exercises

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println("Hello, Go World!")
    fmt.Printf("Go version: %s\n", runtime.Version())
    fmt.Printf("CPUs available: %d\n", runtime.NumCPU())
}

📋 Summary

📌 Cheat Sheet

📚 Further Reading

• The Go FAQ — Official answers to common questions about Go's design
• Go at Google: Language Design in the Service of Software Engineering — Rob Pike's essay explaining Go's design decisions
• The Go Brand Book — The official Go design philosophy
• Effective Go — The canonical guide to idiomatic Go
• Getting to Go: The Journey of Go's Garbage Collector — Deep dive into Go's GC evolution
• The Go Scheduler — Excellent explanation of the GMP model