Ruby programming language

From Freepedia

Ruby is a reflective, object-oriented programming language. It combines syntax inspired by Ada and 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.

Contents

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 after a colleague's birthstone. Appropriately, the name reflects the language's Perl heritage. Pearl is the birthstone of June while the ruby is the birthstone of July (suggesting progression). Although Matsumoto was not aware of it at the time, in typography, pearl and ruby are descriptors in a deprecated hierarchy for type size.

As of September 2005, the latest stable version is 1.8.3. Ruby 1.9 (with some major changes) is also in development.

Philosophy

Matz's primary design consideration is to make programmers happy by reducing the menial work they must do, following the principles of good user interface design.[1] He stresses that systems design needs to emphasize human, rather than computer, needs[2] :

Often people, especially computer engineers, focus on the machines. They think, "By doing this, the machine will run faster. By doing this, the machine will run more effectively. By doing this, the machine will something something something." They are focusing on machines. But in fact we need to focus on humans, on how humans care about doing programming or operating the application of the machines. We are the masters. They are the slaves.

Ruby is said to follow the principle of least surprise (POLS), meaning that the language typically behaves intuitively or as the programmer assumes it should. The phrase did not originate with Matz and, generally speaking, Ruby more closely follows a paradigm best termed as 'Matz' Least Surprise' though, happily, many programmers have found it to be close to their own mental model as well.

Semantics

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, 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 everything done in Ruby procedurally (that is, outside of the scope of a particular object) is actually done to an Object instance named 'main'. 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 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 Ruby interpreter has been ported to many platforms, including Unix, Microsoft Windows, DOS, Mac OS X, OS/2, Amiga and many more.

Interaction

The Ruby distribution also includes "irb", an interactive command-line interpreter which can be used to test code quickly. A session with this interactive program might be: 

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

Licensing terms

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

Features

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

Possible surprises

Although Ruby's design is guided by the principle of least surprise, naturally, some features differ 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.
  • 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. In Ruby, however, it yields 1, because even the number 0 is considered a "something"; only nil and false evaluate to false. A corollary to this rule is that by convention, Ruby methods -- for example, regular expression searches — return numbers, strings, lists etc. on success, but nil on failure (e.g., mismatch) or some other expression of the negative.
  • 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.
  • Lack of a 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); to obtain "a" use "abc"[0,1] (a substring of length 1) or "abc"[0].chr.

A good list of "gotchas" may be found in Hal Fulton's book The Ruby Way, pages 48–64. However, since the list in the book pertains to an older version of Ruby (version 1.6), some items have been fixed since the book's publication. 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']       # Prints:  hot

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!"

Ruby code corresponding to the fragment in the article Python programming language demonstrating closures: 

def foo(initial_value=0)
  var = initial_value
  return Proc.new {|x| var = x}, Proc.new { var }
end

setter, getter = foo
setter.call(21)
getter.call # => 21

Yielding program flow to a block provided at the location of the call 

 def bfs(e)
   q = []
   e.mark
   yield e
   q.push e
   while not q.empty?
     u = q.shift
     u.edge_iterator do |v|
     if not v.marked?
       v.mark
       yield v
       q.push v
     end  
   end
 end
 bfs(e) {|v| puts v}

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: 

File.open('file.txt', 'w+b') do |file|
  file.puts 'Wrote some text.'
end                             # File automatically closed here

Or 

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. Also, the last evaluated statement in a method is its return value, allowing the omission of an explicit 'return'. 

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 examples

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

Operating systems

Ruby is available for the following operating systems:

Other ports may also exist.

Applications

The Ruby Application Archive serves as a repository for a wide range of Ruby applications and libraries, containing more than a thousand items. Although the number of applications available does not match the volume of material available in the Perl or Python community, there is a wide range of tools and utilities which serve to foster further development in the language.

See also

External links

Wikibooks has more about this subject:
Major programming languages (more) (edit)

Industrial: ABAP | Ada | AWK | Assembly | C | C++ | C# | COBOL | Common Lisp | Delphi | Eiffel | Fortran | Java | JavaScript | Lisp | Magik | Objective-C | Pascal | Perl | PHP | PL/SQL | PowerBuilder | Python | Ruby | SAS | Smalltalk | Tcl | Visual Basic | VB.NET | Visual FoxPro

Academic: APL (historical dialect)/J | Haskell | Logo | ML | Prolog | Scheme

Historical: ALGOL | BASIC | Clipper | Modula-2/Modula-3 | MUMPS | PL/I | Simula

Retrieved from "http://en.freepedia.org/Ruby_programming_language.html"


Views
Personal tools
In other languages
Similar Links