Getting Started with Go, Part 1: Setup & Syntax Basics

Installing Go and starting a module

Grab the toolchain from go.dev/dl — there's no separate package manager to install alongside it, go is a single binary that compiles, tests, formats, and manages dependencies. Confirm it landed:

go version

Then start a module — the unit Go uses to track your code and its dependencies, replacing the old GOPATH convention entirely:

mkdir jobrunner && cd jobrunner
go mod init jobrunner

That gives you a go.mod file with your module's name and the Go version you're targeting. You won't touch it much by hand; go get and go mod tidy manage it for you once there are real dependencies to track. We won't need any for a while — the standard library covers everything in this series.

Variables, types, and zero values

Go is statically typed, but it infers types constantly so it rarely feels like it:

var name string = "urgent-deploy"  // explicit
name2 := "cleanup"                 // inferred — the common form
var retries int                    // no initializer: zero value, 0

That last line matters more than it looks. Go doesn't have "uninitialized" variables — every type has a zero value (0 for numbers, "" for strings, false for bools, nil for pointers/slices/maps/interfaces), and a declared-but-unassigned variable always gets it. There's no null-pointer-style trap waiting from a variable you forgot to set; there's just a defined, sometimes-inconvenient default you have to be aware of.

:= only works inside functions — it declares and infers in one step, and it's what you'll use for nearly everything. var shows up at package level, or when you want the zero value explicitly, or need a type wider than what the literal would infer (var priority int64 = 3).

Control flow: if, for, switch

Go strips the ceremony down to three constructs. if needs no parentheses around the condition, but the braces are mandatory even for one-liners:

if retries > 3 {
    fmt.Println("giving up")
} else if retries > 0 {
    fmt.Println("retrying")
}

for is the only loop keyword — no while, no do-while. It just omits parts of the classic three-clause form to get there:

for i := 0; i < len(jobs); i++ { /* classic */ }
for retries < 3 { /* while-style */ }
for {              /* infinite, break to exit */ }
for i, job := range jobs { /* range: index + value */ }

switch doesn't fall through by default (the opposite of C/Java — you opt in with fallthrough if you actually want it), and it doesn't need a tag value at all, which makes it a clean replacement for an if/else-if chain:

switch {
case strings.HasPrefix(name, "urgent-"):
    return "HIGH"
case strings.HasPrefix(name, "batch-"):
    return "LOW"
default:
    return "NORMAL"
}

Functions and multiple return values

Functions declare parameter types after the name and the return type after the parameter list:

func classify(name string) string {
    // ...
}

The feature that shapes idiomatic Go more than any other single thing: functions can return more than one value, and the convention that grew out of it is (result, error) — no exceptions, no try/catch, just an error value you're expected to check immediately:

func parsePriority(s string) (int, error) {
    switch s {
    case "HIGH":
        return 2, nil
    case "NORMAL":
        return 1, nil
    case "LOW":
        return 0, nil
    default:
        return 0, fmt.Errorf("unknown priority %q", s)
    }
}

We'll build on this return-an-error convention properly in Part 2, once we have real types worth failing on.

The first version of jobrunner

Here's everything above in one program — classify a list of jobs by name prefix and print them with their priority. This is a complete program, so it's runnable — hit Run and it executes for real:

package main

import (
	"fmt"
	"strings"
)

func classify(name string) string {
	switch {
	case strings.HasPrefix(name, "urgent-"):
		return "HIGH"
	case strings.HasPrefix(name, "batch-"):
		return "LOW"
	default:
		return "NORMAL"
	}
}

func main() {
	jobs := []string{"urgent-deploy", "cleanup", "urgent-migrate", "batch-report"}

	for i, name := range jobs {
		priority := classify(name)
		fmt.Printf("%d. [%s] %s\n", i+1, priority, name)
	}
}

The jobs slice is hardcoded here so the example runs standalone in a sandbox with no arguments — in a real CLI you'd read it from os.Args[1:] instead (index 0 is always the program's own path). That's a one-line swap once you're running this on your own machine, and it's the natural next step if you want to try it locally.

That's the whole toolkit this part needed: variables with real zero values, if/for/switch, and functions — enough to write real programs, just not yet ones that model a problem with actual types. That's Part 2.

Further Reading

• A Tour of Go — the official interactive intro, good for drilling syntax further
• Effective Go — idioms and conventions, worth reading once you're past the basics
• The Go Programming Language Specification — the actual source of truth when a rule seems surprising