Introduction: What Go Is

Go is a programming language. You write instructions as plain text in a file. A program called the compiler reads that file and produces an executable: one file your computer can run on its own, with nothing else installed beside it.

Go is statically typed. A type is the kind of a value, such as a whole number or a piece of text. You write types down, and the compiler checks them before the program runs. Adding text to a number is caught when you build, not when a customer hits it.

What Go leaves out

The language has 25 keywords. There is no class inheritance, no exceptions, no operator overloading and no macros. An error is an ordinary value that a function hands back, so every place an error can appear is visible in the code. Code layout is decided by a tool, not by argument. Less to learn means more code you can read on your first day in an unfamiliar project.

What it is for

Go was built for servers and command line tools. Builds take seconds. The language has built-in support for doing several things at the same time, which Stage 5 covers. Docker, Kubernetes and Terraform are written in Go.

This course documents Go 1.27. Where behaviour depends on the version, the lesson says which version introduced it.

package main

import "fmt"

func main() {
	// A variable is a named place that holds a value.
	// count holds whole numbers. The type for whole numbers is int.
	var count int = 3
	// A string is a piece of text.
	var name string = "service"

	fmt.Println(name, "started with", count, "workers")

	// count = "three" would not build. int and string are different types,
	// and the compiler checks that before the program ever runs.
}

// Output:
// service started with 3 workers

package main

import (
	"fmt"
	"strconv"
)

func main() {
	count := 3 // a whole number

	// count + " workers" does not compile: a number and text are different types.
	// strconv.Itoa turns a whole number into text first.
	line := strconv.Itoa(count) + " workers"

	fmt.Println(line)
}

// Output:
// 3 workers

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// strconv.Atoi turns text into a whole number.
	// It hands back two things: the number, and an error value.
	n, err := strconv.Atoi("41")
	if err != nil {
		// nil means "no error". This part runs only when the text was not a number.
		fmt.Println("bad input:", err)
		return
	}

	fmt.Println("next:", n+1)
}

// Output:
// next: 42

$ go build .
./main.go:9:17: invalid operation: count + " workers" (mismatched types int and untyped string)