Why single inheritance in Ruby - Performance Analysis

Time Complexity: Why single inheritance in Ruby

O(n)

Understanding Time Complexity

We want to understand how Ruby's single inheritance affects the time it takes to find methods in a class.

How does Ruby's way of inheriting from one class impact the speed of method lookup?

Scenario Under Consideration

Analyze the time complexity of method lookup in Ruby's single inheritance.

class Animal
  def speak
    "sound"
  end
end

class Dog < Animal
  def speak
    "bark"
  end
end

Dog.new.speak
    

This code shows a class Dog inheriting from Animal and overriding a method. Ruby looks up methods by checking the class and its ancestors one by one.

Identify Repeating Operations

When Ruby calls a method, it searches through the class and its parent classes until it finds the method.

• Primary operation: Checking each class in the inheritance chain for the method.
• How many times: Once per class in the chain, starting from the object's class up to the top.

How Execution Grows With Input

As the inheritance chain gets longer, Ruby checks more classes to find the method.

Inheritance Chain Length (n)	Approx. Checks
2	2
5	5
10	10

Pattern observation: The number of checks grows directly with the length of the inheritance chain.

Final Time Complexity

Time Complexity: O(n)

This means the time to find a method grows linearly with the number of classes in the inheritance chain.

Common Mistake

[X] Wrong: "Ruby can check all parent classes at once, so method lookup is instant regardless of inheritance depth."

[OK] Correct: Ruby checks classes one by one from the object's class up the chain, so longer chains take more time.

Interview Connect

Understanding how inheritance affects method lookup helps you write efficient code and explain design choices clearly.

Self-Check

"What if Ruby supported multiple inheritance? How might that change the time complexity of method lookup?"