Program stability concepts in Go - Step-by-Step Execution

Concept Flow - Program stability concepts

Start Program

↓

Initialize Variables

↓

Run Main Logic

↓

Check for Errors

↓

Handle Error

↓

Recover or Exit

↓

End Program

This flow shows how a Go program runs, checks for errors, and handles them to keep the program stable.

Execution Sample

Go

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")
}

This Go program uses defer and recover to catch a panic and keep the program stable.

Execution Table

Step	Action	Evaluation	Result	Output
1	Start main function	No error	Program starts
2	Set defer function for recovery	Defer set	Recovery ready
3	Print "Start"	No error	Printed	Start
4	Call panic("Something went wrong")	Panic triggered	Program panics
5	Defer function runs due to panic	Recover called	Panic caught	Recovered from panic: Something went wrong
6	Print "End"	No error	Printed
7	End main function	Program ends	Normal exit

💡 Program ends normally after recovering from panic, preventing crash.

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
r (recover)	nil	nil (panic active)	"Something went wrong" (panic caught)	"Something went wrong"

Key Moments - 3 Insights

Why does the program not crash after panic is called?

Because the deferred function uses recover() to catch the panic, as shown in step 5 of the execution_table, allowing the program to continue.

What happens if recover() is not called inside defer?

The panic would not be caught, and the program would crash immediately after step 4, as no recovery is done.

Why is defer used before panic is called?

Defer sets up the recovery function to run when panic happens, ensuring the program can catch the panic and stay stable.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of variable r after step 5?

A panic active

B nil

C "Something went wrong"

D undefined

💡 Hint

Check variable_tracker column 'After Step 5' for r's value.

At which step does the program catch the panic and prevent crashing?

A Step 5

B Step 4

C Step 3

D Step 6

💡 Hint

Look at execution_table row where recover() is called.

If the defer function was removed, what would happen at step 4?

A Program would recover automatically

B Program would crash and stop

C Program would ignore panic

D Program would print "Recovered from panic"

💡 Hint

Refer to key_moments about what happens without recover.

Concept Snapshot

Go programs can panic on errors.
Use defer with recover() to catch panics.
This prevents crashes and keeps programs stable.
Defer runs after panic triggers.
Recover returns panic info and resumes execution.

Full Transcript

This visual trace shows a Go program starting, setting a deferred recovery function, printing a start message, then panicking. The panic triggers the deferred function, which calls recover to catch the panic and print a recovery message. This prevents the program from crashing and allows it to end normally. Variables like r hold the panic info during recovery. Key points include why defer and recover are needed to keep the program stable and what happens if they are missing.

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