Klank Boom Klang

This post continues to look at Ruby Modules and their properties.
It’s possible to mix a Module into a second Module which can then be mixed into a class. The result is that an entire Module chain is moved into the a classes inheritance chain with one call to include.

module OneStrand
end

module TwoStrand
include OneStrand
end

class […]

Modules in Ruby serve two purposes. One is to provide namespace scope for code organization seen in the syntax Test::Unit::TestCase, where TestCase is a class defined inside of the Unit module, which is in turn defined within the Test module. The second purpose of modules is to provide a method for code reuse […]

In my last post I wrote that providing a home for class methods was the raison d’être of the Metaclass. So why go through all the trouble? What are class methods good for? Four uses worth exploring are Object Creation, Annotations, DSL’s, and removal of structural duplication
This post is about Ruby class […]

If you search around the web a bit, you are sure to find the Ruby Metaclass defined as “The singleton class of a class.” While this definition is accurate, it doesn’t contribute to an understanding of why Metaclasses exist. It is also guilty of underplaying some notable difference between Metaclasses and “normal” Singleton […]

It interesting that Ruby, a language which allows you to so easily bypass encapsulation, encapsulates it’s own internals to the point of occasional prevarication. Heres an example…

pirate = Object.new
def pirate.speak
“Yarrrr”
end
pirate.class == Object.new.class
#=> true

In my last post I explained how the code above forces the interpreter to assign a newly created Singleton class to the […]

There’s no shortage of literature on singleton classes, but it’s rare to see an explanation that covers implementation. This is unfortunate, as the implementation is not complex and familiarity with it leads to a more nuanced understanding.
A good way to look at singleton classes is to ask the question, “What is it that Ruby […]

A good understanding of method dispatch can help in deciphering some of the odder corners of the Ruby object model. Luckily, method dispatch is not only straight forward, but entirely consistent for “normal” methods, singleton methods, and module methods.
In Matz’s Ruby Interpreter (MRI), method bodies are stored in a struct devoted to representing […]