Exercises — Module 0: Introduction¶

Work through exercises in order — they're designed to build on each other. Attempt each problem genuinely before looking at the solution. Seeing the solution first might feel like progress, but it isn't.

Instructions¶

1. Attempt first. Spend at least the estimated time on each problem before checking hints or solutions.
2. Write your work. Don't just run code mentally — actually type and run your attempt.
3. Check your answer against the acceptance criteria, not just the solution code.
4. Score yourself honestly in the Scoring Log at the bottom.
5. If you're stuck after a genuine effort, use the hints one at a time — not all at once.

Difficulty Legend¶

Exercise 1: Install Go and Verify [🟢 Easy] [1 pt]¶

Context¶

Before you can write any Go code, you need a working Go installation. This exercise confirms that your environment is ready and that you know how to check it. It's a warm-up to confirm you have the most basic prerequisite: a working toolchain.

Task¶

Install Go on your system (or confirm it's already installed) and verify the installation by running three commands.

Requirements¶

• Running go version prints a Go 1.18 or later version string
• Running go env GOPATH prints a directory path (not an error)
• Running go env GOROOT prints the Go installation directory

Hints¶

Expected Output / Acceptance Criteria¶

$ go version
go version go1.21.5 linux/amd64   (version and OS/arch will differ)

$ go env GOPATH
/home/yourname/go                   (a real directory path)

$ go env GOROOT
/usr/local/go                       (your Go installation path)

Solution¶

Exercise 2: Write and Run Hello World [🟢 Easy] [1 pt]¶

Context¶

The canonical first program in any language. Writing it yourself (not copying) builds the muscle memory of the required structure: package declaration, import, and main function.

Task¶

Create a new directory, create a file named main.go inside it, and write a Go program that prints Hello, World!. Run it with go run.

Requirements¶

• File is named main.go and begins with package main
• The fmt package is imported
• func main() is present and is the entry point
• Running go run main.go prints exactly Hello, World!
• You wrote this by hand — no copy-paste

Hints¶

Expected Output / Acceptance Criteria¶

Hello, World!

Solution¶

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Exercise 3: Run with go run [🟢 Easy] [1 pt]¶

Context¶

go run is the fastest way to test a Go program during development. This exercise ensures you understand the difference between go run (run without leaving a binary) and go build (compile to a binary). Both are essential daily tools.

Task¶

Take your hello.go from Exercise 2 and run it two ways: with go run and with go build. Confirm both produce Hello, World! and observe the difference.

Requirements¶

• go run main.go runs the program and prints the output
• go build -o hello . creates a binary file named hello in the current directory
• Running ./hello (Linux/macOS) or hello.exe (Windows) produces the same output
• You can explain the difference between the two commands

Hints¶

Expected Output / Acceptance Criteria¶

$ go run main.go
Hello, World!

$ go build -o hello .
$ ./hello
Hello, World!

Solution¶

# Run without compiling to disk
go run main.go

# Compile to a binary
go build -o hello .

# Run the binary
./hello      # Linux/macOS
# hello.exe  # Windows

Exercise 4: Print Go Version with runtime Package [🟡 Medium] [2 pts]¶

Context¶

The runtime package provides information about the running Go environment. Using it demonstrates that you can import and call a package beyond fmt, and it's a practical introduction to reading Go package documentation.

Task¶

Write a Go program that prints the current Go version, the operating system, the CPU architecture, and the number of available CPUs. Use only the runtime package (and fmt for printing).

Requirements¶

• Program uses runtime.Version() to get the Go version string
• Program uses runtime.GOOS to get the operating system name
• Program uses runtime.GOARCH to get the CPU architecture
• Program uses runtime.NumCPU() to get the CPU count
• Output is formatted clearly (one piece of information per line)

Hints¶

Expected Output / Acceptance Criteria¶

Go version:   go1.21.5
OS:           linux
Architecture: amd64
CPUs:         8

Solution¶

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println("Go version:  ", runtime.Version())
    fmt.Println("OS:          ", runtime.GOOS)
    fmt.Println("Architecture:", runtime.GOARCH)
    fmt.Println("CPUs:        ", runtime.NumCPU())
}

Exercise 5: Greeting Program with a Function [🟡 Medium] [2 pts]¶

Context¶

Functions are the primary unit of code organization in Go. This exercise introduces defining your own function with a parameter, calling it multiple times, and using fmt.Sprintf to build strings. It's the first step beyond a single-line main function.

Task¶

Write a Go program that defines a greet function accepting a name as a string parameter. The function should return a greeting string (not print it directly). Call greet from main for at least three different names and print the results.

Requirements¶

• A function greet(name string) string is defined outside of main
• The function returns a formatted string like "Hello, Alice! Welcome to Go."
• main calls greet at least three times with different names
• main prints the returned strings using fmt.Println
• The function does not call fmt.Println itself — it only returns a string

Hints¶

s := fmt.Sprintf("Hello, %s!", name)
return s

Expected Output / Acceptance Criteria¶

Hello, Alice! Welcome to Go.
Hello, Bob! Welcome to Go.
Hello, Charlie! Welcome to Go.

Solution¶

package main

import "fmt"

// greet returns a personalized greeting string.
func greet(name string) string {
    return fmt.Sprintf("Hello, %s! Welcome to Go.", name)
}

func main() {
    fmt.Println(greet("Alice"))
    fmt.Println(greet("Bob"))
    fmt.Println(greet("Charlie"))
}

Exercise 6: Use go fmt on Intentionally Bad Formatting [🟡 Medium] [2 pts]¶

Context¶

go fmt is not optional in Go — it enforces a single canonical formatting style. This exercise builds the habit of running go fmt and shows you exactly what it fixes. Understanding what the formatter does (and trusting it) is part of working as a Go developer.

Task¶

Take the following poorly formatted Go program, save it to a file, run go fmt on it, and observe what changes. Then describe at least three formatting issues that go fmt fixed.

package main
import   "fmt"
func main(){
fmt.Println( "Hello" )
x:=42
fmt.Println(x)  }

Requirements¶

• You saved the badly formatted code to a real file
• You ran go fmt (or go fmt ./...) on it
• The file is now correctly formatted
• You can name at least three specific things go fmt changed

Hints¶

Expected Output / Acceptance Criteria¶

After go fmt, the file should look like:

package main

import "fmt"

func main() {
    fmt.Println("Hello")
    x := 42
    fmt.Println(x)
}

Three things go fmt fixed: 1. Added a blank line between import and func main() 2. Added proper tab indentation inside the function body 3. Removed the extra space inside fmt.Println( "Hello" ) → fmt.Println("Hello") 4. Fixed the spacing around := (x:=42 → x := 42) 5. Moved the closing } to its own line

Solution¶

# Save the bad code to bad.go, then:
go fmt bad.go
# or for all files in the module:
go fmt ./...

Exercise 7: Multi-File Program [🔴 Hard] [3 pts]¶

Context¶

Real Go programs are not single files. This exercise introduces the concept of multiple .go files in the same package — they share the same namespace, so functions defined in one file are visible in another without any import. This is how Go programs are actually organized.

Task¶

Create a directory with two files: main.go and math.go. In math.go, define two functions: add(a, b int) int and multiply(a, b int) int. In main.go, call both functions and print the results. Both files must be in package main.

Requirements¶

• math.go contains add and multiply functions in package main
• main.go calls both functions from main() without any import of math.go
• Running go run . (note the ., not a filename) runs both files together
• Running go build . compiles both files into a single binary
• The program prints correct results for addition and multiplication

Hints¶

myprogram/
  main.go    — has package main, import "fmt", func main() calling add() and multiply()
  math.go    — has package main, func add(a, b int) int, func multiply(a, b int) int

Expected Output / Acceptance Criteria¶

add(3, 4) = 7
multiply(3, 4) = 12

Solution¶

package main

// add returns the sum of a and b.
func add(a, b int) int {
    return a + b
}

// multiply returns the product of a and b.
func multiply(a, b int) int {
    return a * b
}

package main

import "fmt"

func main() {
    fmt.Printf("add(3, 4) = %d\n", add(3, 4))
    fmt.Printf("multiply(3, 4) = %d\n", multiply(3, 4))
}

Exercise 8: Use go vet to Find a Bug [🔴 Hard] [3 pts]¶

Context¶

go vet finds likely mistakes that compile but are almost certainly wrong. This exercise trains the habit of running go vet as part of development — and shows you what kind of bugs it catches that the compiler misses.

Task¶

Save the following buggy program to a file and run go vet on it. Identify the bug, explain why it's a problem, and fix it.

package main

import "fmt"

func main() {
    name := "Alice"
    age := 30
    fmt.Printf("Name: %s, Age: %s\n", name, age)
}

Requirements¶

• You ran go vet ./... or go vet main.go and captured its output
• You can explain what the bug is in plain English
• You can explain why this compiles successfully despite being wrong
• You fixed the bug so go vet reports no issues and the output is correct

Hints¶

Expected Output / Acceptance Criteria¶

go vet output before fix:

./main.go:8:2: fmt.Printf format %s has arg age of wrong type int

Program output before fix (what go run actually prints):

Name: Alice, Age: %!s(int=30)

After fix, program output:

Name: Alice, Age: 30

Solution¶

package main

import "fmt"

func main() {
    name := "Alice"
    age := 30
    fmt.Printf("Name: %s, Age: %d\n", name, age)
}

Exercise 9: Set Up a Go Module and Add a Dependency [⭐ Challenge] [5 pts]¶

Context¶

Real Go programs use external packages. This exercise walks through the full modern Go module workflow: initializing a module, adding an external dependency, importing it, and understanding what the resulting go.mod and go.sum files contain. This is how every non-trivial Go project starts.

Task¶

Create a new directory, initialize a Go module, write a program that uses the golang.org/x/text/cases package to convert a string to title case, and run it successfully. Then examine go.mod and go.sum to understand what was recorded.

Requirements¶

• A new directory is created and go mod init is run inside it
• go get golang.org/x/text is run to add the dependency
• go.mod contains a require directive for golang.org/x/text
• go.sum exists and contains cryptographic hashes
• The program uses cases.Title from golang.org/x/text/cases and language.English from golang.org/x/text/language
• The program converts "hello, world" to "Hello, World" and prints it
• go mod tidy runs without errors after the program is complete

Hints¶

caser := cases.Title(language.English)
result := caser.String("hello, world")

Expected Output / Acceptance Criteria¶

Hello, World

And go.mod should look something like:

module example.com/mymodule

go 1.21

require golang.org/x/text v0.14.0

Solution¶

mkdir mymodule
cd mymodule
go mod init example.com/mymodule
go get golang.org/x/text

package main

import (
    "fmt"

    "golang.org/x/text/cases"
    "golang.org/x/text/language"
)

func main() {
    caser := cases.Title(language.English)
    result := caser.String("hello, world")
    fmt.Println(result)
}

go run .
go mod tidy

Scoring Log¶

Record your performance honestly. Include the date and whether you used hints.

Passing threshold: 13/20 (65%). Aim for 17/20 (85%) before taking the test.