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.