String freezing for immutability in Ruby - Step-by-Step Execution

Concept Flow - String freezing for immutability

Create String object

↓

Freeze String with .freeze

↓

Attempt to modify String

↓

Error raised: can't modify frozen String

↓

String remains unchanged

This flow shows creating a string, freezing it to make it immutable, and what happens when you try to change it.

Execution Sample

Ruby

str = "hello"
str.freeze
str << " world"

Creates a string, freezes it, then tries to add more text, which causes an error.

Execution Table

Step	Action	String Value	Frozen?	Result/Output
1	Create string str = "hello"	"hello"	false	String created, not frozen
2	Call str.freeze	"hello"	true	String is now frozen (immutable)
3	Attempt str << " world"	"hello"	true	Error: can't modify frozen String

💡 Modification attempt on frozen string raises error, stopping execution

Variable Tracker

Variable	Start	After freeze	After modification attempt
str	"hello"	"hello" (frozen)	"hello" (frozen, unchanged)

Key Moments - 2 Insights

Why does str << " world" cause an error after freezing?

Because after step 2 in the execution_table, str is frozen and cannot be changed. Trying to add text raises an error.

Does freezing the string change its content immediately?

No, freezing only prevents future changes. The string content stays the same as shown in step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of str after step 2?

A "hello" (frozen)

B "hello world"

C nil

D "hello" (not frozen)

💡 Hint

Check the 'String Value' and 'Frozen?' columns at step 2 in execution_table

At which step does the program raise an error?

A Step 2

B Step 3

C Step 1

D No error

💡 Hint

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

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

A Error still occurs

B String becomes nil

C String changes to "hello world"

D Program crashes before step 3

💡 Hint

Refer to variable_tracker and understand freezing prevents modification

Concept Snapshot

str = "text" creates a string
str.freeze makes it immutable
Trying to change frozen string causes error
Freezing does not change content
Use freeze to protect strings from accidental changes

Full Transcript

This example shows how to make a string unchangeable in Ruby using freeze. First, a string str is created with value "hello". Then str.freeze is called, which marks the string as frozen. After freezing, any attempt to modify str, like adding more text with <<, causes an error. The string content stays the same after freezing, but it cannot be changed anymore. This helps prevent bugs from accidental string changes.

Practice

1. What does freezing a string in Ruby do?
str = "hello".freeze

easy

A. Converts the string to uppercase.

B. Deletes the string from memory.

C. Makes the string unchangeable (immutable).

D. Allows the string to be modified faster.

Solution

1. Step 1: Understand the freeze method

   The freeze method in Ruby makes an object immutable, meaning it cannot be changed after freezing.

2. Step 2: Apply to strings

   When applied to a string, it prevents any further modifications to that string's content.

3. Final Answer:

   Makes the string unchangeable (immutable). -> Option C

4. Quick Check:

   freeze means immutable = A [OK]

Hint: Freeze means no changes allowed to the string [OK]

Common Mistakes:

• Thinking freeze deletes the string
• Assuming freeze changes string content
• Believing freeze speeds up modification

2. Which of the following is the correct way to freeze a string in Ruby?

easy

A. str.freeze = "hello"

B. str = "hello".freeze

C. freeze str = "hello"

D. str = freeze("hello")

Solution

1. Step 1: Review Ruby freeze syntax

   The correct syntax to freeze a string is to call .freeze on the string object, like "hello".freeze.

2. Step 2: Check each option

   str = "hello".freeze correctly calls .freeze on the string literal. Options B, C, and D use invalid syntax or incorrect method calls.

3. Final Answer:

   str = "hello".freeze -> Option B

4. Quick Check:

   Call .freeze on string = A [OK]

Hint: Use .freeze after the string literal [OK]

Common Mistakes:

• Trying to assign freeze as a variable
• Using freeze as a standalone keyword
• Calling freeze as a function with parentheses

3. What will happen when the following Ruby code runs?

str = "hello".freeze
str << " world"

medium

A. The string becomes "hello world".

B. The string remains "hello" silently.

C. The string changes to " world".

D. A runtime error occurs: can't modify frozen String.

Solution

1. Step 1: Understand string freezing effect

   Freezing the string "hello" makes it immutable, so any modification attempt will raise an error.

2. Step 2: Analyze the << operation

   The << operator tries to append " world" to the frozen string, which is not allowed and causes a runtime error.

3. Final Answer:

   A runtime error occurs: can't modify frozen String. -> Option D

4. Quick Check:

   Modifying frozen string = error C [OK]

Hint: Appending to frozen string causes error [OK]

Common Mistakes:

• Assuming string changes silently
• Thinking string resets to new value
• Believing no error occurs

4. Identify the error in this Ruby code:

name = "Alice"
name.freeze
name.upcase!

medium

A. Error because upcase! tries to modify a frozen string.

B. No error; the code runs fine.

C. Error because freeze is called incorrectly.

D. Error because name is not a string.

Solution

1. Step 1: Check freeze usage

   The freeze method is correctly called on the string name, making it immutable.

2. Step 2: Understand upcase! effect

   The upcase! method tries to change the string in place, which is not allowed on a frozen string, causing a runtime error.

3. Final Answer:

   Error because upcase! tries to modify a frozen string. -> Option A

4. Quick Check:

   Modifying frozen string with upcase! = error B [OK]

Hint: In-place methods fail on frozen strings [OK]

Common Mistakes:

• Thinking freeze is called incorrectly
• Assuming no error on upcase!
• Confusing variable type

5. You want to store a constant greeting message that should never change in your Ruby program. Which approach is best?

GREETING = "Welcome!".freeze

Why is freezing important here?

hard

A. It prevents accidental changes to the greeting, ensuring data integrity.

B. It makes the greeting print faster.

C. It allows the greeting to be changed later if needed.

D. It compresses the string to save memory.

Solution

1. Step 1: Understand constant usage

   Constants like GREETING should not change during program execution to avoid bugs.

2. Step 2: Role of freeze on constants

   Freezing the string ensures it cannot be modified accidentally, protecting the constant's value.

3. Final Answer:

   It prevents accidental changes to the greeting, ensuring data integrity. -> Option A

4. Quick Check:

   Freeze constant for safety = D [OK]

Hint: Freeze constants to keep them safe from changes [OK]

Common Mistakes:

• Thinking freeze speeds up printing
• Believing freeze allows changes later
• Assuming freeze compresses data