Go toolchain overview - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go program using 'go run'?

Consider this Go program saved as main.go. What will be printed when you run go run main.go?

Go

package main
import "fmt"
func main() {
    fmt.Println("Hello, Go toolchain!")
}

A Hello, Go toolchain!

B main.go:1:1: expected 'package', found 'import'

C Error: cannot find package fmt

D No output

💡 Hint

Think about what go run does with a simple program that prints text.

The go run command compiles and runs the Go program. Since the program prints "Hello, Go toolchain!", that is the output.

🧠 Conceptual

intermediate

Which Go tool command compiles packages and dependencies?

Which go tool command compiles the packages and their dependencies but does not run the program?

A go test

B go install

C go build

D go run

💡 Hint

Think about the command that creates an executable without running it.

go build compiles the packages and dependencies and produces an executable file but does not run it.

❓ Predict Output

advanced

What error does this Go code produce when run with 'go run'?

What error message will this Go program produce when executed with go run?

Go

package main
func main() {
    var x int = "string"
}

A undefined: x

B no error, program runs successfully

C missing return statement

D cannot use "string" (type string) as type int in assignment

💡 Hint

Look at the variable type and the assigned value types.

The program tries to assign a string value to an int variable, which causes a type mismatch error.

🧠 Conceptual

advanced

What does 'go install' do differently than 'go build'?

Choose the correct statement about the difference between go install and go build.

A <code>go install</code> runs tests, <code>go build</code> does not.

B <code>go install</code> compiles and places the executable in the Go bin directory, <code>go build</code> only compiles locally.

C <code>go install</code> deletes source files after compiling, <code>go build</code> keeps them.

D <code>go install</code> only downloads dependencies, <code>go build</code> compiles code.

💡 Hint

Think about where the executable ends up after each command.

go install compiles the package and places the executable in the Go workspace bin directory, making it available globally. go build compiles locally without installing.

❓ Predict Output

expert

What is the output of this Go program using 'go run' with modules?

This Go program uses a module and imports fmt. What will be the output when running go run main.go inside a module-enabled directory?

Go

package main
import "fmt"
func main() {
    fmt.Println("Module enabled run")
}

A Module enabled run

B cannot find module for path fmt

C go: no Go files in .

D panic: runtime error

💡 Hint

Modules do not affect standard library imports like fmt.

The program prints the string because fmt is part of the standard library and modules do not block this import.

Practice

1. Which Go toolchain command is used to create an executable file from your Go source code?

easy

A. go build

B. go run

C. go fmt

D. go test

Solution

1. Step 1: Understand the purpose of go build

   The go build command compiles your Go source code into an executable file.

2. Step 2: Compare with other commands

   go run runs code without creating an executable, go fmt formats code, and go test runs tests.

3. Final Answer:

   go build -> Option A

4. Quick Check:

   Executable creation = go build [OK]

Hint: Build creates executables; run just executes code [OK]

Common Mistakes:

• Confusing go run with go build
• Thinking go fmt builds code
• Using go test to build executables

2. Which of the following is the correct syntax to run a Go program file named main.go using the Go toolchain?

easy

A. go build main.go

B. go test main.go

C. go run main.go

D. go fmt main.go

Solution

1. Step 1: Identify the command to run code directly

   go run compiles and runs the Go program immediately without creating an executable.

2. Step 2: Check other commands

   go build compiles but does not run, go fmt formats code, and go test runs tests, so they are not for running directly.

3. Final Answer:

   go run main.go -> Option C

4. Quick Check:

   Run code immediately = go run [OK]

Hint: Use go run to execute files quickly [OK]

Common Mistakes:

• Using go build to run code directly
• Trying to run tests with go run
• Confusing go fmt as a run command

3. What will be the output when you run the following commands in order?

go fmt main.go
 go build main.go
 ./main

Assuming main.go contains a valid Go program that prints "Hello, Go!".

medium

A. Syntax error

B. Hello, Go!

C. No output

D. Compilation error

Solution

1. Step 1: Understand each command's effect

   go fmt main.go formats the code but does not affect output. go build main.go compiles the code into an executable named main. ./main runs the executable.

2. Step 2: Predict the program output

   Since main.go prints "Hello, Go!", running ./main will output exactly that.

3. Final Answer:

   Hello, Go! -> Option B

4. Quick Check:

   Build then run prints program output [OK]

Hint: Build creates executable; run it to see output [OK]

Common Mistakes:

• Expecting go fmt to produce output
• Confusing build errors with formatting
• Not running the executable after build

4. You run go test on your Go package, but it reports no tests found. What is the most likely reason?

medium

A. Your test functions are not named starting with Test

B. You forgot to run go build first

C. You need to run go fmt before testing

D. Your Go version is outdated

Solution

1. Step 1: Understand Go test naming conventions

   Go requires test functions to start with Test (e.g., TestFunction) to detect and run them.

2. Step 2: Check other options

   go build is not required before testing, go fmt only formats code, and outdated Go versions usually cause errors, not silent no tests.

3. Final Answer:

   Test functions not named starting with Test -> Option A

4. Quick Check:

   Test function names start with 'Test' [OK]

Hint: Test functions must start with 'Test' to run [OK]

Common Mistakes:

• Assuming build is needed before test
• Thinking formatting affects test detection
• Blaming Go version without checking test names

5. You want to automate your Go project workflow to format code, run tests, and then build the executable only if tests pass. Which sequence of commands correctly achieves this?

hard

A. go build && go test && go fmt

B. go fmt && go build && go test

C. go test && go fmt && go build

D. go fmt ./... && go test ./... && go build

Solution

1. Step 1: Understand command order for workflow

   First, go fmt ./... formats all code files recursively. Then, go test ./... runs all tests. Using && ensures the next command runs only if the previous succeeds.

2. Step 2: Confirm build runs only after tests pass

   go build runs last, so it only executes if tests pass, ensuring a clean build.

3. Final Answer:

   go fmt ./... && go test ./... && go build -> Option D

4. Quick Check:

   Format, test, then build with && [OK]

Hint: Use && to chain commands; build last after tests pass [OK]

Common Mistakes:

• Building before testing
• Running tests after build
• Not chaining commands to stop on failure