if err != nil — Why You'll Miss Ruby's begin/rescue

This is the biggest shock for Ruby developers trying Go.

In Ruby, errors throw Exceptions that get caught by rescue somewhere up the stack. Write the happy path, handle errors in one rescue block.

Go is completely different. No exceptions. Errors are return values.

Ruby vs Go Error Handling

Ruby:

begin
  data = File.read("config.yml")
  config = YAML.parse(data)
  save(config)
rescue => e
  puts "Error: #{e.message}"
end

Go:

data, err := os.ReadFile("config.yml")
if err != nil { return err }
config, err := yaml.Unmarshal(data)
if err != nil { return err }
err = save(config)
if err != nil { return err }

See it? Ruby: 3 lines of happy path + 1 line rescue. Go: 3 lines of actual logic + 6 lines of error checking. if err != nil repeats after every function call.

Why This Design

Go team's philosophy: errors must not be ignored. In exception-based systems, forgetting rescue lets errors propagate silently. In Go, you receive the error and must handle it explicitly. Skip it and the compiler errors: "err declared but not used."

errors.Is, errors.As — Like Ruby's is_a?

Just as Ruby catches specific exceptions with rescue ActiveRecord::RecordNotFound, Go checks error types with errors.Is(err, sql.ErrNoRows) or errors.As(err, &target).

panic/recover — Seriously Don't

Go has panic(). Similar to Ruby's raise. But Go community reserves panic for situations where the program truly cannot continue. HTTP request errors get error returns, not panics.

Completely different culture from Ruby's everyday raise/rescue usage.