Installing Go and your first program

This chapter gets Go on your machine, gets a program running, and introduces the toolchain. If you have ever set up a Node project you will find this shorter than you expect, because most of the steps you are used to do not exist.

Installing

Go to #link("https://go.dev/dl/")[go.dev/dl] and download the installer for your platform. There is no version manager to install first, no equivalent ofnvm, and for most people there never needs to be. Go's compatibility promise means a program written for Go 1.0 in 2012 still compiles today, so "which version" is rarely a question that costs you an afternoon.

Check it worked:

go version

You should see something like go version go1.25.0 windows/amd64. If the command is not found, the installer did not put Go on your PATH; restart your terminal first, because that fixes it more often than anything else.

Your first program

Make a directory and put one file in it.

// main.go
package main

import "fmt"

func main() {
    fmt.Println("Hello from Go")
}

Run it:

go run main.go

Four things in that tiny file deserve explanation, because each is a rule you will meet constantly.

package main declares which package this file belongs to. Every Go file starts with a package declaration. The name main is special: it means this package builds into a runnable program rather than a library.

import "fmt" pulls in the formatting package from the standard library. Note there is no npm install. fmt ships with Go, as does an HTTP server, a JSON encoder, a test runner, a crypto suite and a templating engine.

func main() is the entry point. A program starts here. There is exactly onemain function in a program.

fmt.Println prints a line. Capital P matters enormously, and it is the next section.

Capital letters are the access modifier

This is the first genuinely surprising rule in Go, and it catches everybody.

*An identifier starting with a capital letter is exported. One starting with a lowercase letter is private to its package.* That is the entire visibility system. There is no public, no private, no export keyword.

package money

// Convert is callable from other packages, because it is capitalised.
func Convert(cents int) string { ... }

// round is not. Only code inside package money can call it.
func round(f float64) int { ... }

Modules: go.mod is your package.json

A single file is fine for a demo. A real project is a module. Initialise one:

mkdir hello && cd hello
go mod init github.com/yourname/hello

That writes go.mod:

module github.com/yourname/hello

go 1.25

That is the whole file. Compare it to a package.json for an equivalent project and notice what is missing: no scripts, no devDependencies, nomain, no type: module. The module path doubles as the import path, which is why it looks like a URL: if you push this to GitHub, anybody can import it at exactly that address with no registry publish step.

Add a dependency and go.mod grows a line:

go get github.com/google/uuid

module github.com/yourname/hello

go 1.25

require github.com/google/uuid v1.6.0

The commands you will actually use

Six commands cover almost everything.

• go run .
• Compile and run the current package, without keeping the binary
• go build
• Compile to an executable in the current directory
• go test ./...
• Run every test in this module
• go mod tidy
• Add what is imported, remove what is not. Run it often
• gofmt -w .
• Format every file. Your editor probably does this on save
• go vet ./...
• Report suspicious code the compiler allows

The ./... pattern means "this directory and everything under it", and you will type it constantly.

Compiling a real binary

This is the part that sells Go to people who have deployed Node.

go build -o hello .
./hello

You now have one executable file. It contains your code, every dependency, and the Go runtime. The target machine needs nothing installed. You can also build for a platform you are not on:

GOOS=linux GOARCH=amd64 go build -o hello-linux .

That produces a Linux binary from a Mac or Windows laptop, with no container, no cross-compilation toolchain and no configuration. Copy it to a Linux server and it runs.

package main

import (
    "fmt"
    "os"
)

func main() {
    name := "world"
    if len(os.Args) > 1 {
        name = os.Args[1]
    }
    fmt.Printf("Hello, %s\n", name)
}

Assignment

Commit your work with the message Hello Go - Assignment One, exactly as written, so the leaderboard can score it.

go build -o hello .
ls -lh hello > BUILD.txt