Liquid Development

My fellow socialite Pilu has opened a blog, Gurage, where he provides an introductive examples to Rails.  He uses a simple inheritance example describing a Guitarist and a Singer as being two subclasses of Artist.

While reading his code, that describes a Struct-like class (more an holder of attributes than an holder of behaviours) I thought back to a discussion that we had at the Ruby Social Club meeting about metaprogramming tricks.  My point was that through metaprogramming you can redefine the language in such a way that you can also provide stereotypical descriptions for classes and methods, so that you don't have to explicitly describe initializer, accessors, and so on.

For example, this code written by Pilu

class Artist
  attr_reader :name
  def initialize(name)
    @name = name
  end
end

could easily become something like:

Artist = Struct.new :name

This second form is no doubt more compact, but is it better?

Forget the fact that the full class definition already provides the 'space' to add in new methods and attributes. Assume that the code is done and you are simply reading it.  What is better? and why?

Something tells me that I would like the more terse and compact form, but somehow I still find that the first form has got something that the compact form lacks. I just can't put my finger on it.

Following on from Pilu's example I would like to have a compact formalism that allows me to say something like:

Artist defined by name

Guitarist is an Artist also defined by guitar
Singer is an Artist also defined by microphone

Using metaprogramming is not too hard to generate this kind of Minimal Descriptions, although they would probably look like this:

Artist = defined_by :name

Guitarist = Artist.also_defined_by :guitar
Singer = Artist.also_defined_by :microphone

 
I will leave the metaprogramming as an exercise for the reader :-D

The 'defined_by' is just wrapping a call to ' Struct.new', probably also adding a few extras such as a comparison operator and a prettier to_s method.  The 'also_defined_by' is a method that has been injected into the Class class.  It creates a new anonymous subclass, adding a few extra accessors and also overriding the initializer by adding some extra parameters.

We have seen how this is technically feasible, I just wonder if this is what we want. 

The standard way of doing things shows us explicitly that we are dealing with a class.  The 'class' and the 'end' words and the indentation highlight clearly a  chunk of code and identifies it as being a class, an important  concept within the narrative of our system.

The Minimal Description approach tries to hide away the whole concept of class.  It simply cares about concepts and meaning and it abstracts away a big body of knowledge.  The body of knowledge that is abstracted away  is that we are defining classes and that these classes are related by inheritance.  It is also assuming that we know that if something is defined by a certain characteristic, then this characteristic will have to be used when creating an instance of that concept.

What do you think?  Is this a rightful use of metaprogramming and of Shaping code After Language, or is it a blatant abuse of metaprogramming power?