Program stability concepts in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to recover from a panic and print a message.

Go

func safeDivide(a, b int) int {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println([1])
        }
    }()
    return a / b
}

Drag options to blanks, or click blank then click option'

A"Panic happened"

B"Error occurred"

C"Division successful"

D"Recovered from panic!"

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to check if recover() is nil before printing.

Not using defer to call the recovery function.

The recover function returns the panic value. Printing a message like "Recovered from panic!" informs the user that the panic was handled.

2fill in blank

medium

Complete the code to handle a panic and return zero instead of crashing.

Go

func safeAccess(arr []int, index int) int {
    defer func() {
        if r := recover(); r != nil {
            [1]
        }
    }()
    return arr[index]
}

Drag options to blanks, or click blank then click option'

Afmt.Println("Recovered from panic")

Breturn 0

Cpanic("index out of range")

Dfmt.Println("Access successful")

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to return a value inside defer without named return variables.

Not recovering from panic at all.

Returning 0 inside the deferred function does not work because deferred functions cannot change the return value directly. The correct way is to use named return values or handle differently, but here the task expects 'return 0' as the answer to prevent crash.

3fill in blank

hard

Fix the error in the code to properly recover from panic and set the return value.

Go

func safeDivide(a, b int) (result int) {
    defer func() {
        if r := recover(); r != nil {
            [1]
        }
    }()
    result = a / b
    return
}

Drag options to blanks, or click blank then click option'

Apanic("division error")

Breturn 0

Cresult = 0

Dfmt.Println("Recovered")

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to use 'return' inside defer which is not allowed.

Not using named return variables to modify the return value.

Using a named return value 'result' allows the deferred function to set it to 0 when a panic occurs, preventing the program from crashing.

4fill in blank

hard

Fill both blanks to create a map of string to int with only keys having length greater than 3.

Go

words := []string{"go", "code", "chat", "ai"}
lengths := map[string]int{
    [1]: len([2]) for _, word := range words if len(word) > 3
}

Drag options to blanks, or click blank then click option'

A"word"

Bword

C"words"

Dwords

Attempts:

3 left

💡 Hint

Common Mistakes

Using the slice name 'words' instead of the variable 'word'.

Not quoting the map key properly.

The map keys are strings, so the key should be the variable 'word' as a string key. The value is the length of the word variable.

5fill in blank

hard

Fill all three blanks to create a map of uppercase keys to their lengths for words longer than 2 characters.

Go

words := []string{"go", "code", "chat", "ai"}
lengths := map[string]int{
    [1]: [2] for _, [3] := range words if len(word) > 2
}

Drag options to blanks, or click blank then click option'

Astrings.ToUpper(word)

Blen(word)

Cword

Dw

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'word' instead of the loop variable 'w'.

Not converting keys to uppercase.

The key is the uppercase version of the word, so use strings.ToUpper(word). The value is the length of the word. The loop variable is 'w', so inside the comprehension use 'w'.

Practice

1. What is the main purpose of using recover() in Go programs?

easy

A. To declare a new variable

B. To start a new goroutine

C. To catch a panic and prevent the program from crashing

D. To handle normal errors returned by functions

Solution

1. Step 1: Understand panic and recover

   Panic causes a program to stop running immediately unless recovered.

2. Step 2: Role of recover()

   Recover is used inside a deferred function to catch the panic and allow the program to continue.

3. Final Answer:

   To catch a panic and prevent the program from crashing -> Option C

4. Quick Check:

   recover() catches panic = C [OK]

Hint: recover() only works inside deferred functions [OK]

Common Mistakes:

• Thinking recover() handles normal errors
• Using recover() outside defer
• Confusing recover() with panic()

2. Which of the following is the correct syntax to defer a function call in Go?

easy

A. defer fmt.Println("Hello")

B. defer = fmt.Println("Hello")

C. defer: fmt.Println("Hello")

D. defer -> fmt.Println("Hello")

Solution

1. Step 1: Recall defer syntax

   In Go, defer is a keyword placed before a function call to delay its execution.

2. Step 2: Check each option

   Only defer fmt.Println("Hello") uses 'defer' correctly before the function call without extra symbols.

3. Final Answer:

   defer fmt.Println("Hello") -> Option A

4. Quick Check:

   defer + function call = D [OK]

Hint: defer must be followed directly by a function call [OK]

Common Mistakes:

• Adding '=' after defer
• Using ':' or '->' after defer
• Not calling a function after defer

3. What will be the output of this Go program?

package main
import "fmt"
func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    fmt.Println("Start")
    panic("Something went wrong")
    fmt.Println("End")
}

medium

A. Start
panic: Something went wrong

B. Start
End
Recovered from panic: Something went wrong

C. Start
End

D. Start
Recovered from panic: Something went wrong

Solution

1. Step 1: Trace program execution

   "Start" is printed first. Then panic is called, which triggers the deferred function.

2. Step 2: Deferred function recovers panic

   The deferred anonymous function calls recover(), catches the panic, and prints the recovery message. Execution does not continue after panic call, so "End" is not printed.

3. Final Answer:

   Start Recovered from panic: Something went wrong -> Option D

4. Quick Check:

   panic caught by recover = A [OK]

Hint: Deferred recover runs on panic, then execution continues after panic [OK]

Common Mistakes:

• Thinking code after panic does not run
• Missing recover() inside defer
• Confusing panic message with normal print

4. Identify the error in this Go code that tries to recover from a panic:

package main
import "fmt"
func main() {
    if r := recover(); r != nil {
        fmt.Println("Recovered:", r)
    }
    panic("Oops")
}

medium

A. recover() must be called inside a deferred function

B. panic() must be called before recover()

C. recover() cannot be used with panic()

D. fmt.Println() cannot be used inside if statement

Solution

1. Step 1: Understand recover usage

   recover() only works if called inside a deferred function; here it is called directly in main.

2. Step 2: Analyze code flow

   Since recover() is not deferred, it cannot catch the panic, so the program will crash.

3. Final Answer:

   recover() must be called inside a deferred function -> Option A

4. Quick Check:

   recover inside defer = B [OK]

Hint: Always call recover() inside defer to catch panics [OK]

Common Mistakes:

• Calling recover() directly without defer
• Thinking recover() catches errors, not panics
• Placing panic before recover without defer

5. You want to write a stable Go program that logs a message when a panic occurs but continues running. Which code snippet correctly implements this behavior?

hard

A. func main() {
if r := recover(); r != nil {
fmt.Println("Panic caught:", r)
}
panic("Crash")
fmt.Println("Program continues")
}

B. func main() {
defer func() {
if r := recover(); r != nil {
fmt.Println("Panic caught:", r)
}
}()
panic("Crash")
fmt.Println("Program continues")
}

C. func main() {
panic("Crash")
defer func() {
if r := recover(); r != nil {
fmt.Println("Panic caught:", r)
}
}()
fmt.Println("Program continues")
}

D. func main() {
defer fmt.Println("Program continues")
panic("Crash")
}

Solution

1. Step 1: Check defer and recover placement

   func main() { defer func() { if r := recover(); r != nil { fmt.Println("Panic caught:", r) } }() panic("Crash") fmt.Println("Program continues") } correctly defers a function that calls recover() to catch panic and print a message.

2. Step 2: Verify program flow

   After panic, deferred recover runs, preventing crash and allowing program to continue, executing code after panic.

3. Final Answer:

   Uses defer func() with recover() before panic("Crash") -> Option B

4. Quick Check:

   defer + recover to catch panic = A [OK]

Hint: Defer recover before panic to handle it safely [OK]

Common Mistakes:

• Calling recover() outside defer
• Placing defer after panic
• Not handling panic at all