article thumbnail

Go Crash Course

The Language That Powers the Cloud — Simple by Design
13 min read
#programming, #go, #golang, #friday1

Docker, Kubernetes, Terraform, Prometheus, and half the tools running your infrastructure are written in the same language. It's not C++, it's not Rust, and it's not Python. It's Go — the language Google built in 2009 because their C++ builds were taking 45 minutes and their new hires needed a week to become productive. Go's whole philosophy is less: fewer keywords, fewer ways to do the same thing, no clever tricks. You can learn the entire language in an afternoon and be shipping production services by the weekend. Here's your crash course.

Why Go Exists

Go was designed by Rob Pike, Ken Thompson (of Unix and C fame), and Robert Griesemer to solve real problems at Google scale:

The trade-off: Go is deliberately opinionated and sometimes verbose. There are no generics-everywhere gymnastics (though generics did arrive in 1.18), no operator overloading, no inheritance. Many developers find this restrictive at first and liberating within a week.

Installing Go

Go installs in about two minutes on any platform — no dependency dance, no version manager required to get started.

Windows:

1. Download the MSI installer from go.dev/dl
2. Run it — it installs to C:\Go and adds `go` to your PATH automatically
3. Open a new terminal and confirm: go version

Prefer the command line? winget install GoLang.Go does the same thing.

Linux:

# Grab the current tarball (check go.dev/dl for the latest version number)
wget https://go.dev/dl/go1.26.5.linux-amd64.tar.gz
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.26.5.linux-amd64.tar.gz

# Add Go to your PATH (~/.bashrc or ~/.profile)
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

go version

Your distro's package manager (apt, dnf) usually has a golang package too, but it often lags several versions behind — the official tarball keeps you on the current release.

Hello, Go

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Run it directly, or compile to a binary:

go run hello.go          # compile + run in one step
go build hello.go        # produces ./hello (a standalone binary)

Every file belongs to a package. The main package with a main() function is your entry point.

Variables and Types

Go is statically typed but infers types with :=, so it often feels dynamic.

var name string = "Ada"   // explicit
var age = 36              // type inferred (int)
count := 0               // short form — only inside functions

const Pi = 3.14159       // constants

// Zero values: everything has a sensible default
var s string   // ""
var n int      // 0
var ok bool    // false
var p *int     // nil

There's no null for value types — an uninitialized int is 0, not undefined. This kills an entire category of bugs.

The Type System in One Screen

// Basic types
int, int8, int16, int32, int64
uint, uint8 (byte), ..., uint64
float32, float64
bool, string
rune  // an int32 — one Unicode code point

// Composite types
[3]int          // array — fixed size
[]int           // slice — dynamic, the one you'll actually use
map[string]int  // hash map
struct{...}     // your custom types

Slices and maps are the workhorses:

nums := []int{1, 2, 3}
nums = append(nums, 4)          // [1 2 3 4]

ages := map[string]int{"Ada": 36, "Alan": 41}
ages["Grace"] = 45
age, exists := ages["Ada"]     // exists is true; the "comma-ok" idiom
delete(ages, "Alan")

Structs and Methods (No Classes)

Go has no classes. Instead you attach methods to structs.

type Point struct {
    X, Y int
}

// A method — the (p Point) is the "receiver"
func (p Point) Distance() float64 {
    return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}

// Pointer receiver lets you modify the struct
func (p *Point) Move(dx, dy int) {
    p.X += dx
    p.Y += dy
}

pt := Point{X: 3, Y: 4}
fmt.Println(pt.Distance())  // 5
pt.Move(1, 1)               // pt is now {4, 5}

Interfaces: Duck Typing, Verified at Compile Time

This is Go's most elegant idea. A type satisfies an interface simply by having the right methods — no implements keyword, no declaration.

type Shape interface {
    Area() float64
}

type Circle struct{ R float64 }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

type Square struct{ Side float64 }
func (s Square) Area() float64 { return s.Side * s.Side }

// Both Circle and Square satisfy Shape automatically
func printArea(s Shape) {
    fmt.Printf("Area: %.2f\n", s.Area())
}

printArea(Circle{R: 2})
printArea(Square{Side: 3})

The most famous interface in Go is error, which is just:

type error interface {
    Error() string
}

Error Handling: Explicit, Everywhere

Go has no exceptions. Functions return errors as ordinary values, and you check them. This is the single most divisive feature — and the reason Go code rarely surprises you at runtime.

f, err := os.Open("config.json")
if err != nil {
    return fmt.Errorf("opening config: %w", err)  // %w wraps the error
}
defer f.Close()   // runs when the function returns — no matter how

data, err := io.ReadAll(f)
if err != nil {
    return err
}

defer schedules cleanup to run when the surrounding function exits — the idiomatic way to close files, unlock mutexes, and release resources.

Concurrency: The Headline Feature

A goroutine is a function running concurrently, launched with the go keyword. They're cheap — you can run hundreds of thousands of them.

go doWork()   // runs doWork() concurrently and moves on

Channels let goroutines communicate safely without locks:

ch := make(chan int)

go func() {
    ch <- 42        // send a value into the channel
}()

result := <-ch      // receive (blocks until a value arrives)
fmt.Println(result) // 42

The Go motto: "Don't communicate by sharing memory; share memory by communicating."

A realistic pattern — run tasks concurrently and wait for all of them:

var wg sync.WaitGroup
for _, url := range urls {
    wg.Add(1)
    go func(u string) {
        defer wg.Done()
        fetch(u)
    }(url)
}
wg.Wait()   // blocks until all goroutines call Done()

And select waits on multiple channels at once — the foundation of timeouts and cancellation:

select {
case msg := <-ch:
    fmt.Println("got", msg)
case <-time.After(2 * time.Second):
    fmt.Println("timed out")
}

The Standard Library Is the Framework

Go ships with an industrial-strength standard library. This is a complete, production-viable web server — no dependencies:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello from %s", r.URL.Path)
    })
    http.ListenAndServe(":8080", nil)
}

encoding/json, net/http, database/sql, testing, crypto/*, and context cover most of what web apps need out of the box.

Modules and Tooling

Go's tooling is unified and comes in the box — no choosing between competing package managers, formatters, or linters.

go mod init example.com/myapp   # start a module (creates go.mod)
go get github.com/some/dep      # add a dependency
go build ./...                  # build everything
go test ./...                   # run all tests
go fmt ./...                    # auto-format (there is only ONE style)
go vet ./...                    # catch suspicious code

gofmt deserves special mention: Go has exactly one canonical formatting style, applied automatically. Every Go codebase on Earth looks the same. Formatting debates simply don't exist.

Testing Is Built In

No framework to install. Put tests in a _test.go file:

package math

import "testing"

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    if got != 5 {
        t.Errorf("Add(2,3) = %d; want 5", got)
    }
}
go test              # run tests
go test -bench=.     # run benchmarks
go test -cover       # report coverage

Generics (Since Go 1.18)

For years Go had no generics. Now it does, with a clean square-bracket syntax:

func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

doubled := Map([]int{1, 2, 3}, func(n int) int { return n * 2 })
// [2 4 6]

Use them sparingly — the community norm is "reach for generics only when interfaces genuinely don't fit."

Quick Reference: Coming From Another Language

You know... In Go it's...
class struct + methods
implements Interface just have the methods (implicit)
try/catch/throw if err != nil { return err }
null nil (only for pointers, slices, maps, interfaces)
thread / async go func() (goroutine)
finally defer
pip / npm go get + go.mod
list / array slice []T
dict / HashMap map[K]V
ternary a ? b : c (none — use an if)

Gotchas That Trip Up Newcomers

Where Go Shines (and Where It Doesn't)

Great for: network services, CLIs, DevOps tooling, APIs, microservices, anything that needs to be a single deployable binary. Its concurrency model and fast compiles make it ideal for backend infrastructure.

Less ideal for: heavy numerical/scientific computing (Python/Julia win), GUI desktop apps, or domains that lean on deep generic abstractions and metaprogramming.

A question worth asking directly: is Go a good replacement for a LAMP/WAMP stack? Sort of — but it asks you to think differently rather than swap like-for-like. A PHP site under Apache is a folder of files an interpreter re-parses on every request; a Go site is one compiled binary that is the web server, since net/http handles routing and serving with nothing in between. That binary can talk to the very same MySQL/MariaDB database your LAMP stack already uses, through database/sql and a driver like go-sql-driver/mysql, and frameworks such as Gin, Echo, or Fiber get you close to the routing-and-middleware convenience of a PHP framework. Where Go wins outright: no interpreter overhead, one binary to deploy, and concurrency that shrugs off traffic a stock Apache/PHP-FPM box would choke on. Where LAMP still wins: cheap shared hosting (most hosts won't run an arbitrary compiled binary for you) and the enormous plugin ecosystems of WordPress and friends. Treat Go as the right tool for a new API or backend, not a drop-in replacement under an existing WordPress install.

And yes — it runs great on a Raspberry Pi. Go ships official ARM builds, and you can cross-compile a Pi-ready binary from your own laptop with GOOS=linux GOARCH=arm64 go build (or GOARCH=arm for older 32-bit boards) — you don't even need to install Go on the Pi itself. Between the tiny memory footprint and single-binary deploys, a Pi quietly running a small Go API or home-automation service is one of the more satisfying weekend projects out there.

Getting Started Checklist

Don't want to install anything yet? Open the Go Playground and paste in any snippet from this article — it compiles and runs server-side, right in your browser. Once you're ready to practice for real, Go by Example walks through the language one annotated program at a time, learngo hands you a thousand small broken programs to fix, and Exercism's Go track pairs exercises with free human mentoring. Once the fundamentals click and you want to see how real projects fit together, Awesome Go is the definitive curated list of libraries and frameworks people actually use.

✅ Install Go from go.dev (or your package manager) ✅ Run go version to confirm ✅ go mod init myproject to start ✅ Write main.go, run it with go run . ✅ Format on save with gofmt (your editor plugin does this automatically) ✅ Take the interactive A Tour of Go ✅ Read Effective Go — the canonical style guide

Conclusion: Go won't dazzle you with clever features — that's the point. It trades expressiveness for readability, and cleverness for maintainability, and it wins on both fronts once a codebase has more than one author. The language is small enough to learn in a day, the tooling is unified and excellent, and the result compiles to a single binary you can drop onto any server. Install it, take the tour, and build a small HTTP service this weekend. You'll understand why the cloud runs on Go.

Most covered topics

Databases Python AI PHP Linux JavaScript