Quiz-internals | RubyDev

Quiz: Ruby Internals & Object Model

Test your understanding of Ruby's object model, method lookup chain, eigenclasses, garbage collection, and open classes. This comprehensive quiz covers advanced Ruby internals concepts.

Quiz Instructions

How to Take This Quiz

Read each question carefully - questions cover object model, method lookup, garbage collection, and open classes
Think about Ruby's internals - consider how Ruby manages objects, memory, and method resolution
Use the interactive code runner - test your understanding with real Ruby code
Take your time - these are advanced concepts that require deep understanding

1
Question 1: Everything is an Object

In Ruby, "everything is an object." Which of the following statements about Ruby's object model are true? (Select all that apply)

Numbers like 42 are objects with methods like even? Classes themselves are objects and instances of the Class class nil, true, and false are objects with their own classes Methods are not objects in Ruby - they're just behavior attached to objects

💡 Hint: Try using .class, .methods, and .method(:name) to explore Ruby's object model.

2
Question 2: Method Lookup Chain

Given this Ruby code, what will be the method lookup chain when calling obj.greet?

module
Greeting
  def
greet
    "Hello from module"
  end
end

class
Parent
  include
Greeting
  def
greet
    "Hello from parent"
  end
end

class
Child
 < Parent
end

obj = Child.new

Child → Parent → Greeting → Object → BasicObject Child → Greeting → Parent → Object → BasicObject Child → Parent → Object → Greeting → BasicObject Child → eigenclass → Parent → Greeting → Object → BasicObject

💡 Hint: Use Child.ancestors to see the actual method lookup chain. Remember that included modules are inserted above the class that includes them.

3
Question 3: Eigenclasses & Singleton Methods

What happens when you define a singleton method on a specific object instance?

str1 = "hello"
str2 = "world"

def
 str1.shout

self.upcase + "!!!"

end

Ruby creates an eigenclass (singleton class) for str1 and adds the method there The method is added to the String class, so all strings now have a shout method Ruby raises an error because you can't define methods on specific object instances The method is stored directly in the object's instance variables

💡 Hint: Test with str1.singleton_class and str2.respond_to?(:shout) to understand singleton methods.

4
Question 4: Garbage Collection

Which statements about Ruby's mark-and-sweep garbage collection are correct? (Select all that apply)

The mark phase identifies all reachable objects by following references from root objects Circular references prevent objects from being garbage collected Ruby uses generational garbage collection - young objects are collected more frequently You can use GC.stat to monitor garbage collection performance

💡 Hint: Try creating circular references and see if they get collected. Use GC.stat to explore GC metrics.

5
Question 5: Safe Monkey Patching

What is the safest way to add a method to an existing class without causing conflicts?

Check if method exists first:
def new_method; end unless String.method_defined?(:new_method)

Always override existing methods:
class String; def new_method; end; end

Use refinements for scoped monkey patching:
module MyRef; refine String do; def new_method; end; end; end

Create a new class instead:
class MyString < String; def new_method; end; end

💡 Hint: Consider safety, scope, and potential conflicts with other code. Multiple approaches can be "safe" depending on the context.

Test Your Knowledge - Interactive Practice

Practice Time: Use the code runner below to experiment with Ruby internals concepts. Try the examples from the quiz questions and explore deeper!

Interactive Code Runner

Ruby Code Editor

# Ruby Internals Exploration
# Try these examples and create your own!

# 1. Everything is an Object
puts "=== Everything is an Object ==="
puts 42.class
puts true.class
puts nil.class
puts String.class
puts Class.class

# 2. Method Lookup Chain
module Greeting
  def greet
    "Hello from module"
  end
end

class Parent
  include Greeting
  def greet
    "Hello from parent"
  end
end

class Child < Parent
end

puts "\n=== Method Lookup ==="
puts Child.ancestors
obj = Child.new
puts obj.greet

# 3. Singleton Methods
str1 = "hello"
str2 = "world"

def str1.shout
  self.upcase + "!!!"
end

puts "\n=== Singleton Methods ==="
puts str1.shout
puts str2.respond_to?(:shout)
puts str1.singleton_class

# 4. Garbage Collection
puts "\n=== Garbage Collection ==="
before = GC.stat[:heap_live_slots]
puts "Live objects before: #{before}"

# Create temporary objects
1000.times { |i| "temp string #{i}" }

GC.start
after = GC.stat[:heap_live_slots]
puts "Live objects after GC: #{after}"

# 5. Safe Monkey Patching
class String
  def palindrome?
    self == self.reverse
  end unless String.method_defined?(:palindrome?)
end

puts "\n=== Monkey Patching ==="
puts "racecar".palindrome?
puts "hello".palindrome?

# Add your own experiments below!

Output will appear here when you run the code...

Check Your Answers

Question 1 Answer:

Correct answers: Numbers like 42 are objects with methods ✓, Classes are objects and instances of Class ✓, nil/true/false are objects with their own classes ✓. Incorrect: Methods ARE objects too - you can get them with .method(:name).

Question 2 Answer:

Correct: Child → Parent → Greeting → Object → BasicObject. When a module is included, it's inserted into the lookup chain above the class that includes it.

Question 3 Answer:

Correct: Ruby creates an eigenclass (singleton class) for str1 and adds the method there. This allows individual objects to have unique methods without affecting other instances.

Question 4 Answer:

Correct answers: Mark phase identifies reachable objects ✓, Ruby uses generational GC ✓, GC.stat monitors performance ✓. Incorrect: Circular references do NOT prevent collection - Ruby's GC handles them correctly.

Question 5 Answer:

Multiple correct approaches: Checking if method exists first is safe for global patches. Refinements provide scoped monkey patching. Creating new classes avoids monkey patching entirely. The best choice depends on your specific needs and context.

Quiz Complete - Key Takeaways

Ruby Internals Mastery

Everything is truly an object: Numbers, classes, methods, and even nil have methods and belong to classes
Method lookup follows a predictable chain: eigenclass → class → included modules → superclass → Object → BasicObject
Eigenclasses enable object-specific behavior: Each object can have unique methods via singleton classes
Garbage collection is sophisticated: Mark-and-sweep with generational collection handles circular references correctly
Open classes require responsibility: Check for existing methods, use namespaces, or consider refinements for safety

Ruby Language

Rails Framework

Production Ready