Immutable data with freeze in Ruby - Step-by-Step Execution

Concept Flow - Immutable data with freeze

Create object

↓

Call freeze on object

↓

Object becomes immutable

↓

Attempt to modify object?

Yes→Error raised

No↓

Use object safely as immutable

This flow shows how freezing an object in Ruby makes it immutable, preventing any changes and raising errors if modification is attempted.

Execution Sample

Ruby

arr = [1, 2, 3]
arr.freeze
arr << 4

This code creates an array, freezes it to make it immutable, then tries to add an element, which causes an error.

Execution Table

Step	Action	Object State	Result/Output
1	Create array arr = [1, 2, 3]	[1, 2, 3] (mutable)	Array created
2	Call arr.freeze	[1, 2, 3] (frozen)	Array is now immutable
3	Attempt arr << 4	[1, 2, 3] (frozen)	FrozenError: can't modify frozen Array

💡 Execution stops because modifying a frozen object raises a FrozenError

Variable Tracker

Variable	Start	After freeze	After modification attempt
arr	[1, 2, 3] (mutable)	[1, 2, 3] (frozen)	[1, 2, 3] (frozen, unchanged)

Key Moments - 2 Insights

Why does arr << 4 cause an error after freeze?

Because after freeze (see step 2 in execution_table), the array becomes immutable and any modification like << raises a FrozenError.

Does freeze change the contents of the object?

No, freeze only prevents changes; the contents remain the same as shown in variable_tracker where arr stays [1, 2, 3].

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of arr after step 2?

A Mutable array [1, 2, 3]

B Frozen array [1, 2, 3]

C Empty array []

D Array with 4 elements

💡 Hint

Check the 'Object State' column at step 2 in execution_table

At which step does the program raise an error?

A Step 3

B Step 2

C Step 1

D No error

💡 Hint

Look at the 'Result/Output' column in execution_table for error messages

If we remove arr.freeze, what would happen at step 3?

A RuntimeError raised

B Array remains unchanged

C 4 is added to the array

D Program crashes immediately

💡 Hint

Consider what freeze does by looking at variable_tracker and execution_table

Concept Snapshot

Ruby's freeze method makes an object immutable.
Once frozen, any attempt to modify it raises a FrozenError.
Freeze does not change the object's contents.
Use freeze to protect data from accidental changes.

Full Transcript

This example shows how to make data immutable in Ruby using freeze. First, an array is created with three numbers. Then, freeze is called on the array, which prevents any changes. When the code tries to add a new element to the frozen array, Ruby raises a FrozenError because the array is now immutable. The variable tracker shows that the array contents stay the same before and after freezing. This helps avoid bugs by protecting data from accidental modification.