Ruby & Rails Interview Prep

Metaprogramming is "code that writes code." Ruby's flexibility at runtime is one of its most powerful features.

1. Dynamic Method Definition (define_method)

Copyclass Greeting
  ["english", "french", "spanish"].each do |lang|
    define_method("greet_in_#{lang}") do
      case lang
      when "english" then "Hello!"
      when "french"  then "Bonjour!"
      when "spanish" then "Hola!"
      end
    end
  end
end

Greeting.new.greet_in_french  # => "Bonjour!"

2. Dynamic Dispatch (send)

Copyuser.send("name")        # Calls user.name (even private!)
user.public_send("name") # Safe: only public methods

3. Ghost Methods (method_missing)

Intercepts calls to undefined methods — how ActiveRecord's find_by_name works.

Copyclass SecretAgent
  def method_missing(name, *args)
    puts "Searching for dossier: #{name}..."
  end
  def respond_to_missing?(name, include_private = false)
    true
  end
end

bond = SecretAgent.new
bond.goldfinger  # => Searching for dossier: goldfinger...

4. class_eval / instance_eval

Copy# Add method to all Strings at runtime
String.class_eval do
  def shout
    self.upcase + "!!!"
  end
end
"hello".shout  # => "HELLO!!!"

5. Introspection

• obj.methods — list all available methods
• obj.instance_variables — list all instance variables
• obj.respond_to?(:method_name) — check before calling

All three are closures — pieces of code that can be stored and passed around.

Blocks

Part of method call syntax. Not an object. Triggered inside method via yield.

Copydef run_block
  yield "Aravinth" if block_given?
end
run_block { |name| puts "Hello, #{name}!" }  # => Hello, Aravinth!

Procs — blocks as objects

Copysay_hi = Proc.new { puts "Hello!" }
say_hi.call  # => Hello!

Lambdas — strict Procs

Copysay_hi = -> { puts "Hello!" }
say_hi.call

Key Difference: Proc vs Lambda

The & Operator

Copyhello_proc = Proc.new { |name| puts "Hello, #{name}!" }
greet(&hello_proc)  # Converts Proc → block

def capture(&block)  # Converts block → Proc
  block.call
end

When to use: Blocks for one-off logic, Lambdas for reusable callable objects, Procs rarely (only for early-return behavior).

Scope Gates

class, module, and def each create a new scope — local variables do NOT cross these boundaries.

Copyx = 10
class MyClass
  puts x  # => NameError: undefined local variable
end

Why @@ is dangerous

Class variables are shared across the entire inheritance hierarchy, causing subtle bugs when subclasses modify them. Prefer class-level instance variables (@var on the class itself) instead.

Mixin Methods

• include M → M's methods become instance methods
• extend M → M's methods become class methods
• prepend M → M's methods run before the class's own methods

Copymodule Greetable
  def greet
    "Hello, I'm #{name}"
  end
end

class User
  include Greetable
  attr_reader :name
  def initialize(name) = @name = name
end

User.new("Alice").greet  # => "Hello, I'm Alice"

Duck Typing

Ruby has no native interfaces. Instead, it uses duck typing: "if it walks like a duck and quacks like a duck, it's a duck." Check capability with respond_to?, not class.

Copydef process(obj)
  raise "Not quackable" unless obj.respond_to?(:quack)
  obj.quack
end

When Ruby looks up a method, it walks the ancestor chain in order:

1. Prepended modules (right-to-left)
2. The class itself
3. Included modules (right-to-left)
4. Superclass (repeats up to BasicObject)
5. method_missing as final fallback

Copymodule A; end
module B; end

class MyClass
  prepend A
  include B
end

MyClass.ancestors
# => [A, MyClass, B, Object, Kernel, BasicObject]

Practical: prepend for transparent wrapping

Copymodule Logging
  def save
    puts "Saving..."
    super  # calls original MyModel#save
  end
end

class MyModel
  prepend Logging
  def save = puts "Saved!"
end

MyModel.new.save
# => Saving...
# => Saved!

An N+1 problem: 1 query for books, then 1 per book for the author = 11 queries for 10 books.

Copy# BAD (N+1)
Book.limit(10).each { |b| puts b.author.name }

# GOOD (2 queries total)
Book.includes(:author).limit(10).each { |b| puts b.author.name }

Three Methods Compared

Rails 6.1+: Strict Loading

Copyhas_many :books, strict_loading: true
# Raises ActiveRecord::StrictLoadingViolationError on N+1

Rails 7+: Async Loading

Copy@posts = Post.includes(:comments).load_async
do_other_work  # DB query runs in background thread
render @posts  # waits here if needed

Magic Naming

Copy# Auto-generates up/down methods:
rails g migration AddEmailToUsers email:string
rails g migration RemoveAgeFromUsers age:integer
rails g migration CreateProducts name:string price:decimal

Data Types to Know

• integer vs bigint — use bigint for IDs with high volume
• decimal — always for currency (never float)
• jsonb — PostgreSQL JSON with indexing support
• string vs text — string (255 limit) vs text (unlimited)

change vs up/down

Copyclass AddIndexToEmails < ActiveRecord::Migration[7.0]
  def change
    add_index :users, :email, unique: true  # reversible
  end
end

# Non-reversible operations need explicit up/down:
def up
  execute "UPDATE users SET role = 'admin' WHERE id = 1"
end
def down
  raise ActiveRecord::IrreversibleMigration
end

Single Table Inheritance (STI)

One table, type column differentiates subclasses. Simple but can cause sparse columns.

Copyclass Animal < ApplicationRecord; end
class Dog < Animal; end
class Cat < Animal; end
# All stored in `animals` table with `type` column

Delegated Types (Rails 6.1+)

Shared base table + separate tables per type. Best of both worlds.

Copyclass Entry < ApplicationRecord
  delegated_type :entryable, types: %w[Message Comment]
end
class Message < ApplicationRecord; end  # own table
class Comment < ApplicationRecord; end  # own table

Polymorphic Associations

Copyclass Comment < ApplicationRecord
  belongs_to :commentable, polymorphic: true
end
class Post < ApplicationRecord
  has_many :comments, as: :commentable
end
class Video < ApplicationRecord
  has_many :comments, as: :commentable
end

Service Object Example

Copy# app/services/user_registration_service.rb
class UserRegistrationService
  def initialize(params) = @params = params

  def call
    user = User.new(@params)
    if user.save
      UserMailer.welcome_email(user).deliver_later
      true
    else
      false
    end
  end
end

# In controller:
UserRegistrationService.new(user_params).call

Query Object Example

Copyclass PopularPostsQuery
  def call
    Post.where('created_at > ?', 1.month.ago)
        .joins(:likes)
        .group('posts.id')
        .order('COUNT(likes.id) DESC')
        .limit(10)
  end
end

Sidekiq Job Example

Copyclass SendEmailJob
  include Sidekiq::Job
  sidekiq_options retry: 3, queue: 'mailers'

  def perform(user_id)
    UserMailer.welcome(User.find(user_id)).deliver_now
  end
end

SendEmailJob.perform_async(user.id)
SendEmailJob.perform_in(5.minutes, user.id)

Dead Letter Queue (DLQ)

Jobs that fail all retries go to a DLQ. Monitor and replay manually. Essential for reliability in production.

Core Query Pattern

CopySELECT department, COUNT(*) AS total, AVG(salary) AS avg_salary
FROM employees
WHERE status = 'active'
GROUP BY department
HAVING COUNT(*) > 5
ORDER BY avg_salary DESC
LIMIT 10;

JOINs

Copy-- INNER JOIN: only matching rows
SELECT u.name, o.total FROM users u
INNER JOIN orders o ON o.user_id = u.id;

-- LEFT JOIN: all users, even those without orders
SELECT u.name, o.total FROM users u
LEFT JOIN orders o ON o.user_id = u.id;

CTE (Common Table Expression)

CopyWITH monthly_sales AS (
  SELECT DATE_TRUNC('month', created_at) AS month, SUM(total) AS revenue
  FROM orders GROUP BY 1
)
SELECT * FROM monthly_sales WHERE revenue > 10000;

Window Functions

CopySELECT name, salary,
  RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS rank
FROM employees;

Rails default: PostgreSQL is preferred in modern Rails for JSONB columns, better performance under concurrent writes, and richer query capabilities.

Associations

Copyclass User < ApplicationRecord
  has_many :posts, dependent: :destroy
  has_one  :profile
  belongs_to :company
  has_many :comments, through: :posts
end

Validations

Copyvalidates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP }
validates :age, numericality: { greater_than: 0, less_than: 150 }

Callbacks Order

before_validation → after_validation → before_save → before_create/update → (DB write) → after_create/update → after_save → after_commit

Yield in Layouts

Copy
<%= yield %>                   
<%= yield :sidebar %>          


<%= content_for :sidebar do %>
  
Sidebar content here
<% end %>

Hotwire Stack

• Turbo Drive — SPA-like navigation without JS frameworks
• Turbo Frames — decompose pages into independent sections
• Turbo Streams — server-pushed partial page updates over WebSocket
• Stimulus — minimal JS sprinkles for interactivity

Action Cable integrates WebSockets into Rails using a pub/sub model backed by Redis.

Key Concepts

• Connection — one WebSocket per browser tab (authentication here)
• Channel — logical grouping of streams (like a chat room)
• Broadcasting — server pushes data to all subscribers

Copy# app/channels/chat_channel.rb
class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from "chat_#{params[:room]}"
  end
end

# Broadcast from anywhere:
ActionCable.server.broadcast("chat_1", { message: "Hello!" })

Rails 7+: Turbo Streams over Cable

Copyclass Message < ApplicationRecord
  after_create_commit -> {
    broadcast_append_to "messages",
      partial: "messages/message",
      locals: { message: self }
  }
end

Copypid = fork do
  # Child process — separate memory space
  puts "Child PID: #{Process.pid}"
end
Process.waitpid(pid)
puts "Parent continues"

GIL (Global Interpreter Lock)

CRuby's GIL prevents true parallel thread execution for CPU-bound work. For I/O-bound tasks (web requests, DB queries), threads work well. For CPU-heavy work, use processes or JRuby/TruffleRuby.

Puma: Hybrid Model

Puma uses multiple workers (processes) × threads per worker, combining both approaches for web servers.