Learning Ruby via IronRuby and C# Part 1

Click here to view the entire IronRuby via C# series

In a previous post I explained how to get Iron Ruby up and running and then in another post I explained how to run an app in IronRuby. If you haven’t checked those out, then go do so!

So, if you are like many C# developers you have probably been hearing a lot recently about dynamic languages like Ruby and Python. And most likely, if you are a web developer, you have used a dynamic language. And by that I am talking about Javascript. So, if Javascript is a dynamic language you may be wondering what the big deal is. If you are like many C# developers, it is likely that you aren’t a fan of Javascript. And there are certainly many reasons for this, but I think that they are mostly because of differing implementations across browsers, and the fact that the programming paradigm is so different from what we are used to.

Ruby doesn’t have these problems. Ruby has a standard implementation which IronRuby is aiming at matching and Ruby operates in similar object oriented fashion that C# does as well. Hopefully in this series I am going to show you how to take some of your C# skills and show you how those can translate into Ruby. At the same time I hope you’ll see the power of Ruby and where Ruby might fit into your toolset.

Also, I am not a Ruby expert and I want you to know that this is going to be a learning experience for me as well as for you. If I do something poorly or do something completely wrong, then please feel free to call me out and I’ll get it fixed!

Before we start, what does it mean for a language to be dynamic? A dynamic language is generally just a language that runs in an interpreted environment, and does most things at runtime that static languages do at compile time. Because of this, the program is generally free to modify itself by running. Most people refer to this ability as Metaprogramming. Now, calling a language dynamic may be a little fuzzy, but I think that you’ll start to understand a bit better as we delve deeper into Ruby.

But let us first start off with the basics. And you really can’t get any more simple than variables. In C# a local variable declaration looks like this:

int count = 1;

You have the type, identifier, and then the value. In Ruby you just have this:

count = 1

As you can see, it is completely missing any type information. This is due to the fact that not only is Ruby a dynamic language, it is also dynamically typed. This means that all types are implicit. Since we assigned “1” to the “count” variable it became a number, if we were to assign “abc” to it, then it would become a string. Like this:

count = 1
count = "abc"

This code in Ruby is completely valid. We can reassign this variable’s type as we see fit. Whether this is good practice or not is another story. Now, in C# everything is forced inside of classes, but in Ruby we don’t have to do this. So, Ruby needs global variables, so that files can access variables in other files. This is done like this:

$count = 1

The dollar sign designates that this is global. Ruby follows this idiom of using prefixes as access modifiers. Now, the next two types of variables we are going to talk about are in terms of classes, so I am going to show you real quick how to declare classes in Ruby. But first in C# we are going to declare a Person class:

public class Person
{
}

In Ruby this would look like this:

class Person

end

In C# we can declare two types of variables within a class, instance and static. As you know instance variables store a unique value within each class instance, while static variables declare a single values for all instances of a type. In C# these look like this:

public class Person
{
    protected int count;
    protected static int count2;
}

In Ruby these will look like this (One note is that Ruby static variables are usually referred to as “class variables”):

class Person
    @count
    @@count
end

One thing that you will also notice is that we have no types on the Ruby variables. This is because Ruby class and instance variables are, by design, not accessible from outside of the class. I used protected in the C# version because all ruby instance variables are accessible from descendant classes, there really is no private instance or class variables in Ruby. In order to get at these variables outside the class you have to specify methods to get or set these values. Now, this may sound like a pain and even give you Java flashbacks, but fear not, Ruby provides easy ways to do this. Just like in C# 3.0 we finally have our wonderful automatic properties:

public class Person
{
    public int Count { get; set; }
    public static int Count2 { get; set; }
}

Ruby provides a method that allows us to define “properties” called “attr_accessor” which only works for instance variables:

class Person
    attr_accessor :count
    @@count2 = 0

    def count2
        @@count2
    end

    def count2=(value)
        @@count2 = value
    end
end

So, you can see that we have defined methods to access our static variable, but we only need one line to declare our instance variable and methods to get and set it. One thing you may have noticed is that next to our “attr_accessor” the word “count” has a colon next to it. This is what in Ruby is called a symbol. It just allows us to assign pass a name around. In this case “attr_accessor” is simply a method that we are passing a symbol to. This method then creates an instance variable with the name of the symbol and get and set methods with the same name. The same could be done by passing a string in, only it would be much less efficient.

I think I am going to stop there for the night. You should know by now how to declare a variable, class, and variables inside classes. In the next post we will start to flesh out our class a bit more and do some operations on the data that we have defined.