Now, let’s take a closer look to the real things…

OOP in Ruby

First of all, it’s good to have the ri utility. You type

ri Class

and you get a lot of explanations about OO stuff in Ruby. (if you type lowercase class, it will describe the .class property of an object.)

Let’s take a look on that info ri Class returns:

-------------------------------------------------- Class: Class < Module
     Classes in Ruby are first-class objects---each is an instance of
     class +Class+.

     When a new class is created (typically using +class Name ... end+),
     an object of type +Class+ is created and assigned to a global
     constant (+Name+ in this case). When +Name.new+ is called to create
     a new object, the +new+ method in +Class+ is run by default. This
     can be demonstrated by overriding +new+ in +Class+:

        class Class
           alias oldNew  new
           def new(*args)
             print "Creating a new ", self.name, "\n"
             oldNew(*args)
           end
         end

         class Name
         end

         n = Name.new

     _produces:_

        Creating a new Name

The first awesome thing that we can see right here is what seems to be the new overloading. However, I doubt it somehow. Maybe it’s just a clumsy way to write class’ constructor?

Doing a bit of googling, and voila: constructor in Ruby is called initialize() method. Base class can be referred as super — good, that’s OO classics.

Apparently, new overloading is indeed new overloading. It allows you to fake creation of an object, which might depend on new arguments… wait, wait, wait… this thing has a name, and this is an OO feature that doesn’t exist in C++… this, my friends, is VIRTUAL CONSTRUCTOR!!!

Oh my God…

I don’t know whether this is Mr. Matsumoto creation (that’s the guy who created Ruby), or a later one, but I don’t care either. This is absolutely genius thing. Love it. You maybe can live without it, but it come very handy, say, in de-serialization, when you need to re-create the object, but you don’t know which one it would be.

Unless I got it all wrong, it seems that Ruby brings to the table something I’ve never seen in any other programming language. Lovely, lovely thing!

What’s not totally clear to me (yet) is the relationship between Object, Class, and Module. Object seems to be the top super-class of all classes; it’s just the name which is confusing me, probably because of my C++ background. Apparently, in Ruby class instance is not called Object; this name is reserved for the top class.

Built-in Data Structures

Man, data structures ARE important.

I’ve seen so many people who cannot tell the actual difference between an array and a list… not even with hints.

Ok, so I’ve just learned that Ruby has Arrays and Hashes. Arrays are indexed and Hashes have keys. (Perl philosophy, again.) And you can use tags, again, like in Perl — there is only syntactic difference. All straightforward, clear, easy — love it.

What escapes me though is the question mark (?) operator. Maybe I was going too fast through the book, and missed the explanation. Let’s ask my friend Google… wow. It’s just part of the method name. The convention is to put ? at the end of the name of a method which returns boolean. Sort of asking question: is_a? respond_to? kind_of? Quite elegant idea.

Pointers to functions — just like in C

Back to Zed Shaw’s site / book.

Lesson #40 contains an interesting example:

cities = {'CA' => 'San Francisco',
  'MI' => 'Detroit',
  'FL' => 'Jacksonville'}

cities['NY'] = 'New York'
cities['OR'] = 'Portland'

def find_city(map, state)
  if map.include? state
    return map[state]
  else
    return "Not found."
  end
end

# ok pay attention!
cities[:find] = method(:find_city)

while true
  print "State? (ENTER to quit) "
  state = gets.chomp

  break if state.empty?

  # this line is the most important ever! study!
  puts cities[:find].call(cities, state)
end

cities is our little in-memory database of cities. But unlike strongly-typed languages (C, C++, C#), this container (the hash) might contain totally unrelated pieces of data, while the data is of different types and the keys are of different types and so on.

The code on the line 17 (just below the “pay attention” remark) is placing into the hash a new piece of data: pointer to the find_city method. It’s stored now under the key :find (it could be called :finding_method or :boo or whatever).

You are more than welcome to review this example which demonstrates the usage of method pointers (or whatever they are called in Ruby), and which is a cool game, too.

Due to examples it was another long post, I guess…

So, Learning Ruby the Hard Way is apparently quite a useful site. It’s written for absolute beginners, and I”ll try to finish it today, but this is not the point. The author is obviously familiar with bunch of other programming languages, and most examples he’s bringing to reader’s attention are easy to remember as references to Python, C, etc.

E.g. “the syntax of function declarations is Python-ish”, while “file operations are C-ish”, with read and seek etc. And require is PHP-ish. Sort of mishmash, I’d better not confuse which keyword was taken from which language…

Syntax of functions return values is somewhat not obvious though. Old good return would probably do better… but it’s probably easier for new programming students.

So far I’ve learned Ruby supports the concept of modules. Not sure whether this is the only way to do OO in Ruby, but I wouldn’t be surprised. Let’s not rush into conclusions though.

Reading the code

Another lovely thing about that site / book: it’s teaching to read Ruby code. At least it give you couple of exercises on that. This is very useful for beginners, but experts should probably do it from time to time, too. From my experience, many years ago, this was quite hard for us new grads: we knew how to write code, but not really how to read it. It took some experience. Reading your own code is not the same.

Now, this might sound really stupid. Beginners’ katas in martial arts might seem stupid, too.

And the last but not the least, Mr Zed A. Shaw (the author of that book) is calling me a good programmer.

A good programmer assumes, like a good scientist, that there’s always some probability their code is wrong. Good programmers start from the premise that their software is broken and then work to rule out all possible ways it could be wrong before finally admitting that maybe it really is the other guy’s code.

Thank you Zed!

And you, managers and business people — don’t you confuse professionalism with lack of self-confidence!

Back to Ruby

It just escapes me why scripting people dislike STL-style names for list/array manipulation.

push_back/push_front, pop_back/pop_front – are clear, uniform, easy to remember.

push / pop are better; but shift / unshift seem to be originated from Perl’s shift. If you don’t have any previous background… well, who cares indeed.

Ok, I made it through the first half of this book.

Coding the logic: IF-statements

The syntax of logic statements is very concise: no {}, not then‘s, no Python-style colons (the latter, with all due respect to Python, is a bit weird). Reverse if‘s are also possible — it’s Perl feature, and I love it. Same with elsif. These small things actually make you coding faster.

Coding the logic: loops

First, I love for-loop with foreach semantics. It’s just natural. Shame C/C++ doesn’t have it (yea, new release, C++0x/11, I know).

Second, I love the idea of blocks, and this is entirely Ruby idea, for the best of my knowledge.

tools = ['hammer', 'saw', 'drill']
tools.each do |tool|
  puts "My tool: #{tool}"
end

It resembles C# idea of Enumerables; although Ruby was created first from chronological perspective, most of us, I assume, have heard of C# before we’ve heard of Ruby.

Anyway, I could also say:

for tool in tools
  puts "My tool: #{tool}"
end

and the effect would be the same.

for over arrays and while loop are trivial => easy to remember.

Oops’es

No equivalent to Pearl’s die function in Ruby? What is this Process.exit(0) javabberish?!

to_i() – oh my God, this is just a joke! why not to_int()?!

prompt is not exactly designed for programmers productivity… Fortunately, there are good Ruby libraries which allow you writing:

require "highline/import"
input = ask "Input text: "
puts "You entered the following text: "+input

Ah, this is better!

If the above didn’t work, you probably need to install appropriate library — and this is Perl-ish way, again:

sudo gem1.9.1 install highline

or just

sudo gem install highline

depending on your version (I have both 1.8 and 1.9 installed).

I should take a better look on that Highline library, ’cause it’s about saving time, and that’s exactly my intention.

Debugging

Mr. Zed A. Shaw is writing: