The document provides an introduction to the Ruby Object Model, explaining that Ruby is an object-oriented language where everything, including classes and primitive types, is represented as objects. It details the internal structure of objects and classes in Ruby, describing how instance variables, methods, and classes are organized and represented through various structures. Additionally, it covers the use of modules as mixins for adding functionality to classes and the differences between extending and including modules.

1. Introduction to the
Ruby Object Model

2. Ruby is an object
oriented language

3. Primitives
182376
“hello, world”
[1, 2, 3]
Objects
String: “x”
object_id: 2817249
#length, #upcase, #..
Object
@name = “Peter”
@age = 30
object_id: 2132452
Array: [., .]
object_id: 2132452
#next, #size, #..

4. An Object
@name = “Peter”
@age = 30
#name=(name)
#name
#age=(age)
#age
Data
Methods
class: User
object_id: 2132452

5. In Ruby: everything (well, almost
everything) is an object:
• Classes
• “Primitive types”
• Modules (will be explained later on)
• Procs

6. ‘a’.upcase # => ‘A’
‘a’.class # => String

7. 10.class # => Fixnum

8. class Fixnum
def +(other)
42
end
end
10 + 10 # => 42 (!)

9. Fixnum.class # => Class
Class.class # => Class

10. my_class = Class.new
my_obj = my_class.new

11. The “Ruby Object Model”

12. How Objects Are
Represented Internally

13. struct RObject {
struct RBasic basic;
long numiv;
VALUE *ivptr;
struct st_table *iv_index_tbl;
};
Number of
instance variables
Instance variables array
@name = “Fred”
@age = 23
Essentially a hash of
{ name -> index into ivptr }

14. struct RBasic {
VALUE flags;
VALUE klass;
};
Stores information like
whether the object is
frozen, tainted or others
Reference to
whatever the class
of the object is

15. An object has:
• Klass (parent class)
• Flags (frozen? tainted? etc.)
• Instance variables
• Nothing else.

16. How Classes Are
Represented Internally

17. struct RClass {
struct RBasic basic;
rb_classext_t *ptr;
struct st_table *m_tbl;
struct st_table *iv_index_tbl;
};
struct rb_classext_struct {
VALUE super;
struct st_table *iv_tbl;
struct st_table *const_tbl;
};
Additional class
info
Methods
Instance
variables
Reference
to superclass
Instance
variables
Constants

18. struct RClass {
VALUE flags;
VALUE klass;
VALUE super;
struct st_table *iv_tbl;
struct st_table *const_tbl;
struct st_table *m_tbl;
struct st_table *iv_index_tbl;
};
Reference
to superclass
Instance
variables
Constants
Methods
Instance
variables

19. class Oban < Scotch
AGE = 14
@tasty = true
def tasty
Oban.instance_variable_get("@tasty")
end
end

20. class Oban < Scotch
AGE = 14
@tasty = true
def tasty
Oban.instance_variable_get("@tasty")
end
end
basic.klass Class
ptr->super Scotch
iv_tbl { “@tasty” => true }
const_tbl { “AGE” = 14 }
m_tbl { “tasty” => … }

21. Enough with the C
code!

22. RObject and RClass
flags
RObject
class reference
instance variables
@age = 10
@name = “Peter”
flags
RClass
class reference
instance variables
methods table
reference to ‘superclass’
constants table
These three are extra to classes

23. class User
def name=(name)
@name = name
end
def name
@name
end
end

24. User (RClass)
class reference
class instance variables
methods table
#name=
#name
reference to ‘superclass’
Class (RClass)
class reference
Object (RClass)
class reference

25. class User
def name=(name)
@name = name
end
def name
@name
end
end
me = User.new

26. User (RClass)
methods table
#name=
#name
RObject
class reference
instance variables

27. User (RClass)
methods table
#name=
#name
RObject
class reference
instance variables
@name => “Peter Cooper”
me.name = “Peter Cooper”

28. class User
def status
:admin
end
end

29. User (RClass)
methods table
#name=
#name
#status
RObject
class reference
instance variables
@name => “Peter Cooper”

30. me = User.new
you = User.new
def me.age
30
end
me.age # => ?
you.age # => ?

31. me = User.new
you = User.new
def me.age
30
end
me.age # => 30
you.age # => NoMethodError

32. User (RClass)
methods table
#name=
#name
RObject
Me
class reference
RObject
You
class reference
.. but where does
me.age go?

33. User (RClass)
methods table
#name=
#name
RObject
Me
class reference
methods table
#age
RObject
You
class reference
*me (RClass)
singleton class

34. RObject
Me
class reference
RObject
You
class reference
*me (RClass)
methods table
#age
superclass
User (RClass)
methods table
#name=
#name

35. me.class # => User

36. “Class Methods”

37. class User
def self.plural_name
“users”
end
end
User.plural_name # => “users”
me.plural_name # => NoMethodError
you.plural_name # => NoMethodError

38. User (RClass)
superclass
methods table
#name=
#name
klass
Class (RClass)
*User (RClass)
methods table
#plural_name
klass
Object (RClass)

39. User (RClass)
superclass
methods table
#name=
#name
klass
Object (RClass) Conclusion:
All methods in Ruby
instance methods!
Class (RClass)
are actually
*User (RClass)
methods table
#plural_name
klass

40. Modules
“Collection of methods
and constants”

41. module MyModule
PI = 3.141592
def some_method
puts "Hello, world!"
end
end
MyModule::PI # => 3.141592 (yay!)
MyModule.some_method # => NoMethodError (eh!?)

42. class User
include MyModule
end
Using modules as “mixins"
me.some_method # => “Hello, world!”

43. class User
include MyModule
end
Using modules as “mixins"
“Mixing in” functionality
into an existing class
me.some_method # => “Hello, world!”

44. Using modules as function grouping in a
namespace (helper/utility classes)
module MyModule
def self.some_method
puts “Hello, world!”
end
end
MyModule.some_method # => “Hello, world!”

45. Math.cos(10)

46. module NamingMethods
def name=(name)
@name = name
end
def name
@name
end
end
class User
include NamingMethods
end
me = User.new
me.name = “Fred”
p me.name

47. module NamingMethods
def name=(name)
@name = name
end
def name
@name
end
end
Can anybody guess
what’s going on
behind the scenes?
class User
include NamingMethods
end
me = User.new
me.name = “Fred”
p me.name

48. User (RClass)
superclass
methods table
#name=
#name
Object (RClass)
NamingMethods (RModule)
methods table
#name=
#name
#hello

49. superclass
User (RClass)
superclass
methods table
#name=
#name
Object (RClass)
NamingMethods (RModule)
methods table
#name=
#name
#hello
NamingMethods (IClass)
methods table

50. “extend” vs “include”

51. module ClassMethods
def hello
42
end
end
class User
extend ClassMethods
end
p User.hello # => 42

52. module SingletonMethods
def hello
42
end
end
str = “hello”
str.extend SingletonMethods
p str.hello # => 42

53. module MyFunctionality
def instance_meth
puts “I’m an instance method”
end
def self.included(klass)
klass.extend ClassMethods
end
module ClassMethods
def class_meth
puts “I’m a class method”
end
end
end
class MyClass
include MyFunctionality
end
p MyClass.class_meth # => “I’m a class method”
p MyClass.new.instance_meth # => “I’m an instance method”

54. superclass
MyClass (RClass)
superclass
Object (RClass)
MyFunctionality (RModule)
methods table
#instance_meth
(IClass)
methods table
klass
*(IClass)
superclass
methods table
MyFunctionality::ClassMethods
methods table
#class_meth
(RModule)