Ruby Interview Questions and Answers

Top 100 Ruby Interview Questions for Freshers

Ruby is one of the most widely used programming languages in top tech companies, including IDM TechPark. Its flexibility, simplicity, and extensive libraries make it an essential skill for developers. To secure a Ruby developer role at IDM TechPark, candidates must be well-versed in Ruby concepts and ready to tackle both the Ruby Online Assessment and Technical Interview Round.
To help you succeed, we have compiled a list of the Top 100 Ruby Interview Questions along with their answers. Mastering these will give you a strong edge in cracking Ruby interviews at IDM TechPark.

1. What is Ruby?

Answer:
Ruby is a dynamic, open-source, object-oriented programming language known for its simplicity and readability. It is widely used in web development, scripting, and automation.

2. What are the main features of Ruby?

Answer:

Purely object-oriented (everything is an object).
Dynamic typing and duck typing.
Garbage collection for memory management.
Metaprogramming support.
Blocks, Procs, and Lambdas for flexible coding.

3. What is IRB in Ruby?

Answer:
IRB (Interactive Ruby) is a command-line tool that allows you to execute Ruby code interactively.

CopyEdit

$ irb >> puts "Hello, Ruby!" Hello, Ruby!

4. What are Ruby’s primitive data types?

Answer:

Integer (10, -5)
Float (3.14, -2.5)
Boolean (true, false)
String ("Hello", 'World')
Symbol (:name, :age)
Array ([1, 2, 3])
Hash ({name: "John", age: 25})

5. What is the difference between puts, print, and p in Ruby?

Answer:

puts adds a newline after output.
print does not add a newline.
p prints debug-friendly output (inspects objects).

ruby

CopyEdit

puts "Hello" # Output: Hello (newline) print "World" # Output: World (no newline) p [1, 2, "Hi"] # Output: [1, 2, "Hi"]

6. What is a Symbol in Ruby?

Answer:
A Symbol is an immutable, unique identifier used as a lightweight alternative to strings.

ruby

CopyEdit

:name == :name # true (same object) "hello" == "hello" # true (but different objects)

7. What is the difference between an Array and a Hash in Ruby?

Answer:

Array: Ordered collection of elements.

ruby

CopyEdit

arr = [1, 2, 3]
Hash: Key-value pair storage.

ruby

CopyEdit

hash = { name: "John", age: 25 }

8. What is the difference between ==, .eql?, and equal? in Ruby?

Answer:

== checks value equality.
.eql? checks value & type equality.
equal? checks object identity.

ruby

CopyEdit

a = "hello" b = "hello" c = a a == b # true a.eql? b # true a.equal? b # false a.equal? c # true

9. What is the difference between a Block, Proc, and Lambda in Ruby?

Answer:

Block: A piece of code passed to methods.
Proc: A saved block that can be reused.
Lambda: Similar to Proc but has stricter argument handling.

ruby

CopyEdit

def greet yield end greet { puts "Hello!" } # Block proc_example = Proc.new { puts "Hello from Proc!" } proc_example.call # Proc lambda_example = -> { puts "Hello from Lambda!" } lambda_example.call # Lambda

10. What is a Class in Ruby?

Answer:
A class is a blueprint for creating objects.

ruby

CopyEdit

class Car def initialize(model) @model = model end end

11. What are blocks in Ruby?

Answer:
Blocks are chunks of code enclosed in {} or do...end that can be passed to methods.

def greet yield end greet { puts "Hello from the block!" }

12. What is the difference between puts, print, and p in Ruby?

Answer:

MethodDescription

putsAdds newline after output

printOutputs without newline

pShows raw form (for debugging)

13. What are symbols in Ruby?

Answer:
Symbols are immutable, reusable constants. They start with a colon (:).

:name, :id

They use less memory than strings and are often used as hash keys.

14. What is the difference between == and === in Ruby?

Answer:

== checks value equality
=== is used for case equality, mainly in case...when statements

case 5 when Integer puts "It's an integer" # Uses === internally end

15. How are hashes defined in Ruby?

Answer:

person = { name: "Alice", age: 25 }

Hashes use key-value pairs. Keys can be symbols, strings, or objects.

16. What is the difference between require and include in Ruby?

Answer:

require: Loads external files/libraries
include: Mixes a module's methods into a class

require 'date' include Math

17. What is the self keyword in Ruby?

Answer:
self refers to the current object. In a class, it can be used to define class methods or access the instance itself.

class Person def self.say_hi puts "Hi!" end end

18. What is a module in Ruby?

Answer:
Modules are collections of methods and constants. Used for namespacing and mixins.

module Greet def hello "Hello!" end end

Use include or extend to use them in classes.

19. What is an iterator in Ruby?

Answer:
An iterator is a method that repeatedly invokes a block. Common ones: each, map, select.

[1, 2, 3].each { |n| puts n }

20. How do you define a class and create an object in Ruby?

Answer:

class Dog def bark "Woof!" end end my_dog = Dog.new puts my_dog.bark

21. Q: What is Ruby?
A: Ruby is a high-level, interpreted, object-oriented programming language known for its simplicity and productivity. It has an elegant syntax that is easy to read and write.

22. Q: What are variables in Ruby and how are they declared?
A: Variables in Ruby are used to store data. They are dynamically typed and declared by simply assigning a value.

Example:

name = "Alice" age = 30

23. Q: What is a method in Ruby?
A: A method is a block of code that performs a specific task and can be reused. It is defined using the def keyword.

Example:

def greet(name) "Hello, #{name}!" end puts greet("Bob")

24. Q: What are arrays in Ruby?
A: Arrays are ordered collections that can hold objects of any type.

Example:

fruits = ["apple", "banana", "cherry"] puts fruits[1] # Output: banana

25. Q: What is the difference between puts and print in Ruby?
A:

puts outputs text with a newline at the end.
print outputs text without adding a newline.

Example:

puts "Hello" print "World" # Output: # Hello # World

1. What is Duck Typing in Ruby?

Answer:
Duck Typing means that Ruby determines an object's type based on the methods it responds to, rather than its class.

ruby

CopyEdit

def speak(animal) animal.speak end class Dog def speak puts "Woof!" end end class Cat def speak puts "Meow!" end end speak(Dog.new) # Woof! speak(Cat.new) # Meow!

2. What are Mixins in Ruby?

Answer:
Mixins allow multiple inheritance using modules.

ruby

CopyEdit

module Swim def swim puts "Swimming!" end end class Fish include Swim end Fish.new.swim # Swimming!

3. What is Metaprogramming in Ruby?

Answer:
Metaprogramming allows Ruby to write and modify code at runtime.

ruby

CopyEdit

class Example define_method(:dynamic_method) do puts "This method was defined dynamically!" end end Example.new.dynamic_method # This method was defined dynamically!

4. What is method_missing in Ruby?

Answer:
method_missing handles calls to undefined methods dynamically.

ruby

CopyEdit

class DynamicMethods def method_missing(name, *args) puts "You called #{name} with #{args}" end end obj = DynamicMethods.new obj.unknown_method(1, 2, 3) # Output: You called unknown_method with [1, 2, 3]

5. What is the difference between Proc and Lambda?

Answer:

Lambda enforces exact arguments and returns to the caller.
Proc allows flexible arguments and returns immediately.

ruby

CopyEdit

proc_example = Proc.new { return "Proc exits early" } lambda_example = -> { return "Lambda exits normally" } def test proc_example.call # Will exit method here puts "This won't print" end puts lambda_example.call # Lambda returns to caller

6. What is singleton_class in Ruby?

Answer:
A singleton class allows defining methods for a single object.

ruby

CopyEdit

obj = "Hello" def obj.greet puts "Singleton method!" end obj.greet # Singleton method!

7. What is the difference between include and extend?

Answer:

include adds methods as instance methods.
extend adds methods as class methods.

ruby

CopyEdit

module Greetings def hello puts "Hello!" end end class Person include Greetings end class Robot extend Greetings end Person.new.hello # Instance method Robot.hello # Class method

8. What are public, private, and protected in Ruby?

Answer:

public: Accessible from anywhere.
private: Accessible only inside the class.
protected: Accessible inside the class and subclasses.

ruby

CopyEdit

class Example def public_method puts "Public" end private def private_method puts "Private" end end

9. What is freeze in Ruby?

Answer:
freeze prevents modifications to an object.

ruby

CopyEdit

str = "Hello".freeze str << " World" # Error: Frozen object

10. What is a Struct in Ruby?

Answer:
A Struct is a lightweight class with automatic attribute accessors.

ruby

CopyEdit

Person = Struct.new(:name, :age) p = Person.new("Alice", 25) puts p.name # Alice

11. What are blocks, procs, and lambdas in Ruby?

Answer:

Block: A chunk of code passed to a method that can be executed within that method. It is passed with yield or call.

def greet yield end greet { puts "Hello!" }

Proc: An object that holds a block and can be passed around like a variable.

my_proc = Proc.new { puts "Hello from Proc!" } my_proc.call

Lambda: Similar to Proc but more strict about argument count and return behavior.

my_lambda = ->(x) { x * 2 } my_lambda.call(3) # Output: 6

12. What is method chaining in Ruby?

Answer:

Method chaining involves calling multiple methods on the same object in a single line. Each method returns the object (or another object) that allows further methods to be called.

"hello".upcase.reverse #=> "OLLEH"

13. What are the differences between dup and clone in Ruby?

Answer:

dup: Creates a shallow copy of an object (does not copy the object’s frozen state).
clone: Creates a shallow copy and copies the frozen state and taint state of the object.

original = "Hello" duplicate = original.dup clone = original.clone

14. How do you define a class method in Ruby?

Answer:

To define a class method, you use self in front of the method name within the class.

class MyClass def self.my_class_method "I'm a class method!" end end MyClass.my_class_method

15. How does Ruby handle memory management?

Answer:

Ruby uses automatic garbage collection (GC) to manage memory. It frees up memory that is no longer in use by tracking objects and their references.

Objects are cleaned up when they are no longer referenced.
Ruby developers can interact with the garbage collector using GC.start and configure GC settings.

16. What is yield in Ruby and how is it used?

Answer:

yield is used to pass control from a method to a block provided to that method.

def greet yield "Alice" end greet { |name| puts "Hello, #{name}" } # Output: Hello, Alice

If no block is given, yield raises an error.

17. What are module and class variables in Ruby?

Answer:

Class Variables: Shared among all instances of a class. Defined with @@:

class MyClass @@counter = 0 end

Module Variables: Used within a module and shared among the methods defined inside the module.

module MyModule @@module_var = 100 end

18. How do you handle multi-line strings in Ruby?

Answer:

Ruby provides several ways to handle multi-line strings:

Here Documents: Using <<-:

str = <<-TEXT This is a multi-line string TEXT

Double Quotes with \n: For multi-line strings without formatting:

str = "This is \na multi-line \nstring"

19. What is the self keyword in Ruby?

Answer:

The self keyword in Ruby refers to the current object or context.

Inside an instance method, self refers to the current object.
Inside a class method, self refers to the class itself.

class MyClass def instance_method self # Refers to the instance end def self.class_method self # Refers to the class end end

20. What is the difference between == and equal? in Ruby?

Answer:

== compares values for equality.
equal? compares object identity, meaning it checks if two references point to the same object.

a = "hello" b = "hello" a == b # true (values are the same) a.equal? b # false (different objects)

21. Q: What are symbols in Ruby and how are they different from strings?
A: Symbols are lightweight, immutable identifiers often used as keys in hashes or for referencing method names. Unlike strings, each symbol is only stored once in memory.

Example:

:name # Symbol "name" # String

Difference: :name is immutable and reused; "name" creates a new object each time.

22. Q: What is a block in Ruby? How is it used?
A: A block is an anonymous piece of code passed to methods. Blocks can be defined using {} or do...end.

Example:

3.times do |i| puts "Iteration #{i}" end

Blocks are used extensively in iterators and DSLs (Domain-Specific Languages).

23. Q: What is the difference between proc and lambda in Ruby?
A: Both are types of callable objects, but they differ in behavior:

lambda checks the number of arguments and uses normal return.
proc is more lenient with arguments and returns from the calling context.

Example:

my_lambda = ->(x) { return x * 2 } my_proc = Proc.new { |x| return x * 2 } # May exit the method it’s called from

24. Q: How do you handle exceptions in Ruby?
A: Ruby uses begin-rescue-end for exception handling.

Example:

begin result = 10 / 0 rescue ZeroDivisionError => e puts "Error: #{e.message}" end

You can also use ensure to run code regardless of an exception.

25. Q: What are mixins in Ruby and how are they implemented?
A: Mixins are a way to include shared behavior using modules. Ruby does not support multiple inheritance, but mixins allow adding functionality to classes.

Example:

module Greetable def greet "Hello!" end end class Person include Greetable end puts Person.new.greet # Output: Hello!

Let me know if you’d like the advanced set next or have a specific Ruby topic in mind!

1. What is a Singleton Pattern in Ruby?

Answer:
A singleton ensures only one instance of a class exists.

ruby

CopyEdit

class SingletonExample @@instance = nil def self.instance @@instance ||= new end private_class_method :new end obj1 = SingletonExample.instance obj2 = SingletonExample.instance puts obj1 == obj2 # true

2. How does Ruby’s Garbage Collector (GC) work?

Answer:
Ruby uses a mark-and-sweep garbage collector. It marks unused objects and reclaims memory. Generational GC optimizes this by categorizing objects into:

Young objects: Short-lived objects collected frequently.
Old objects: Long-lived objects collected less often.

ruby

CopyEdit

GC.start # Forces garbage collection puts GC.stat # Shows GC statistics

3. What is a Memory Leak in Ruby?

Answer:
A memory leak occurs when objects are unintentionally retained, preventing GC.

ruby

CopyEdit

class Leak @@instances = [] def initialize @@instances << self end end 10.times { Leak.new } puts ObjectSpace.each_object(Leak).count # Leak count

4. What is a Binding Object in Ruby?

Answer:
A binding captures the current execution context.

ruby

CopyEdit

def get_binding(value) binding end b = get_binding(10) puts eval("value", b) # 10

5. How does Ruby handle Method Caching?

Answer:
Ruby optimizes method lookups by caching them.

Clearing the cache occurs when new methods are defined.
Performance can be impacted by frequent method redefinitions.

ruby

CopyEdit

class Test def run; end end puts Test.new.run # Cached method call

6. What is define_method in Ruby?

Answer:
It dynamically creates methods.

ruby

CopyEdit

class Example define_method(:hello) { puts "Hello, world!" } end Example.new.hello # Hello, world!

7. How does prepend work in Ruby?

Answer:
prepend inserts a module before the class in the method lookup chain.

ruby

CopyEdit

module A def greet puts "Hello from A" end end class B prepend A def greet puts "Hello from B" end end B.new.greet # Hello from A

8. How does Ruby’s Concurrency work?

Answer:
Ruby uses GIL (Global Interpreter Lock), allowing only one thread to execute Ruby code at a time (MRI).

JRuby removes GIL for true parallelism.

ruby

CopyEdit

threads = 3.times.map do Thread.new { puts "Thread #{Thread.current.object_id}" } end threads.each(&:join)

9. What is DRb (Distributed Ruby)?

Answer:
DRb allows distributed objects over a network.

ruby

CopyEdit

require 'drb/drb' DRb.start_service('druby://localhost:9999', Object.new) DRb.thread.join

10. How does method_missing impact performance?

Answer:
Overusing method_missing slows down method lookups. Alternatives:

Use respond_to_missing?
Use define_method for dynamic methods.

ruby

CopyEdit

class Test def method_missing(name, args) puts "Undefined method: #{name}" end end Test.new.unknown_method # Undefined method: unknown_method

11. What is metaprogramming in Ruby?

Answer:

Metaprogramming in Ruby refers to writing code that can manipulate itself or other code during runtime. This includes defining methods dynamically, modifying classes, or creating methods programmatically.

Examples:

define_method to create methods dynamically:

class DynamicMethods ['foo', 'bar', 'baz'].each do |method_name| define_method(method_name) { "This is #{method_name}" } end end obj = DynamicMethods.new puts obj.foo # "This is foo"

method_missing to handle undefined methods:

class MyClass def method_missing(name) puts "You tried to call #{name}" end end

12. What are method_missing and respond_to_missing? in Ruby?

Answer:

method_missing: Called when an undefined method is called on an object. It allows for dynamic method creation or custom behavior.

class MyClass def method_missing(name, *args) puts "Called #{name} with arguments #{args.join(', ')}" end end

respond_to_missing?: Allows checking if an object can respond to a specific method, often used in conjunction with method_missing.

class MyClass def respond_to_missing?(name, include_private = false) name.to_s.start_with?("dynamic_") || super end end

13. How do you implement concurrency in Ruby?

Answer:

Ruby provides several ways to implement concurrency:

Threads: Ruby has built-in support for threads, allowing concurrent execution within the same process.

Thread.new do puts "This runs in a separate thread" end

Fibers: Lightweight concurrency, used in scenarios where you need cooperative multitasking.

fiber = Fiber.new { puts "Hello from the fiber!" } fiber.resume

Concurrency Libraries: Ruby has libraries like concurrent-ruby for more advanced concurrency patterns.

14. What are some ways to optimize Ruby code for performance?

Answer:

Use Symbol Keys for Hashes: Symbols are more memory efficient than strings.

hash = {name: "John", age: 30}

Avoid Repeated Object Creation: Reuse objects rather than creating new ones within loops or frequently called methods.
Use each and map Instead of for Loops: each and map are more efficient in Ruby.
Profiling: Use tools like Benchmark or ruby-prof to identify bottlenecks.

require 'benchmark' Benchmark.bm do |x| x.report("method1") { method1 } x.report("method2") { method2 } end

Use freeze to Prevent Object Mutation: Prevent unnecessary object duplication by freezing objects when they don’t need to be modified.

15. What are the key differences between Ruby 1.8 and Ruby 1.9 (and beyond)?

Answer:

Performance Improvements: Ruby 1.9 introduced the YARV (Yet Another Ruby VM) interpreter, improving performance significantly compared to Ruby 1.8.
New Syntax for Hashes: In Ruby 1.9 and later, hash keys can be written as symbols without the hash rocket (=>).

# Ruby 1.9 and beyond hash = { key: "value" }

Encoding Support: Ruby 1.9 introduced encoding support, allowing Ruby to handle different character encodings.
Improvements in Regular Expressions: Ruby 1.9 introduced named captures in regular expressions, making it easier to work with complex patterns.

16. Explain the ObjectSpace module in Ruby.

Answer:

The ObjectSpace module provides access to the internal object space in Ruby, enabling introspection and manipulation of live objects.

ObjectSpace.each_object: Iterate over all objects of a specific class.

ObjectSpace.each_object(String) { |obj| puts obj }

ObjectSpace.count_objects: Counts the number of living objects by type.

puts ObjectSpace.count_objects

17. How do you implement a Singleton pattern in Ruby?

Answer:

You can use the Singleton module in Ruby to ensure that a class has only one instance.

require 'singleton' class MySingleton include Singleton end obj1 = MySingleton.instance obj2 = MySingleton.instance puts obj1.equal?(obj2) # true

18. What is the difference between class and module in Ruby?

Answer:

Class: Can be instantiated and have objects. Supports inheritance.

class Animal def speak; "Roar!"; end end dog = Animal.new

Module: Cannot be instantiated and cannot be inherited. Used for mixins to add functionality to classes.

module Swimmable def swim; "I can swim!"; end end class Fish include Swimmable end

19. How do you manage dependencies in a Ruby project?

Answer:

Ruby uses bundler and the Gemfile to manage dependencies:

Gemfile: Lists all the required gems for your project.

source 'https://rubygems.org' gem 'rails', '5.2.3' gem 'pg', '1.1.4'

Bundler: Install the dependencies from the Gemfile.

bundle install

gem command: To manage individual gems.

gem install rails

20. What are @ and @@ variables in Ruby?

Answer:

@: Instance variables belong to a specific instance of a class.

class Person def initialize(name) @name = name end end

@@: Class variables are shared across all instances of the class.

class Counter @@count = 0 def increment @@count += 1 end end

21. Q: What is metaprogramming in Ruby?
A: Metaprogramming is the ability of Ruby to write code that writes or modifies other code at runtime. It uses methods like define_method, method_missing, class_eval, and send to dynamically create behavior.

Example:

class Person [:name, :age].each do |attr| define_method(attr) do instance_variable_get("@#{attr}") end define_method("#{attr}=") do |value| instance_variable_set("@#{attr}", value) end end end

22. Q: What is method_missing and how should it be used responsibly?
A: method_missing is a hook method that is called when an object receives a method call it doesn’t recognize. It's commonly used in DSLs and dynamic proxies.

Example:

class DynamicAttributes def method_missing(method, *args) puts "You called: #{method} with #{args.inspect}" end end

Caution: Always override respond_to_missing? for compatibility with tools like introspection and reflection.

23. Q: Explain the difference between include, extend, and prepend in Ruby.
A:

include adds module methods as instance methods.
extend adds module methods as class methods to a single object or class.
prepend is like include, but the module's methods override existing methods in the class.

Example:

module A def greet; "Hello from A"; end end class B prepend A def greet; "Hello from B"; end end puts B.new.greet # Output: "Hello from A"

24. Q: What is the difference between class_eval and instance_eval?
A:

class_eval executes code in the context of the class itself, useful for defining methods.
instance_eval executes code in the context of a single object, used to manipulate instance variables or define singleton methods.

Example:

class MyClass; end MyClass.class_eval { def hello; "Hi"; end } MyClass.new.hello # => "Hi" obj = Object.new obj.instance_eval { def greet; "Hello"; end } obj.greet # => "Hello"

25. Q: How does garbage collection work in Ruby?
A: Ruby uses a mark-and-sweep garbage collector (GC) to automatically manage memory. It tracks object references and deallocates those that are no longer reachable. Modern Ruby (2.1+) includes generational and incremental GC, improving performance and responsiveness.

You can trigger or control GC using:

GC.start # Manually starts garbage collection GC.disable # Disables GC GC.enable # Re-enables GC

1. What is Metaprogramming in Ruby? How does it work?

Answer:
Metaprogramming allows code to modify itself at runtime by dynamically defining methods, modifying classes, and intercepting method calls.
Example: Using define_method

ruby

CopyEdit

class Meta [:hello, :bye].each do |method_name| define_method(method_name) do puts "#{method_name.capitalize} from metaprogramming!" end end end m = Meta.new m.hello # "Hello from metaprogramming!" m.bye # "Bye from metaprogramming!"

2. What are Ruby Symbols? How do they differ from Strings?

Answer:

Symbols (:symbol) are immutable and stored in memory once, making them more efficient than strings.
Strings ("string") are mutable, meaning every new string creates a new object.

ruby

CopyEdit

puts :hello.object_id == :hello.object_id # true (same object) puts "hello".object_id == "hello".object_id # false (different objects)

3. How do you handle method missing in Ruby?

Answer:
The method_missing hook intercepts undefined method calls.
Optimized approach: Always override respond_to_missing? for better compatibility.

ruby

CopyEdit

class DynamicMethod def method_missing(name, *args) puts "You tried to call #{name} with #{args.inspect}" end def respond_to_missing?(method_name, include_private = false) true end end dm = DynamicMethod.new dm.unknown_method(42) # "You tried to call unknown_method with [42]" puts dm.respond_to?(:unknown_method) # true

4. What is the difference between Proc, Lambda, and Block?

FeatureProcLambdaBlock

Returns from method?Returns from outer scopeReturns from lambda onlyReturns from outer scope

Argument checkingNo strict checkingStrict checkingNo strict checking

Object typeProc objectProc object (Lambda flag)Code snippet

Example:

ruby

CopyEdit

def proc_vs_lambda my_proc = Proc.new { return "Proc return" } my_lambda = -> { return "Lambda return" } puts my_lambda.call # "Lambda return" puts my_proc.call # Exits method early end puts proc_vs_lambda

5. How does Ruby's Garbage Collector work?

Answer:

Ruby uses Mark-and-Sweep GC.
Ruby 2.1+ introduced Generational GC (Young & Old objects).
Use GC.start to force GC, but it's inefficient.

ruby

CopyEdit

puts GC.stat # Shows current GC statistics

6. What is a Thread in Ruby, and how does it work with the GIL?

Answer:

Ruby (MRI) has a Global Interpreter Lock (GIL), allowing only one thread to execute at a time.
True parallelism is possible in JRuby and Rubinius.

ruby

CopyEdit

threads = [] 5.times do |i| threads << Thread.new { puts "Thread #{i}" } end threads.each(&:join)

7. How do Fibers differ from Threads in Ruby?

Answer:

Fibers are lightweight, manually controlled execution units.
Threads execute in parallel (subject to GIL).

ruby

CopyEdit

fiber = Fiber.new do puts "Hello from fiber" Fiber.yield puts "Resumed fiber" end fiber.resume # "Hello from fiber" fiber.resume # "Resumed fiber"

8. What is Lazy Evaluation in Ruby?

Answer:
Lazy evaluation defers execution until needed, optimizing memory for large datasets.

ruby

CopyEdit

lazy_enum = (1..Float::INFINITY).lazy.map { |n| n**2 }.first(5) puts lazy_enum.inspect # [1, 4, 9, 16, 25]

9. How do you prevent Memory Leaks in Ruby?

Answer:

Avoid large global variables and class variables (@@var).
Use WeakRef for caching objects without preventing GC.

ruby

CopyEdit

require 'weakref' obj = "Hello, World!" weak_obj = WeakRef.new(obj) puts weak_obj # "Hello, World!" GC.start # Force garbage collection

10. How does Ruby handle WebSockets and Real-time Communication?

Answer:

EventMachine and Faye provide asynchronous event handling for WebSockets.
ActionCable (Rails) integrates WebSockets easily.

ruby

CopyEdit

require 'faye/websocket' require 'eventmachine' EM.run { ws = Faye::WebSocket::Client.new('ws://echo.websocket.org') ws.on :open do |event| ws.send('Hello, WebSocket!') end ws.on :message do |event| puts "Received: #{event.data}" ws.close end ws.on :close do |_event| EM.stop end }

11. How does Ruby handle thread safety and concurrency?

Answer:

Ruby uses Global Interpreter Lock (GIL) in its standard interpreter, MRI (Matz's Ruby Interpreter), which prevents multiple threads from executing Ruby bytecodes simultaneously. However, Ruby threads can still be useful for I/O-bound operations, as the GIL only affects CPU-bound tasks.

Thread Safety: If a class or library is thread-safe, it can safely be used in a multithreaded environment. For thread safety:
- Synchronization mechanisms like Mutex are used to ensure that only one thread accesses a shared resource at a time.
- Example:

mutex = Mutex.new mutex.synchronize do # Critical section of code end

Concurrency: Ruby threads can run concurrently, but only one thread executes Ruby code at a time. For I/O-bound operations, like reading from a file or making network requests, multiple threads can still be useful.

12. What is the difference between Thread.new and Thread.start in Ruby?

Answer:

Thread.new: This is a more general way to create a new thread in Ruby. It starts the thread immediately and yields to the block given.

Thread.new { puts "Hello from the new thread" }

Thread.start: This is an alias for Thread.new in Ruby. There is no functional difference between the two; both create and start a thread immediately.

Thread.start { puts "Hello from the start thread" }

13. Explain Ruby's garbage collection mechanism.

Answer:

Ruby uses automatic garbage collection (GC) to manage memory and clean up unused objects. The garbage collector in Ruby works by identifying objects that are no longer referenced and freeing up their memory.

Generational Garbage Collection: Ruby’s garbage collector is generational, meaning that it organizes objects into generations (young and old). Objects that survive many GC cycles are promoted to the older generation.
Mark and Sweep: The GC works by marking all objects that are still in use and then sweeping away those that are not.
Manual Garbage Collection: You can manually invoke garbage collection using GC.start.

GC.start # Forces garbage collection to run

14. How does Ruby handle object immutability?

Answer:

In Ruby, some objects are mutable (can be changed), while others are immutable (cannot be changed once created).

Immutable Objects:
- Symbols: Once created, symbols are immutable and stored in the symbol table.
- Frozen Objects: You can make an object immutable by calling freeze on it. A frozen object cannot be modified after its creation.

str = "Hello" str.freeze str << " World" # Raises a RuntimeError

Mutable Objects: Strings, arrays, and hashes are mutable by default.

15. What are fibers in Ruby, and how do they differ from threads?

Answer:

Fibers in Ruby provide a way to implement cooperative multitasking. Unlike threads, which are preemptively scheduled by the operating system, fibers are manually scheduled and allow developers to control the execution flow.

Fibers are lightweight and cheaper in terms of memory overhead compared to threads.
Thread: Preemptively scheduled by the operating system; better for parallelism.
Fiber: Cooperatively scheduled by the program; better for concurrency, where you can control the switching between tasks.

fiber = Fiber.new do puts "First fiber" Fiber.yield puts "Resumed fiber" end fiber.resume # First fiber fiber.resume # Resumed fiber

16. How can you avoid memory leaks in Ruby?

Answer:

Memory leaks in Ruby typically occur when objects that are no longer needed are still referenced, preventing the garbage collector from cleaning them up. To avoid memory leaks:

Release References: Make sure that objects are dereferenced when they are no longer needed.

obj = SomeObject.new obj = nil # Dereference to allow GC to collect it

Use Weak References: Ruby provides WeakRef to create references to objects that don’t prevent them from being garbage collected.

require 'weakref' obj = SomeObject.new weak_ref = WeakRef.new(obj)

Avoid Circular References: Circular references can prevent the garbage collector from cleaning up objects. Ensure there are no circular references in your data structures.

17. How does Ruby handle exception handling?

Answer:

Ruby handles exceptions using the begin, rescue, ensure, and else keywords. Exceptions allow developers to handle runtime errors gracefully.

begin: Marks the start of a block of code to monitor for exceptions.
rescue: Catches exceptions and allows the program to handle them.
ensure: Always runs, regardless of whether an exception occurred or not (often used for cleanup).
else: Runs only if no exception is raised in the begin block.

begin # Code that might raise an exception raise 'Some error' rescue => e puts "Handled error: #{e.message}" ensure puts "This will always run" end

18. What is the __send__ method in Ruby?

Answer:

The __send__ method is a lower-level version of send and is used to invoke methods on an object dynamically. Unlike send, it allows for calling private and protected methods as well.

class MyClass private def private_method "I'm private!" end end obj = MyClass.new puts obj.__send__(:private_method) # "I'm private!"

Use __send__ cautiously since it bypasses access control mechanisms.

19. What is the purpose of alias_method and alias_method_chain in Ruby?

Answer:

alias_method: Creates an alias for an existing method. This is often used to override a method while preserving the original functionality.

class MyClass def hello "Hello" end alias_method :greet, :hello end obj = MyClass.new puts obj.greet # "Hello"

alias_method_chain: A Rails-specific method for chaining method overrides. This was used in earlier versions of Rails but is now deprecated in favor of Module#prepend.

# Deprecated in Rails 5 and higher class MyClass def hello "Hello" end def hello_with_exclamation hello_without_exclamation + "!" end alias_method_chain :hello, :exclamation end

20. How does Ruby handle duck typing?

Answer:

Duck typing in Ruby refers to the concept where an object's suitability is determined by the methods it responds to, rather than its class. If an object behaves like a certain type (i.e., responds to specific methods), it is treated as that type.

Example:

class Dog def speak "Woof!" end end class Cat def speak "Meow!" end end def make_sound(animal) puts animal.speak # Works as long as the object has a `speak` method end make_sound(Dog.new) # "Woof!" make_sound(Cat.new) # "Meow!"

21. Q: How do you manage memory in Ruby, and what tools can help with memory profiling?
A: Ruby handles memory management through its built-in garbage collector (GC), which uses a mark-and-sweep algorithm. In modern versions (2.1+), Ruby uses generational GC (young and old objects) and incremental GC for better performance.

Memory Profiling Tools:

ObjectSpace – track object allocation and counts
GC.stat – inspect GC statistics
Gems like memory_profiler, derailed_benchmarks, and stackprof

Example:

puts GC.stat[:total_allocated_objects]

22. Q: What is a singleton class in Ruby and how is it used?
A: A singleton class is a hidden class attached to a single object that holds its methods. It's how Ruby supports per-object behavior (e.g., defining methods only on one instance).

Example:

str = "hello" def str.shout upcase + "!" end puts str.shout # Output: HELLO!

You can also access it explicitly:

class << str def whisper downcase + "..." end end

23. Q: How does Ruby handle concurrency and what are Fibers?
A: Ruby supports concurrency via:

Threads: true concurrency (on JRuby or TruffleRuby); limited by GVL in MRI.
Fibers: lightweight cooperative concurrency; manually yielded.
Ractors (Ruby 3.0+): parallel execution without sharing memory.

Fiber Example:

fiber = Fiber.new do puts "Start" Fiber.yield puts "Resume" end fiber.resume # => Start fiber.resume # => Resume

24. Q: How does method lookup work in Ruby's object model?
A: Ruby uses a method lookup path starting from:

The object's singleton class
The object's class
Included modules (in reverse inclusion order)
Superclasses
BasicObject (at the top)

Ruby uses depth-first, left-to-right resolution. You can inspect it using:

MyClass.ancestors

25. Q: What is the difference between require, require_relative, and load in Ruby?
A:

require loads a file once, searching the $LOAD_PATH.
require_relative loads a file once, relative to the current file's directory.
load loads a file every time it's called.

Example:

require 'json' # Looks in standard libraries and gems require_relative 'config' # Looks in current directory load 'config.rb' # Reloads every time

"Deep Concepts to Elevate Your Career"

This guide provides 100+ Ruby interview questions along with in-depth concepts to strengthen your expertise.

Download

Ruby Interview Questions and Answers

Top 100 Ruby Interview Questions for Freshers

"Deep Concepts to Elevate Your Career"

This guide provides 100+ Ruby interview questions along with in-depth concepts to strengthen your expertise.

Contact Us

IDM Techpark Erode
1st floor, 33/15 vasavi complex, nalli
hospital road, annamalai layout, near bus
stand, erode 638011

+91-95853-05700

idmtechpark@gmail.com

Software Courses

Full Stack Developer

Ruby Interview Questions and Answers

Top 100 Ruby Interview Questions for Freshers

"Deep Concepts to Elevate Your Career"

This guide provides 100+ Ruby interview questions along with in-depth concepts to strengthen your expertise.

Contact Us

IDM Techpark Erode 1st floor, 33/15 vasavi complex, nalli hospital road, annamalai layout, near bus stand, erode 638011

+91-95853-05700

idmtechpark@gmail.com

Software Courses

Full Stack Developer

IDM Techpark Erode
1st floor, 33/15 vasavi complex, nalli
hospital road, annamalai layout, near bus
stand, erode 638011