RUBY (PROGRAMMING LANGUAGE)

'Ruby' is a reflective, dynamic, object-oriented programming language. It combines syntax inspired by Perl with Smalltalk-like object-oriented features, and also shares some features with Python, Lisp, Dylan, and CLU. Ruby is a single-pass interpreted language. Its official implementation is free software written in C.

Contents

History

Philosophy

Semantics

Features

Interaction

Syntax

"Gotchas"

Language comparison

Language features

Examples

Collections

Blocks and iterators

Classes

Exceptions

More examples

Implementations

Operating systems

Licensing terms

Criticism

Repositories and libraries

References

See also

External links

History

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. "Ruby" was named as a gemstone because of a joke within Matsumoto's circle of friends alluding to Perl's name ^[1].
As of March 2007, the latest stable version is 1.8.6. Ruby 1.9 (with some major changes) is also in development. Performance differences between the current Ruby implementation and other more entrenched programming languages has led to the development of several virtual machines for Ruby. These include JRuby, a port of Ruby to the Java platform, IronRuby, an implementation for the .NET Framework produced by Microsoft, and Rubinius, an interpreter modeled after self-hosting Smalltalk virtual machines. The main developers have thrown their weight behind the virtual machine provided by the YARV project, which was merged into the Ruby source tree on 31 December 2006, and will be released as Ruby 2.0.

Philosophy

The language's creator has said that Ruby is designed for programmer productivity and fun, following the principles of good user interface design.^[2] He stresses that systems design needs to emphasize human, rather than computer, needs ^[3]:
Ruby is said to follow the principle of least surprise (POLS), meaning that the language should behave in such a way as to minimize confusion for experienced users. Matz has said his primary design goal was to make a language that he himself enjoyed using, by minimizing programmer work and possible confusion. He has said he hadn't applied the principle of least surprise to the design of Ruby,^[3] but nevertheless the phrase has come to be closely associated with the Ruby programming language. The phrase has itself been a source of surprise, as novice users may take it to mean that Ruby's behaviors try to closely match behaviors familiar from other languages. In a May 2005 discussion on the comp.lang.ruby newsgroup, Matz attempts to distance Ruby from POLS, explaining that since any design choice will be surprising to someone, he uses a personal standard in evaluating surprise. If that personal standard remains consistent there will be few surprises for those familiar with the standard. [1]
Matz defined it this way in an interview [2]:

Semantics

Ruby is object-oriented: every data type is an object, including even classes and types that many other languages designate as primitives (such as integers, booleans, and "nil"). Every function is a method. Named values (variables) always designate references to objects, not the objects themselves. Ruby supports inheritance with dynamic dispatch, mixins and singleton methods (belonging to, and defined for, a single instance rather than being defined on the class). Though Ruby does not support multiple inheritance, classes can import modules as mixins. Procedural syntax is supported, but all methods defined outside of the scope of a particular object are actually methods of the Object class. Since this class is parent to every other class, the changes become visible to all classes and objects.
Ruby has been described as a multi-paradigm programming language: it allows procedural programming (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 support for introspection, reflection and metaprogramming, as well as support for threads^[5]. Ruby features dynamic typing, and supports parametric polymorphism.
According to the Ruby FAQ ^[6], "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." ^[7]

Features

★ object-oriented

★ four levels of variable scope: global, class, instance, and local

★ 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

★ highly portable

★ cooperative multi-threading on all platforms using Green threads

★ DLL/shared library dynamic loading on most platforms

★ introspection, reflection and metaprogramming

★ large standard library

★ supports dependency injection

★ continuations and generators (examples in RubyGarden: continuations and generators)
Ruby currently lacks full support for Unicode, though it has partial support for UTF-8.

Interaction

The Ruby official distribution also includes "irb", an interactive command-line interpreter which can be used to test code quickly. The following code fragment represents a sample session using irb:

$ irb
irb(main):001:0> puts "Hello, World"
Hello, World
=> nil
irb(main):002:0> 1+2
=> 3

Syntax

The syntax of Ruby is broadly similar to Perl and Python. Class and method definitions are signaled by keywords. In contrast to Perl, variables are not obligatorily prefixed with a sigil. When used, the sigil changes the semantics of scope of the variable. The most striking difference from C and Perl is that keywords are typically used to define logical code blocks, without braces (i.e., pair of { and }). Line breaks are significant and taken as the end of a statement; a semicolon may be equivalently used. Unlike Python, indentation is not significant.
One of the differences of Ruby compared to Python and Perl is that Ruby keeps all of its instance variables completely private to the class and only exposes them through accessor methods (attr_writer, attr_reader, etc). Unlike the "getter" and "setter" methods of other languages like C++ or Java, accessor methods in Ruby can be written with a single line of code. As invocation of these methods does not require the use of parentheses, it is trivial to change an instance variable into a full function, without modifying a single line of code or having to do any refactoring achieving similar functionality to C# and VB.NET property members. Python's property descriptors are similar, but come with a tradeoff in the development process. If one begins in Python by using a publicly exposed instance variable and later changes the implementation to use a private instance variable exposed through a property descriptor, code internal to the class may need to be adjusted to use the private variable rather than the public property. Ruby removes this design decision by forcing all instance variables to be private, but also provides a simple way to declare set and get methods. This is in keeping with the idea that in Ruby, one never directly accesses the internal members of a class from outside of it. Rather one passes a message to the class and receives a response.
See the ''examples'' section for samples of code demonstrating Ruby syntax.

"Gotchas"

Language comparison

Some features that differ notably from languages such as C or Perl:

★ Names that begin with a capital letter are treated as constants, so local variables should begin with a lowercase letter.

★ The symbols $ @ are not sigils as in Perl, but rather function as scope resolution operators.

★ To denote floating point numbers, one must follow with a zero digit (99.0) or an explicit conversion (99.to_f). It is insufficient to append a dot (99.) because numbers are susceptible to method syntax.

★ Boolean evaluation of non-boolean data is strict: 0, "" and [] are all evaluated to ''true''. In C, the expression 0 ? 1 : 0 evaluates to 0 (i.e. false). In Ruby, however, it yields 1, as all numbers evaluate to true; only nil and false evaluate to ''false''. A corollary to this rule is that Ruby methods by convention — for example, regular-expression searches — return numbers, strings, lists, or other non-false values on success, but nil on failure (e.g., mismatch). This convention is also used in Smalltalk, where only the special objects true and false can be used in a boolean expression.

★ Versions prior to 1.9 lack a character data type (compare to C, which provides type char for characters). This may cause surprises when slicing strings: "abc"[0] yields 97 (an integer, representing the ASCII code of the first character in the string); to obtain "a" use "abc"[0,1] (a substring of length 1) or "abc"[0].chr.

★ The notation "statement until expression", despite the English-language implication that the statement would be executed at least once, which follows the precedent used in other languages' equivalent statements (e.g. "do { statement } while (not(expression));" in C/C++/...), actually never runs the statement if the expression is already true.

★ Because constants are references to objects, changing what a constant refers to generates a warning, but modifying the object itself does not. For example, if Greeting = "Hello" then Greeting << " world!" does not generate an error or warning.

Language features

★ In terms of speed, Ruby's performance is inferior to that of many compiled languages (as is any interpreted language) and other major scripting languages such as Python and Perl^[8]. However, in future releases (current revision: 1.9), Ruby will be bytecode compiled to be executed on YARV (''Yet Another Ruby VM''). Currently, Ruby's memory footprint for the same operations is higher than Perl's and Python's.⁸

★ Omission of parentheses around method arguments may lead to unexpected results if the methods take multiple parameters. Note that the Ruby developers have stated that omission of parentheses on multi-parameter methods may be disallowed in future Ruby versions. Much existing literature, however, encourages parenthesis omission for single-argument methods.
A list of "gotchas" may be found in Hal Fulton's book ''The Ruby Way'', 2nd ed (ISBN 0-672-32884-4), Section 1.5. A similar list in the 1st edition pertained to an older version of Ruby (version 1.6), some problems of which have been fixed in the meantime. retry, for example, now works with while, until, and for, as well as iterators.

Examples

Classic Hello world example:

puts "Hello World!"

Some basic Ruby code:

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

Collections

Constructing and using an array:

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