Include vs Extend

Direct Answer

include SomeModule makes the module's instance methods available to instances of the receiving class, while extend SomeModule makes those methods singleton methods of the receiving object. Therefore User.include(Greeting) lets User.new.greet work; User.extend(Greeting) lets User.greet work. Any individual object can also be extended without changing other instances of its class.

Deep Dive & Architecture

A module stores instance-method definitions. include inserts that module into the ancestor chain used by instances of the class. Ruby still performs normal message lookup; it does not paste a second independent copy of each method into every object.

extend operates on one receiver. It includes the module in that receiver's singleton class, a hidden class that holds methods unique to the object. When the receiver happens to be a class object, those singleton methods are what Ruby developers normally call class methods.

This model explains why obj.extend(M) is local to obj and why module methods can read the receiver's state. Inside the reused method, self is the object that received the call—not the module where the method was written.

Hooks can combine both ideas, but a beginner-facing design often stays clearer with an explicit include InstanceMethods and extend ClassMethods. A module should express one coherent capability; using it only to avoid typing a few unrelated methods hides dependencies rather than improving design.

Code Example

module Greeting
  def greet
    "hello from #{self.class}"
  end
end

class Member
  include Greeting
end
Member.new.greet             # => 'hello from Member'

class Team
  extend Greeting
end
Team.greet                   # => 'hello from Class'

guest = Object.new
guest.extend(Greeting)
guest.greet                  # only guest gained this method

Common Mistakes & Pitfalls

Using include when you wanted class methods (use extend), or expecting extend to affect instances.