Raise for throwing errors in Ruby - Step-by-Step Execution

Concept Flow - Raise for throwing errors

Start

↓

Code runs

↓

Error condition?

No→Continue normal flow

Yes↓

Raise error

↓

Error thrown

↓

Catch or terminate

The program runs code, checks for an error condition, raises an error if needed, then either catches it or stops.

Execution Sample

Ruby

def check_age(age)
  raise "Age must be positive" if age <= 0
  "Age is #{age}"
end

puts check_age(5)
puts check_age(-1)

This code raises an error if age is not positive, otherwise returns a message.

Execution Table

Step	Action	Condition	Result	Output/Error
1	Call check_age(5)	age <= 0? (5 <= 0)	False	"Age is 5"
2	Return from check_age			"Age is 5" printed
3	Call check_age(-1)	age <= 0? (-1 <= 0)	True	Raise error with message "Age must be positive"
4	Error thrown			Program stops with RuntimeError: Age must be positive

💡 Error raised at step 3 because age is -1, which is not positive

Variable Tracker

Variable	Start	After call 1	After call 2	Final
age	undefined	5	-1	-1

Key Moments - 2 Insights

Why does the program stop after the second call to check_age?

Because at step 3 in the execution table, the condition age <= 0 is true, so raise throws an error that stops the program.

What happens if the condition for raise is false?

As shown in step 1, if the condition is false, the program continues normally and returns the string without error.

Visual Quiz - 3 Questions

Look at the execution table, what is the output after the first call to check_age?

A nil

B RuntimeError

C "Age is 5"

D "Age must be positive"

💡 Hint

Check step 2 in the execution table where the output is printed.

At which step does the program raise an error?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Result' column in the execution table for when raise is called.

If we change age to 10 in the second call, what happens?

A Program prints "Age is 10" and continues

B Error is raised

C Program stops immediately

D Nothing is printed

💡 Hint

Refer to the variable_tracker and execution_table for when age is positive.

Concept Snapshot

Use raise to throw an error in Ruby.
Syntax: raise "error message".
If condition is true, raise stops execution and shows error.
If false, code continues normally.
Useful to catch invalid inputs or unexpected states.

Full Transcript

This example shows how Ruby's raise keyword works to throw errors. The program calls a function check_age with a number. If the number is less than or equal to zero, raise triggers an error with a message. Otherwise, it returns a string showing the age. The execution table traces each step: first call with 5 passes and prints a message. Second call with -1 triggers raise, stopping the program with an error. The variable tracker shows how the age variable changes with each call. Key moments clarify why the program stops and what happens when the condition is false. The quiz tests understanding of when errors occur and outputs appear. The snapshot summarizes how to use raise simply and effectively.