Fiber for cooperative concurrency in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of simple Fiber switch

What is the output of this Ruby code using Fiber for cooperative concurrency?

Ruby

fiber = Fiber.new do
  puts "Step 1"
  Fiber.yield
  puts "Step 2"
end

fiber.resume
puts "Between resumes"
fiber.resume

A

Between resumes
Step 1
Step 2

B

Step 1
Step 2
Between resumes

C

Step 1
Between resumes

D

Step 1
Between resumes
Step 2

💡 Hint

Remember that Fiber.yield pauses the fiber and returns control to the caller.

The fiber prints "Step 1" then yields control. The main code prints "Between resumes" then resumes the fiber, which prints "Step 2".

🧠 Conceptual

intermediate

Fiber behavior on resume after completion

What happens if you call resume on a Ruby Fiber that has already finished executing?

A It raises a FiberError indicating dead fiber

B It restarts the fiber from the beginning

C It blocks the current thread until the fiber is ready

D It silently does nothing and returns nil

💡 Hint

Think about whether fibers can be restarted once done.

Calling resume on a finished fiber raises a FiberError because the fiber is dead and cannot be resumed.

🔧 Debug

advanced

Identify the error in Fiber usage

What error does this Ruby code produce when run?

Ruby

fiber = Fiber.new do
  Fiber.yield 1
  Fiber.yield 2
end

puts fiber.resume
puts fiber.resume
puts fiber.resume

A FiberError: dead fiber called

B No error, outputs 1 2 nil

C TypeError: wrong argument type

D LocalJumpError: no block given

💡 Hint

Check what happens when resume is called after the fiber finishes all yields.

The third resume call tries to resume a dead fiber, causing FiberError.

🚀 Application

advanced

Using Fiber to alternate execution

Given two fibers that print numbers and letters alternately, what is the output of this code?

Ruby

numbers = Fiber.new do
  (1..3).each do |n|
    puts n
    Fiber.yield
  end
end

letters = Fiber.new do
  ['a', 'b', 'c'].each do |l|
    puts l
    Fiber.yield
  end
end

while numbers.alive? || letters.alive?
  numbers.resume if numbers.alive?
  letters.resume if letters.alive?
end

A

a
b
c
1
2
3

B

1
a
2
b
3
c

C

1
2
3
a
b
c

D

a
1
b
2
c
3

💡 Hint

Fibers yield after printing each item, so they alternate execution.

The numbers fiber prints 1, yields; letters fiber prints 'a', yields; and so on alternating.

🧠 Conceptual

expert

Fiber vs Thread in Ruby concurrency

Which statement best describes the difference between Ruby Fibers and Threads?

A Fibers automatically use multiple CPU cores; Threads require manual synchronization

B Fibers run in parallel on multiple CPU cores; Threads run only one at a time

C Fibers are cooperatively scheduled and run in a single thread; Threads are preemptively scheduled and can run in parallel

D Fibers and Threads are identical in scheduling and execution

💡 Hint

Think about how control switches between fibers and threads.

Fibers switch control only when they yield (cooperative), while threads can be interrupted by the scheduler (preemptive) and run in parallel.

Practice

1. What is the main purpose of using Fiber in Ruby?

easy

A. To pause and resume tasks manually for cooperative multitasking

B. To create multiple threads that run in parallel automatically

C. To speed up code by running it on multiple CPU cores

D. To handle database connections asynchronously

Solution

1. Step 1: Understand Fiber's role

   Fibers allow manual pausing and resuming of code execution, enabling cooperative multitasking.

2. Step 2: Differentiate from threads

   Unlike threads, Fibers do not run in parallel automatically; they require explicit control.

3. Final Answer:

   To pause and resume tasks manually for cooperative multitasking -> Option A

4. Quick Check:

   Fiber = manual pause/resume [OK]

Hint: Fibers pause and resume tasks manually, not parallel threads [OK]

Common Mistakes:

• Confusing Fibers with threads or parallelism
• Thinking Fibers run automatically in background
• Assuming Fibers speed up CPU usage

2. Which of the following is the correct way to create a Fiber in Ruby?

easy

A. fiber = Fiber.start { puts 'Hello' }

B. fiber = Fiber.new { puts 'Hello' }

C. fiber = Fiber.create { puts 'Hello' }

D. fiber = Fiber.run { puts 'Hello' }

Solution

1. Step 1: Recall Fiber creation syntax

   Ruby uses Fiber.new with a block to create a new Fiber.

2. Step 2: Check other options

   Methods like create, start, or run do not exist for Fiber creation.

3. Final Answer:

   fiber = Fiber.new { puts 'Hello' } -> Option B

4. Quick Check:

   Fiber creation = Fiber.new [OK]

Hint: Use Fiber.new with a block to create a Fiber [OK]

Common Mistakes:

• Using non-existent Fiber methods like create or start
• Forgetting to pass a block to Fiber.new
• Confusing Fiber with Thread syntax

3. What will be the output of the following Ruby code?

fiber = Fiber.new do
  puts 'Step 1'
  Fiber.yield
  puts 'Step 2'
end

fiber.resume
puts 'Between'
fiber.resume

medium

A. Step 2
Between
Step 1

B. Step 1
Step 2
Between

C. Between
Step 1
Step 2

D. Step 1
Between
Step 2

Solution

1. Step 1: Trace first resume call

   Calling fiber.resume runs until Fiber.yield, printing 'Step 1'.

2. Step 2: Trace code after first resume

   After yield, control returns to main, printing 'Between'.

3. Step 3: Trace second resume call

   Second fiber.resume resumes after yield, printing 'Step 2'.

4. Final Answer:

   Step 1 Between Step 2 -> Option D

5. Quick Check:

   Fiber.yield pauses, resume continues [OK]

Hint: Fiber.yield pauses; resume continues after yield [OK]

Common Mistakes:

• Assuming all code runs at first resume
• Confusing order of prints around yield
• Thinking yield stops Fiber permanently

4. Identify the error in this Fiber usage:

fiber = Fiber.new do
  puts 'Start'
  Fiber.yield
  puts 'End'
end

fiber.yield
fiber.resume

medium

A. Calling Fiber.yield outside a Fiber block causes an error

B. Fiber.resume must be called before Fiber.yield

C. Fiber.new requires a parameter for yield count

D. Fiber cannot print inside its block

Solution

1. Step 1: Check where Fiber.yield is called

   The code calls fiber.yield outside the Fiber block, which is invalid.

2. Step 2: Understand Fiber.yield usage

   Fiber.yield is a class method to pause current Fiber, not an instance method on Fiber objects.

3. Final Answer:

   Calling Fiber.yield outside a Fiber block causes an error -> Option A

4. Quick Check:

   Fiber.yield only inside Fiber block [OK]

Hint: Fiber.yield is called inside Fiber block only [OK]

Common Mistakes:

• Calling fiber.yield instead of Fiber.yield
• Expecting Fiber.resume before yield call
• Thinking Fiber.new needs parameters for yield

5. Given two Fibers that alternate printing numbers, what is the output of this code?

fiber1 = Fiber.new do
  3.times do |i|
    puts "Fiber1: #{i}"
    Fiber.yield
  end
end

fiber2 = Fiber.new do
  3.times do |i|
    puts "Fiber2: #{i}"
    Fiber.yield
  end
end

while fiber1.alive? || fiber2.alive?
  fiber1.resume if fiber1.alive?
  fiber2.resume if fiber2.alive?
end

hard

A. Fiber2: 0
Fiber1: 0
Fiber2: 1
Fiber1: 1
Fiber2: 2
Fiber1: 2

B. Fiber1: 0
Fiber1: 1
Fiber1: 2
Fiber2: 0
Fiber2: 1
Fiber2: 2

C. Fiber1: 0
Fiber2: 0
Fiber1: 1
Fiber2: 1
Fiber1: 2
Fiber2: 2

D. Fiber1: 0
Fiber2: 0
Fiber2: 1
Fiber1: 1
Fiber1: 2
Fiber2: 2

Solution

1. Step 1: Understand Fiber alternation

   Each Fiber prints a number then yields, pausing itself.

2. Step 2: Trace the while loop

   The loop resumes fiber1 then fiber2 alternately while they are alive.

3. Step 3: Follow output order

   Output alternates: Fiber1:0, Fiber2:0, Fiber1:1, Fiber2:1, Fiber1:2, Fiber2:2.

4. Final Answer:

   Fiber1: 0 Fiber2: 0 Fiber1: 1 Fiber2: 1 Fiber1: 2 Fiber2: 2 -> Option C

5. Quick Check:

   Fibers alternate resume and yield [OK]

Hint: Fibers alternate resume and yield to interleave output [OK]

Common Mistakes:

• Assuming one Fiber runs completely before the other
• Mixing order of Fiber resumes
• Forgetting Fiber.yield pauses execution