Best practices in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go code snippet?

Consider the following Go program that uses channels. What will it print?

Go

package main

import (
	"fmt"
)

func main() {
	ch := make(chan int, 2)
	ch <- 1
	ch <- 2
	close(ch)

	for v := range ch {
		fmt.Print(v)
	}
}

A 12

B 21

C runtime error: send on closed channel

D 12 followed by deadlock

💡 Hint

Remember that closing a channel allows range to receive remaining buffered values.

The channel is buffered with capacity 2. It receives 1 and 2, then closes. The range loop reads all values until the channel is empty, printing "12".

🧠 Conceptual

intermediate

Which is the best practice for error handling in Go?

In Go, what is the recommended way to handle errors returned by functions?

A Return error values and check them explicitly after function calls

B Use panic() for all errors to stop execution immediately

C Ignore errors if they are not critical

D Use exceptions and try-catch blocks like in other languages

💡 Hint

Think about Go's philosophy of explicit error handling.

Go encourages returning error values and checking them explicitly to handle errors gracefully and clearly.

🔧 Debug

advanced

What error does this Go code produce?

Analyze the following Go code snippet. What error will it cause when compiled?

Go

package main

func main() {
	var x int
	if x := 5; x > 3 {
		println(x)
	}
	println(x)
}

A Compilation error: x redeclared in the same block

B Prints 5 then 0

C Prints 0 then 5

D Runtime panic: variable x used before initialization

💡 Hint

Consider variable shadowing and scopes in Go.

The 'x' inside the if statement shadows the outer 'x'. Inside the if block, x is 5 and prints 5. Outside, the original x is 0 and prints 0.

🔧 Debug

advanced

Which option causes a runtime panic in Go?

Which of the following Go code snippets will cause a runtime panic when executed?

Go

package main

func main() {
	var x int
	if x := 5; x > 3 {
		println(x)
	}
	println(x)
}

A

m := map[string]int{"a": 1}
 m["b"] = 2

B

var m map[string]int = map[string]int{"a": 1, "b": 2}
 m["c"] = 3

C

m := make(map[string]int)
 m["a"] = 1

D

var m map[string]int
 m["a"] = 1

💡 Hint

Remember that maps must be initialized with make() or a map literal before you can assign to them.

Option D declares a nil map (var m map[string]int) and tries to assign m["a"] = 1, which causes a runtime panic: 'assignment to entry in nil map'. Options B, C, and D all properly initialize the map before assignment.

🚀 Application

expert

How many goroutines are running after this Go program executes?

Consider this Go program. How many goroutines are alive after the main function finishes?

Go

package main

import (
	"fmt"
	"time"
)

func worker(done chan bool) {
	time.Sleep(100 * time.Millisecond)
	done <- true
}

func main() {
	done := make(chan bool)
	for i := 0; i < 3; i++ {
		go worker(done)
	}
	for i := 0; i < 3; i++ {
		<-done
	}
	fmt.Println("All workers done")
}

A 4 goroutines

B 3 goroutines

C 0 goroutines

D 1 goroutine

💡 Hint

Think about when goroutines finish and the main function exits.

The main function waits for all 3 worker goroutines to send done signals before printing. After that, all worker goroutines have finished, so no goroutines remain alive.