Go compilation and execution flow - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple Go program with init and main

What is the output of this Go program when compiled and run?

Go

package main
import "fmt"

func init() {
    fmt.Println("Init function called")
}

func main() {
    fmt.Println("Main function called")
}

A Init function called\nMain function called

B Main function called\nInit function called

C Init function called

D Main function called

💡 Hint

Remember that init functions run before main in Go.

In Go, the init function runs automatically before main. So the output first prints from init, then from main.

❓ Predict Output

intermediate

Output of Go program with multiple init functions

What is the output of this Go program with two init functions in the same package?

Go

package main
import "fmt"

func init() {
    fmt.Println("First init")
}

func init() {
    fmt.Println("Second init")
}

func main() {
    fmt.Println("Main function")
}

A Main function\nFirst init\nSecond init

B First init\nMain function\nSecond init

C Second init\nFirst init\nMain function

D First init\nSecond init\nMain function

💡 Hint

Multiple init functions run in the order they appear in the source file.

Go runs multiple init functions in the order they are declared in the source file before main.

❓ Predict Output

advanced

Output of Go program with package-level variable initialization

What is the output of this Go program considering package-level variable initialization order?

Go

package main
import "fmt"

var a = initializeA()
var b = initializeB()

func initializeA() int {
    fmt.Println("Initializing A")
    return 1
}

func initializeB() int {
    fmt.Println("Initializing B")
    return 2
}

func main() {
    fmt.Println("a =", a, ", b =", b)
}

A Initializing A\nInitializing B\na = 1 , b = 2

B a = 0 , b = 0

C a = 1 , b = 2\nInitializing A\nInitializing B

D Initializing B\nInitializing A\na = 1 , b = 2

💡 Hint

Package-level variables are initialized in the order they are declared.

Variables a and b are initialized in order. So initializeA runs first, then initializeB, then main prints values.

❓ Predict Output

advanced

Output of Go program with multiple packages and init functions

Given two packages, main and util, what is the output when running the main package?

Go

package util

import "fmt"

func init() {
    fmt.Println("util init")
}

func UtilFunc() {
    fmt.Println("util function")
}

---

package main

import (
    "fmt"
    "util"
)

func init() {
    fmt.Println("main init")
}

func main() {
    fmt.Println("main function")
    util.UtilFunc()
}

A main function\nutil init\nmain init\nutil function

B util init\nmain init\nmain function\nutil function

C main init\nutil init\nmain function\nutil function

D util function\nutil init\nmain init\nmain function

💡 Hint

Package init functions run before main, and dependencies init first.

Go initializes imported packages first, so util's init runs before main's init, then main runs.

🧠 Conceptual

expert

Order of compilation and linking in Go build process

Which of the following correctly describes the order of steps in Go's compilation and execution flow when building and running a program?

A Execution → Linking → Compilation to object files → Type checking → Source code parsing

B Linking → Compilation to object files → Type checking → Source code parsing → Execution

C Source code parsing → Type checking → Compilation to object files → Linking → Execution

D Compilation to object files → Source code parsing → Type checking → Linking → Execution

💡 Hint

Think about how source code is processed step-by-step before running.

Go first parses source code, then checks types, compiles to object files, links them, then runs the program.

Practice

1. What does the go build command do in Go programming?

easy

A. It compiles the code and creates an executable file.

B. It runs the code without compiling.

C. It only checks the code for errors without compiling.

D. It deletes the executable file.

Solution

1. Step 1: Understand the purpose of go build

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

2. Step 2: Differentiate from other commands

   Unlike go run, go build does not run the program immediately but creates a file you can run later.

3. Final Answer:

   It compiles the code and creates an executable file. -> Option A

4. Quick Check:

   go build creates executable [OK]

Hint: Remember: build = compile and save executable [OK]

Common Mistakes:

• Confusing go build with go run
• Thinking go build runs the program immediately
• Believing go build only checks syntax

2. Which of the following is the correct way to compile and run a Go program in one step?

easy

A. go execute main.go

B. go build main.go

C. go run main.go

D. go compile main.go

Solution

1. Step 1: Identify the command that compiles and runs

   go run compiles the code and runs it immediately without creating an executable file.

2. Step 2: Check other options

   go build only compiles; go execute and go compile are not valid Go commands.

3. Final Answer:

   go run main.go -> Option C

4. Quick Check:

   go run compiles and runs [OK]

Hint: Use go run to compile and run instantly [OK]

Common Mistakes:

• Using go build to run directly
• Typing invalid commands like go execute
• Confusing compile-only and run commands

3. What will happen if you run the command go run main.go on a valid Go source file?

medium

A. It compiles the code, creates an executable file, and runs it.

B. It deletes the source file after running.

C. It only checks the code for errors but does not run it.

D. It compiles the code and runs it without creating an executable file.

Solution

1. Step 1: Understand go run behavior

   go run compiles the source code in memory and runs it immediately without saving an executable file.

2. Step 2: Eliminate incorrect options

   It compiles the code, creates an executable file, and runs it. is wrong because no executable file is saved. It only checks the code for errors but does not run it. is wrong because it runs the program. It deletes the source file after running. is incorrect as source files are never deleted.

3. Final Answer:

   It compiles the code and runs it without creating an executable file. -> Option D

4. Quick Check:

   go run compiles & runs, no file saved [OK]

Hint: Run with go run to skip saving executable [OK]

Common Mistakes:

• Assuming go run saves an executable
• Thinking go run only checks syntax
• Believing source files get deleted

4. You run go build on your Go program, but no executable file appears. What is the most likely reason?

medium

A. Go automatically deletes the executable after building.

B. The source file has syntax errors preventing compilation.

C. The executable is created but hidden in a different directory.

D. The go build command only runs the program, not build it.

Solution

1. Step 1: Understand go build behavior on errors

   If the source code has syntax errors, go build will fail and not create an executable file.

2. Step 2: Check other options

   go build does not run the program, executables are created in the current directory by default, and Go does not delete executables automatically.

3. Final Answer:

   The source file has syntax errors preventing compilation. -> Option B

4. Quick Check:

   Syntax errors block build, no executable made [OK]

Hint: Check for syntax errors if no executable appears [OK]

Common Mistakes:

• Expecting go build to run the program
• Looking in wrong directories without checking errors
• Assuming Go deletes executables automatically

5. You want to quickly test a small Go program without creating an executable file. Which command should you use and why?

hard

A. Use go run because it compiles and runs the program without saving an executable.

B. Use go build because it compiles and runs the program immediately.

C. Use go install because it runs the program without compiling.

D. Use go test because it compiles and runs the program.

Solution

1. Step 1: Identify the command for quick testing

   go run compiles and runs the program immediately without creating an executable file, perfect for quick tests.

2. Step 2: Understand why other commands don't fit

   go build creates an executable but does not run it. go install compiles and installs packages, not for quick runs. go test runs tests, not general programs.

3. Final Answer:

   Use go run because it compiles and runs the program without saving an executable. -> Option A

4. Quick Check:

   Quick test = go run [OK]

Hint: Use go run for quick compile-and-run tests [OK]

Common Mistakes:

• Using go build expecting immediate run
• Confusing go install with running code
• Trying go test for normal program execution