Hello, Go

1 · The intuition

Go was designed at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson. Their complaint: large C++ programs took 45 minutes to compile, and the resulting binaries needed a dozen build flags to behave. Go's answer: compile every Go program ever written in seconds; only one way to format; one binary builds, tests, and ships.

That ethos shows up everywhere. There's no separate package manager: go mod is built in. There's no formatter argument: gofmt has no options. There's no test runner: go test is the runner. You'll use five commands every day for the next year.

2 · Try it: your first Go program

Open a terminal. Make a directory. Put this in a file called main.go.

1234567891011

// Every Go file declares which package it's part of.
// "main" is special — it's a program, not a library.
package main

// Imports go below the package line. fmt is the formatting + IO package.
import "fmt"

// "main" is the function the program runs. No arguments, no return.
func main() {
    fmt.Println("Hello, Go!")
}

Two things happened in that one command. Go compiled main.go to a temporary binary, then ran the binary. The whole process takes about 200 ms on modern hardware. The compile time is so fast Go treats it like an interpreted language, but the output is native code.

3 · Build it up: three variations

Variation 1: pass an argument

12345678910111213141516

package main

import (
    "fmt"
    "os"
)

func main() {
    // os.Args is a []string. Element 0 is the program name; 1+ are the args.
    if len(os.Args) < 2 {
        fmt.Println("Usage: go run main.go <name>")
        return
    }
    fmt.Printf("Hello, %s!
", os.Args[1])
}

Variation 2: read stdin

12345678910111213141516

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    fmt.Print("Name? ")
    scanner := bufio.NewScanner(os.Stdin)
    if scanner.Scan() {
        fmt.Printf("Hello, %s!
", scanner.Text())
    }
}

Variation 3: multiple files in one package

A real Go program rarely lives in one file. Make a second file greet.go in the same directory:

1234567

package main

// Capitalised names are exported from the package.
// Lower-case names are package-private. This one is package-private.
func greet(name string) string {
    return "Hello, " + name + "!"
}

And change main.go:

1234567

package main

import "fmt"

func main() {
    fmt.Println(greet("Go"))
}

Run go run . (the dot means "all files in the current directory"). Same output. The package gathered both files automatically.

4 · The toolchain: what each command does

5 · Common mistakes

• Forgetting package main. Every Go file declares its package. The one that contains func main() must be in package main. Without it, go run errors with "no main function".
• Unused imports. Go refuses to compile if you import a package you don't use. This is a feature, keeps imports tidy, but newcomers hit it constantly. Editor with the Go extension auto-fixes on save.
• Unused variables. Same rule: declare a variable and don't use it? Compile error. Use _ (the blank identifier) to throw away values you don't care about: _, err := os.Open("foo").
• Capitalisation matters. A name starting with a capital letter is exported (visible outside the package). A lowercase name is private. The compiler enforces it; there is no public or private keyword.
• Missing braces. Go requires braces around every if / for body: no exceptions. if x { doIt() } is fine; if x doIt() is a parse error.

6 · From the wild: real Go

A snippet from a project you've heard of: etcd, the distributed key-value store powering Kubernetes. This is the actual entrypoint of the etcd binary, simplified. Notice: it's the same shape you just wrote.

12345678910111213

package main

import (
    "fmt"
    "os"

    "go.etcd.io/etcd/server/v3/etcdmain"
)

func main() {
    etcdmain.Main(os.Args)
    fmt.Println("etcd shutdown")
}

Four imports, one main(), one library call, one print. Nothing fancy. Production Go is mostly this shape, expanded: the boilerplate stays small even at 100k-LOC scale.

7 · Coming from another language?

8 · Exercises (~10 min)

1. Echo three times. Modify the program to print "Hello, Go!" three times. Try a for loop: Go's only loop keyword.
2. Greet the OS. Use runtime.GOOS (import the runtime package) to print "Hello from linux/darwin/windows". Hint: Println accepts multiple args.
3. The 30-second build. Run go build . in your directory. What appears? Run that file directly (e.g. ./hello). Confirm: the binary doesn't need Go installed on the machine to execute.
4. Break it on purpose. Remove the import "fmt" line. Run again. Read the compiler error. Re-import. Now remove the fmt. prefix from Println. Read that error. The error messages are part of the experience.

9 · When it clicks

You can answer these questions without looking anything up:

• What does go run . do that go build . doesn't?
• If you have main.go and util.go in the same directory, do they share variables?
• Why is the function called Println and not println?
• What happens if you import fmt but never call any of its functions?

If those are all easy, you've got Day 1 of Go. Move on.