Rubarian Notation

I recently bought the book "The Best of Ruby Quiz" by James Edward Gray II. This is a fun little book of simple programs to write in Ruby, and a number of solutions to those programs written by folks in the Ruby community.

The very first problem is a simple game of Mad Libs. As I read trough the solutions at the end of the book, I found that I did not care for any of them.

(What! A programmer who doesn't like what some other programmer has done???)

Don't get me wrong, I thought the solutions were clever, and I learned a lot from them. I just didn't think they were particularly clear or clean. So I decided to see if I could do better. And, of course, I think I did.

That was about three weeks ago. Today I went back to the program I wrote to see if I could clean it up even more. I found that I was tempted to do something very strange. Here's the snippet of code that started that temptation:

  def translate(text)
    questions_and_text = split_questions_from_text(text)
    answers_and_text = replace_questions_with_answers(questions_and_text)
    answers_and_text.join
  end

I looked at this and realized that I didn't remember the type of the variable questions_and_text.

Now, type is an interesting concept in Ruby. Variables don't have a type. Instances do, but variables are simply untyped references to those instances. So what kind of instance was this questions_and_text variable referring to?

I was pretty sure that the instance behind the variable was a simple list of strings. Although "simple" isn't quite the right word. It was a list of strings in which every other string was a mad-libs question. You know, like "verb", or "adjective", or "name of girl in room". So the questions_and_text variable held a list of strings of alternating questions and text.

I didn't want to have to reason this out the next time I read this. So I was strongly tempted to change the name of the variable to list_of_alternating_text_and_questions; but this seemed pretty long to me. So I naturally thought of abbreviating it to ls_alternating_text_questions. The abbreviation made me think that I should come up with a suite of standard abbreviations that helped to indicate the type of a variable. And then I stopped myself.

Now this embarrasing chain of reasoning took less than two or three seconds. But it scared me. I had, in that short space of time, nearly convinced myself that Ruby requires Hungarian Notation!!! Indeed, this thought is still quaking around in my brain. Am I really so bound to statically typed languages that I need to encode the type of a variable in it's name? Or is there a better way?

Of course there is a better way. We should be naming our variables for what we do to them, not for what they contain. That implies that we should create variables that we do things to, rather than variables that simply hold data. Indeed, that's just OO, isn't it?

Stay tuned...

---

!commentForm -r