Here’s another ruby-ism that wasn’t obvious to me at first. In C#, I might have a class that took several parameters in the constructor, and I would need to save those values in some private member variables. My code always looked something like this:

// C# code
class Team
{
    private Schedule schedule; // reference to a Schedule object
    private string name;
    private string city;

    public Team(string name, string city, Schedule schedule)
    {
        this.name = name;
        this.city = city;
        this.schedule = schedule;
    }

}

I’ve done this thousands of times, and it seemed easy enough to me that I never thought about how it could ever be any better. But actually I was just a mouse who’d been trained to run through a maze if I wanted some cheese. Look at the Ruby equivalent:

class Team

  def initialize(name, city, schedule)
    @name, @city, @schedule = name, city, schedule
  end

end

Here I’ve taken advantage of Ruby’s multiple assignment feature to quickly initialize everything.

Also, behold the following… let’s say the name, city, and schedule should be read-only properties of my class. Let’s run through another maze:

// C# code 
class Team
{
   private Schedule schedule; // reference to a Schedule object
    private string name;
    private string city;

    public Team(string name, string city, Schedule schedule)
    {
        this.name = name;
        this.city = city;
        this.schedule = schedule;
    }

    public string Name
    {
        get { return name; }
    }

    public string City
    {
        get { return city; }
    }

    public Schedule Schedule
    {
        get { return schedule; }
    }
}

And the ruby equivalent:

class Team

  attr_reader :name, :city, :schedule

  def initialize(name, city, schedule)
    @name, @city, @schedule = name, city, schedule
  end

end

Sure feels good to get out of that rat race.