What is metaprogramming in Ruby?

Question

Accepted Answer

**Metaprogramming** is writing code that **writes or modifies code at runtime** — defining methods dynamically, responding to undefined methods, and inspecting/altering classes on the fly. Ruby's dynamic nature (everything is an object, including classes) makes it exceptionally good at metaprogramming, which powers much of Rails' "magic."

## Defining methods dynamically

```ruby
class Product
  # define methods programmatically at runtime
  [:name, :price, :sku].each do |attribute|
    define_method(attribute) do            # creates a getter method for each
      instance_variable_get("@#{attribute}")
    end
    define_method("#{attribute}=") do |value|   # and a setter
      instance_variable_set("@#{attribute}", value)
    end
  end
end
# → Product now has name/name=, price/price=, sku/sku= — generated, not hand-written
```

`define_method` creates methods at runtime — here generating accessors in a loop instead of writing each by hand. (This is essentially how `attr_accessor` works internally.)

## method_missing — handle undefined method calls

```ruby
class DynamicConfig
  def initialize = @settings = {}

def method_missing(name, *args)         # called when an UNDEFINED method is invoked
    name_str = name.to_s
    if name_str.end_with?("=")            # a setter like config.timeout = 30
      @settings[name_str.chomp("=")] = args.first
    else                                  # a getter like config.timeout
      @settings[name_str]
    end
  end
  def respond_to_missing?(name, include_private = false) = true
end

config = DynamicConfig.new
config.timeout = 30      # no `timeout=` method defined → method_missing handles it
config.timeout           # 30 — also via method_missing
```

**`method_missing`** intercepts calls to undefined methods — enabling dynamic APIs where methods don't need to be defined explicitly (used heavily in Rails, e.g. dynamic finders).

## Other metaprogramming tools

```ruby
obj.send(:method_name, args)        # call a method by name (even private)
obj.respond_to?(:method_name)        # check if a method exists
Object.const_get("ClassName")        # get a class by name string
self.class.instance_methods          # introspect methods
user.define_singleton_method(:special) { ... }   # add a method to one object
```

## Why it matters

Metaprogramming is one of Ruby's most powerful and distinctive features, and understanding it is valuable both for advanced Ruby development and — especially — for comprehending how **Rails and other Ruby frameworks achieve their "magic."** Ruby's exceptional metaprogramming ability (enabled by its dynamic nature where everything, including classes, is an object that can be manipulated at runtime) lets code write and modify code on the fly: **`define_method`** generates methods dynamically (avoiding repetitive hand-written code — it's how `attr_accessor` and Rails' dynamic attributes work), and **`method_missing`** intercepts undefined method calls (enabling flexible dynamic APIs — the mechanism behind Rails' dynamic finders like `find_by_name`, ActiveRecord attribute methods, and much more).

Understanding these techniques demystifies how frameworks like Rails provide their seemingly magical, concise APIs (where methods you never explicitly defined just work), which is important for both using these frameworks effectively and for building your own flexible, DSL-like APIs and libraries.

Knowing the metaprogramming tools (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) reflects advanced Ruby knowledge.

While powerful, metaprogramming should be used judiciously (it can make code harder to follow, debug, and statically analyze — the trade-off for its flexibility).

Understanding metaprogramming — what it is (code that manipulates code at runtime), the key techniques, and that it powers Rails' magic — is valuable senior-level knowledge that explains how the Ruby frameworks you use work, enables advanced metaprogramming and DSL creation, and is a hallmark of deep Ruby expertise and a common advanced interview topic distinguishing developers who truly understand Ruby's dynamic capabilities.