Getting started

Install Go#

1. Download the installer for your system from go.dev/dl and run it.
2. Open a new terminal and check it worked:

go version
# go version go1.25.x linux/amd64

3. Install an editor with Go support. VS Code with the official Go extension is the most common choice. It installs gopls, the Go language server that gives you autocomplete, go-to-definition and inline errors.

Create a module#

A module is a project: a folder with a go.mod file at its root. The module path is the name other code uses to import it, conventionally the place it will live on GitHub.

mkdir godsa && cd godsa
go mod init github.com/you/godsa

That creates go.mod:

module github.com/you/godsa
 
go 1.25

Your first program#

Create main.go in the same folder:

package main
 
import "fmt"
 
// main is where the program starts.
func main() {
	fmt.Println("Hello, gopher")
}

Run it:

go run .
# Hello, gopher

Reading the program line by line#

Two rules surprise newcomers. First, the opening brace { must be on the same line as func main(); Go inserts semicolons automatically at line ends, and a brace on the next line would end the statement too early. Second, every import and every local variable must be used, or the program does not compile.

Change it and run it again

The fastest way to learn is to edit a working program and predict what will change. This one adds a variable, a loop and fmt.Printf, which fills in the % placeholders from its other arguments:

package main
 
import "fmt"
 
func main() {
	name := "gopher" // := declares a variable and infers its type
	fmt.Println("Hello,", name)
 
	for i := 1; i <= 3; i++ {
		fmt.Printf("lap %d of %d: %s is running\n", i, 3, name)
	}
 
	fmt.Printf("%q has %d letters\n", name, len(name)) // %q adds quotes
	fmt.Printf("%v %v %v\n", 42, 3.5, true)            // %v prints any value
}

Hello, gopher
lap 1 of 3: gopher is running
lap 2 of 3: gopher is running
lap 3 of 3: gopher is running
"gopher" has 6 letters
42 3.5 true

Now break it on purpose to see the two rules from above. Add an unused variable inside main:

	unused := 5

and go run . refuses to compile (the line number depends on where you put it):

./main.go:7:2: declared and not used: unused

Then move the { after func main() onto its own line and run again. Reading compiler errors calmly is a skill you will use every day.

The commands you will use every day#

How a program is organized#

godsa/
├── go.mod              module github.com/you/godsa
├── main.go             package main (the executable)
└── stack/
    ├── stack.go        package stack (a library)
    └── stack_test.go   tests for package stack

• One folder is one package. All files in a folder share the same package line.
• Other code imports a folder by module path plus folder: import "github.com/you/godsa/stack".
• Test files end in _test.go and are only compiled by go test.

You will build exactly this layout over the course, adding one package per data structure.

Summary#

• Install Go, then use go mod init to start every project.
• package main plus func main() makes a program; any other package name makes a library.
• Unused imports and variables are errors, braces stay on the same line, and gofmt decides formatting.
• go run ., go test ./..., go vet ./... and go doc cover most of your daily work.