The language was created by Yukihiro "Matz" Matsumoto, who started working on Ruby on February 24, 1993 and released it to the public in 1995. He chose the name to reflect the language's Perl heritage. This is evident in that rubies and pearls are both jewels and that the pearl is the birthstone of June while the ruby is the birthstone of July (implying progression). According to the author, he designed Ruby to follow the principle of least surprise, meaning that the language should be free from the traps and inconsistencies that plague other languages. As of March 2005, the latest stable version is 1.8.2.

Philosophy

Ruby is object-oriented: every bit of data is an object, including types other languages designate primitive such as integers. Every function is a method. Named values (variables) designate references to objects, not the objects themselves. Ruby supports inheritance with dynamic dispatch, mixins and singleton methods (belonging to a class rather than an instance). Though Ruby does not support multiple inheritance, classes can import modules as mixins. Procedural syntax is included, but everything done in Ruby procedurally (i.e., outside of the scope of a particular object) is actually done to the Object class. Since this class is parent to every other class, the changes become visible to all classes and objects.

Ruby has also been described as a multi-paradigm programming language: it allows you to program procedurally (defining functions/variables outside classes makes them part of the root, 'self' Object), with object orientation (everything is an object) or functionally (it has anonymous functions, closures, and continuations; statements all have values, and functions return the last evaluation). It has rich support for introspection, reflection and meta-programming.

According to the Ruby FAQ, "If you like Perl, you will like Ruby and be right at home with its syntax. If you like Smalltalk, you will like Ruby and be right at home with its semantics. If you like Python, you may or may not be put off by the huge difference in design philosophy between Python and Ruby/Perl."

Implementations

Ruby has two main implementations: the official Ruby interpreter, which is the most widely used, and JRuby, a Java-based implementation. The former has been ported to many platforms, including Unix, Microsoft Windows, DOS, Mac OS X, OS/2, Amiga and many more. The Ruby distribution also includes "IRB", an interactive command-line interpreter which can be used to test code quickly.

Licensing terms

Ruby is distributed disjointedly under the free and open source licenses GPL and Ruby License [1].

Features

object-oriented
exception handling
iterators and closures (based on passing blocks of code)
native, Perl-like regular expressions at the language level
operator overloading
automatic garbage collecting
multi-threading on all platforms
DLL/Shared Library dynamic loading on most platforms.
introspection, reflection and meta-programming
large standard library
supports dependency injection
continuations and generators (for examples see: http://www.rubygarden.org/ruby?Continuations and http://www.rubygarden.org/ruby?RubyFromPython respectively)

Ruby currently lacks support for Unicode, though it has partial support for UTF-8.

Possible surprises

Although Ruby's design has been guided by the principle of least surprise, naturally there are features differing from languages such as C or Perl:

Local variable names may not begin with a capital letter, otherwise they are treated as constants.
0, "" and [] are true: In C, the expression 0 ? 1 : 0 is evaluated as 0. In Ruby, however, it yields 1. Reasoning: In Ruby, many expressions (e.g., regular expression tests) return either a numeric value, string or array, or "nil". When such a return value is evaluated in a boolean context, only "nil" is evaluated as "false": every numeric (string or array) value, including zero (0, empty string, "", or array, []) is considered "true". Coincidently, as in Java, C- and Perl-style automatic conversion from numerics, strings and arrays to boolean "false" does not work.
To indicate floating point numbers, it is insufficient to append a dot (99.). Because numbers are susceptible to method syntax, one must follow with a zero digit (99.0) or an explicit conversion (99.to_f).
There is no character (char) data type. This may cause surprises when slicing strings: "abc"[0] yields 97 (an integer, representing the ASCII code of the first character in the string); use "abc"[0,1] to obtain "a" (a substring of length 1).

Maybe the best "Gotcha list" is to be found in Hal Fulton's book The Ruby Way, pages 48-64. There are a fair number of things to get used to if one is used to Perl, Python, Java, or Smalltalk. However, the list in the book pertains to Ruby 1.6, and some items have changed in Ruby 1.8 and later. For example, retry now works with while, until and for, as well as iterators.

Examples

Some basic Ruby code:

# Everything, including literals, is an object, so this works:
-199.abs                                       # 199
"ruby is cool".length                          # 12
"Rick".index("c")                              # 2
"Nice Day Isn't It?".split(//).uniq.sort.join  # " '?DINaceinsty"

Collections

Constructing and using an array:

a = [1, 'hi', 3.14, 1, 2, [4, 5]]

a[2]                      # 3.14
a.reverse                 # [[4, 5], 2, 1, 3.14, "hi", 1]
a.flatten.uniq            # [1, "hi", 3.14, 2, 4, 5]

Constructing and using a hash:

hash = {'water' => 'wet', 'fire' => 'hot'}
puts hash['fire']        

hash.each_pair do |key, value| 
  puts "#{key} is #{value}"
end

# Prints:             water is wet
#                     fire is hot

hash.delete_if {|key, value| key == 'water'}   # Deletes 'water' => 'wet'

Blocks and iterators

The two syntaxes for creating a code block:

{ puts "Hello, World!" }

do puts "Hello, World!" end

Passing a block as a parameter (to be a closure):

def remember(&p)
  @block = p
end
# Invoke the method, giving it a block that takes a name.
remember {|name| puts "Hello, " + name + "!"}

# When the time is right -- call the closure!
@block.call("Johnny")
# Prints "Hello, Johnny!"

Iterating over enumerations and arrays using blocks:

a = [1, 'hi', 3.14]
a.each {|item| puts item}          # Prints each element
(3..6).each {|num| puts num}       # Prints the numbers 3 through 6

Blocks work with many built-in methods:

IO.readlines('file.txt') do |line|
  # Process each line, here.
end

Using an enumeration and a block to square 1 to 10:

(1..10).collect {|x| x*x}    => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Classes

The following code defines a class named Person. In addition to 'initialize', the usual constructor to create new objects, it has two methods: one to override the <=> comparison operator (so Array#sort can sort by age) and the other to override the to_s method (so Kernel#puts can format its output). Here, "attr_reader" is an example of meta-programming in Ruby: "attr" defines getter and setter methods of instance variables; "attr_reader": only getter methods.

class Person
  def initialize(name, age)
    @name, @age = name, age
  end

  def <=>(person)
    @age <=> person.age
  end

  def to_s
    "#{@name} (#{@age})"
  end

  attr_reader :name, :age
end

group = [ Person.new("John", 20), 
          Person.new("Markus", 63), 
          Person.new("Ash", 16) 
        ]

puts group.sort.reverse

The above prints three names in reverse age order:

Markus (63)
John (20)
Ash (16)

More sample Ruby code is available as algorithms in the following articles:

Hello World

puts "Hello World!"

Operating systems

Ruby is available as a port for the following operating systems:

Most flavours of Unix
DOS
Windows 95/98/XP/NT/2000/2003
Mac OS X
BeOS
Amiga
Acorn RISC OS
OS/2
Syllable

Other ports may also exist.

External links

Ruby language home page
Ruby Garden
Programming Ruby—Full text of first edition of the book by David Thomas & Andrew Hunt, ISBN 0-201-71089-7
Why's Poignant Guide to Ruby
Ruby FAQ
Ruby Application Archive (RAA)
JRuby
The Ruby Documentation project
Ruby Forum
RubyForge
RedHanded—Daily Ruby news and more
Ruby on Rails— an open-source web framework for Ruby

Categories: Class-based programming languages | Object-oriented programming languages | Programming languages | Scripting languages