#metaclasses

Python: Metaclasses all the way down

I have an esoteric question involving Python metaclasses. I am creating a Python package for web-server-side code that will make it easy to access arbitrary Python classes via client-side proxies. My proxy-generating code needs a catalog of all of the Python classes that I want to include in my API. To create this catalog, I am using the __metaclass__special attribute to put a hook into the…

That's something I've always been wondering and I guess it kind of fits the theme. So let's find out.

As always, we can start with the Wikipedia article:

In object-oriented programming, a metaclass is a class whose instances are classes. Just as an ordinary class defines the behavior of certain objects, a metaclass defines the behavior of certain classes and their instances.

Okay, so it allows you to specify various stuff about how a class works. But why isn't your grandma's plain old class definition enough for that?

(In the following, I'll focus on Python as the object-oriented language; this might well apply elsewhere too.)

Well, first of all, consistency of the type system. Since everything is an object, that 'everything' can be taken to include the class itself (for example, what is the type of obj.__class__  when obj is an object? It's the class of the object's class - the metaclass. 

What is it good for? Well, you can dynamically, at runtime change an object's metaclass. That means you can basically rewrite the object's definition - one can imagine a specially crafted metaclass that just wraps around each of the original class's methods, but additionally prints out their names just before being called. Bam, logging. For any class you receive. Automagically. And so meta.

That being said, metaclasses appear to have a bad reputation. They can be quite powerful, but they're generally only used in libraries. As Tim Peters, famous in Python circles puts it:

Metaclasses are deeper magic than 99% of users should ever worry about. If you wonder whether you need them, you don't.

For additional reading check out:

Metaclasses in Five Minutes

Sometimes it's good to go back to the basics. One thing we deal daily with are objects. We all know what they are, we manipulate them, we pass them around. They are really cool, they answer our questions, perform some stuff for us, and once we don't need them anymore, we just leave them there and don't bother calling them anymore, and since the world is a cruel place, they even get collected by that garbage collector guy...

But what really are objects, beyond that conceptual entity? Why does an object respond to method calls? How can it know it's own state? Why do we talk about "object-oriented" in some cases, and about "class-oriented" in some other? What's a meta-object? How about a meta-class? Oh boy so many questions!

Since I've found so many great resources online, I'm mainly going to refer to these.

If you want to know what is object-oriented programming, I would suggest to start by reading that great resource explaining the Smalltalk Object Model. Smalltalk has one of the purest implementation of object-oriented programming to date. Ruby is directly inspired from Smalltalk, and you'll be surprised to see how they look alike.

From there, it's said that:

An object is an encapsulated software component made up of memory and operations that creates a coherent programming entity. All objects are an instance of a class. Everything in Smalltalk is an object-from numbers to entire applications. Objects have public and private properties. An object's implementation details are private and are hidden from other objects. An object's public properties are its messages that make up its interface. The object's private properties are its variables. Interaction with an object only occurs via these messages to its interface. All object instancesof a given class have a common message interface.

The Ruby Object Model is a recording from Dave Thomas' talk about Objects in Ruby.

So what's an object?

It's an entity with a state (instance variable) and behaviors (methods). This concept is the same no matter what OO programing language you are dealing with. An object is always something that is composed of methods and data. It is an instance of a class.

What's a class?

In a pure object-oriented language, a class is an object. It is an instance of a class. The class that defines a class is called a meta-class. A class defines the behavior and state of the objects it represents. In Ruby, I like to see a class as a factory that has a method to create new objects. Since a class creates other objects, it is called a meta-object.

What is a method call?

In pure object-oriented languages, there are no such things as lonely methods. They are all bound to an object. This is the case in Ruby, all methods belong to an object, not to a class. A class is a placeholder for the methods its objects implement. Each objects of a class share the same methods, however, and this is a crucial point: each method of an object is bound to one, and only one instance.

duck.quack

Here we're calling duck's quack method. If you feel wordy, you could also say that you call the quack method defined by the 'Duck' class on the duck instance.

One step further: what's a meta-object protocol?

It is an API build in the language to allow manipulating its object model. I just talked about method call, and with a MOP, it is possible re-define that. One could also redefine other concepts such as inheritance (and maybe take it off!).

Not every language offer a MOP API, but they all define an implicit MOP. It's simply how the language handles object-oriented under the hood. Ruby doesn't implement a MOP API. With a MOP, we could for example implement Aspect-Oriented paradigm into our language. More: Does Ruby have a Metaobject protocol and if not, is it possible to implement one?

How about metaclasses?

In Ruby just like anywhere else, it's only a class that defines a class. However, Ruby defines another concept that doesn't officially have a name but that people refer to as eigenclass or singleton class. A singleton class is an anonymous class that defines a single instance (thus the name).

For more on the subject I recommend reading Why's Seeing Metaclasses clearly.

So what's the difference between Object-Oriented and Class-Oriented?

The best answer I've seen so far comes from this link. The idea is that in class-oriented languages, you need to use inheritance to use polymorphism or to artificially represent related objects. The difference is also closely related to the difference between the dynamically typed and statically typed world.

Other great sources of information: