- 1993, February 24: Yukihiro Matsumoto ("Matz") started to work on Ruby.
- 1993, Summer: First "Hello, world!" program works.
- 1995, December: First release 0.95.
- 1996, December: 1.0 is released.
- 1999: Supposedly overtook Python in Japan.
- 2000: The first official newsgroup.
- 2000-2001: Several books and magazine articles published.
- 2003: Version 1.8.0 is released.
Ruby's syntax and design philosophy are heavily influenced by Perl. It has a lot of syntactic variability. Statement modifiers (if, unless, while, until, etc.) may appear at the end of any statement. Some key words are optional (the ``then'' in an ``if'' statement for example). Parentheses may sometimes be elided in method calls. The receiver of a method may usually be elided. Many, many things are lifted directly from Perl. Built in regular expressions, $_ and friends, here documents, the single-quoted / double-quoted string distinction, $ and @ prefixes to distinguish different kinds of names (but with different semantic) and so forth. Like Perl, Ruby has very good text processing facilities. Like Smalltalk, everything in Ruby is an object, and Ruby has blocks, iterators, meta-classes, operator overloading, etc.
Ruby supports coroutines and exceptions out of the box like any modern language should. Among attractive Ruby features:
- Operator overloading,
- Good, almost PL/1 quality, exception handling (40 years delay but better late then never :-)
- Coroutines, Iterators and closures (again 40 years is a nice amount of time to impleent those features in a language)
- Dynamic loading (depending on the architecture),
- Reasonable portability (Windows, Unixes)
- Good extensibility using C and C++ (weak point of Perl)
- Ruby integrated regex into the language and duplicates the syntax of Perl regular expressions. However it also provides the OO syntax.
Ruby like Smalltalk, provides closures and code blocks and uses them in the same way. The Ruby collection classes and iterators are more powerful and elegant than similar Python constructs (lambdas and list comprehensions):
File.open(file, mode) do |f|
# do something with f (= file handle)
end
# f is closed automatically at this point
Look at this for example:
http://www.rubyquiz.com/quiz70.html
There are several useful documents about ruby written for Perl programmers. For example documentation To Ruby From Perl lists several differences:
- you don’t have the context-dependent rules like with Perl.
- a variable isn’t the same as the object to which it refers. Instead, it’s always just a reference to an object.
- although
$and @ are used as the first character in variable names sometimes, rather than indicating type, they indicate scope ($for globals, @ for object instance, and @@ for class attributes). - array literals go in brackets instead of parentheses.
- composing lists of other lists does not flatten them into one big list. Instead you get an array of arrays.
- it’s
definstead ofsub. - there’s no semicolons needed at the end of each line. Incidentally, you
end things like function definitions, class definitions, and case statements
with the
endkeyword. - objects are strongly typed. You’ll be manually calling
foo.to_i,foo.to_s, etc., if you need to convert between types. - there’s no
eq,ne,lt,gt,ge, norle. - there’s no diamond operator. You usually use IO.some_func instead.
- the fat comma is only used for hash literals.
- there’s no
undef. In Ruby you havenil.nilis an object (like anything else in Ruby). It’s not the same as an undefined variable. It evaluates tofalseif you treat it like a boolean. - when tested for truth, only
falseandnilevaluate to a false value. Everything else is true (including0,0.0, and"0").
I would add that unlike Perl, Ruby has no variable declaration. This means there is no local variable scope. The first variable assignment defines its scope. There is no operators ++ and -- (may not yet :-). Also methods cannot be used before definition (one pass syntax analyzer).
Here is the list of gotchas from Ruby (programming language) - Wikipedia, the free encyclopedia
Gotchas and 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 expression0 ? 1 : 0evaluates to 0 (i.e. false). In Ruby, however, it yields 1, as all numbers evaluate to true; onlynilandfalseevaluate 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, butnilon failure (e.g., mismatch).- 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 data type (compare to C, which provides type
charfor 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.In addition, some issues with the language itself are commonly raised:
- 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[4]. However, in future releases (current revision: 1.9), Ruby will be bytecode compiled to be executed on the YARV (Yet Another Ruby VM). Currently, Ruby's memory footprint for the same operations is better than Perl's and Python's.[4]
- 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 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,
retrynow works withwhile,untilandfor, as well as iterators.
See also Ruby for Perl programmers and Intro to Ruby for Perl programmers
Similarities
As with Perl, in Ruby,...
- Similar types:
- Strings
- Arrays
- Hashes
- hash = { myArray => 'first', 'b' => 'second' }
- NOTE: in Ruby any object can be a hash key
- Regex
- Many special variables names. $_, $&, and the other ugly special variables.
- regexes are built right in. Ruby duplicates the syntax of Perl regexpes. However it also provides the OO syntax.
- there’s a fairly large number of commonly-used built-ins.
- parentheses are often optional
- strings work basically the same.
- there’s a general delimited string and regex quoting syntax similar to Perl’s (looks like
%q{this (single-quoted)}, or%Q{this (double-quotish)}, and%w{this for a single-quoted list of words}. You%Q|can|%Q(use)%Q^other^delimiters if you like).- you’ve got double-quotish variable interpolation, though it
"looks #{like} this"(and you can put any Ruby code you like inside that#{}).- shell command expansion uses `backticks`.
- embedded doc tools (Ruby’s is called rdoc).
- a package management system, somewhat like CPAN (though it’s called RubyGems)
Differences
Unlike Perl, in Ruby,...
- A constant is a variable whose name starts with an upper case letter.
- Role of semicolon
- Semicolon implisidly is presnt at the end of each line.
- Newline works as whitespace only when expression obviously continues to the next line.
- Otherwise newline finishes the expression, like semicolon.
- Many C++ style idioms like a << n1
- "What is truth?".
- Only false and nil are false
- That means that zero and empty string are true values!
- Methods can't be used before definition.
- Iterators are more powerful then map and grep
- used consistently in builtin libraries
- example: iterate through each member of an array:
array = ['a','b','c','d'] array.each {|item| puts item }- Making your own iterators: yield
def fibUpTo(max) i1,i2 = 1,1 while i1 <= max yield i1 i1,i2 = i2,i1+i2 end end fibUpTo(100) {|f| print f, " "} #prints: 1 1 2 3 5 8 13 21 34 55 89- you don’t have the context-dependent rules like with Perl.
- a variable isn’t the same as the object to which it refers. Instead, it’s always just a reference to an object.
- variables hold references to objects
- a=[1,2,3]; b=a; b[0]=0 #a->[0,2,3]
- So you need to use an object's 'clone' or 'dup' method to copy
- a=[1,2,3]; b=a.dup; b[0]=0 #a is unchanged, b->[0,2,3]
- although
$and @ are used as the first character in variable names, rather than indicating type, they indicate scope ($for globals, @ for object instance, and @@ for class attributes).- array literals go in brackets instead of parentheses.
- composing lists of other lists does not flatten them into one big list. Instead you get an array of arrays.
- it’s
definstead ofsub.- there’s no semicolons needed at the end of each line. Incidentally, you end things like function definitions, class definitions, and case statements with the
endkeyword.- objects are strongly typed. You’ll be manually calling
foo.to_i,foo.to_s, etc., if you need to convert between types.- there’s no
eq,ne,lt,gt,ge, norle.- there’s no diamond operator. You usually use IO.some_func instead.
- the fat comma is only used for hash literals.
- there’s no
undef. In Ruby you havenil.nilis an object (like anything else in Ruby). It’s not the same as an undefined variable. It evaluates tofalseif you treat it like a boolean.- when tested for truth, only
falseandnilevaluate to a false value. Everything else is true (including0,0.0, and"0").
A constant is a variable whose name starts with an upper case letter. In older Ruby implementations, when a constant was assigned a new value, a warning was issued. In newer Rubies, constants may not be reassigned from within instance methods, but can otherwise be changed at will.
Any Perl programmer who wants to start with Ruby should first get the Ruby source
distribution and read README.EXT. This is a good document, not only if you're writing
an extension library, but also if you want to understand Ruby more deeply. Next,
have a look at the source of the interpreter itself, and at the various supplied
extensions in the ext/ directory. You'll also find good examples under
contrib/ on the Ruby ftp sites.
|
Old News
[Mar 12, 2008] Tiny Eclipse 3.3.2 by Eric Suen
About: Tiny Eclipse is distribution of Eclipse for development with dynamic languages for the Web, such as JSP, PHP, Ruby, TCL, and Web Services. It features a small download size, the ability to choose the features you want to install, and GUI installers for Win32 and Linux GTK x86.
[Oct 29, 2006] Maybe it's Not Just Ruby on Rails - O'Reilly ONLamp Blog by chromatic
October 27, 2005 (O'Reilly ONLamp Blog) In comments on Curt Hibbs’s What is Ruby on Rails?, he and Aaron Trevena, maintainer of Perl’s similar Maypole project have debated whether Ruby or Rails are doing anything particularly new.
For people who’ve only ever seen complex “enterprise-class” frameworks and libraries and designs as usable, certainly watching any of the Rails movies might give some evidence that being able to solve the 95% of all possible web programming problems that don’t need huge application servers and complex transactional and messaging systems with a fraction of the effort and perhaps fewer lines of code in general than the complex system requires lines of XML in configuration files is a good thing.
Of course, anyone using a decent set of libraries in Perl, Python, Ruby, or PHP probably already knew this.
Ruby does bring certain advantages; I much prefer the ActiveRecord syntax and introspection over that of Perl’s Class::DBI, but they’re both fantastically useful. They’re equivalent enough that neither offers an order-of-magnitude improvement over the other.
Where something like Python’s Django might invent and polish a new idea, the amount of time and work necessary to do something similar in Perl or Ruby isn’t large either. I don’t have enough practical experience with PHP 5 to judge there, but I’m sure it’s also flexible and dynamic enough to work.
In my mind, the issue isn’t “Ruby on Rails is more flexible and capable than standard J2EE or .NET for any project under a (very high) threshold of complexity”. The real point is that the simplicity, flexibility, and abstraction possibilities offered by dynamic languages and well-designed libraries — as well as a talent for exploiting radical simplicity, extracting commonalities from actual working code, and knowing when too much flexibility makes you less agile — offer a huge advantage over languages and libraries and frameworks and platforms that assume you need a lot of hand-holding to solve a really hard problem.
Yes, Ruby on Rails does what it does very well. It’s not the only thing that does, though. I wonder perhaps if some of the buzz and glow is that it’s new and shiny (in comparison), so that people haven’t already formed their own opinions about it, as they may have with Perl (oh, you can’t write readable and maintainable code), Python (all the fun of the Lisp community without half the things that make Lisp special), and PHP (a language that needs to grow up).
Fortunately, a lot of smart people already understand this. It would be nice to have the right debate, though.
Am I wrong? Is it really Ruby and Rails, or is it the dynamicism, flexibility, and better opportunitites for abstraction of dynamic languages that provide so much of the benefit?
[Oct 26, 2006] DougHolton Re: The departure of the hyper-enthusiast
Ruby user's guide:
http://www.rubyist.net/~slagell/ruby/
10 things every java programmer should know about ruby:
http://onestepback.org/articles/10things/
Coming to ruby from java:
http://fhwang.net/blog/40.html
Things I like:
-blocks
-you can be more expressive in ruby and essentially twist it into different domain-specific languages, see: http://blog.ianbicking.org/ruby-python-power.html
-I like how standalone functions essentially become protected extensions of the object class (like C# 3.0 extension methods):
http://www.rubyist.net/~slagell/ruby/accesscontrol.html
-using "end" instead of curly braces (easier for beginners and more readable)Things I don't like and never will:
-awkward syntax for some things like symbols and properties
-awful perlisms like $_,$$,$0,$1,?,<<,=begin
-80's style meaningless and over-abbreviated keywords and method names like "def", "to_s", "puts", etc.
-:: (double colon) vs . . (period).
Ruby is definitely better than python, but still not perfect, and still an order of magnitude slower than statically typed languages.
[Oct 25, 2006] DDJ's Portal Blog/Sun Gets Ruby-fied By Jon Erickson
On the heels of last weekend's Ruby Conference in Denver (for a report, see Jack Woehr's blog), Sun Microsystems made a Ruby-related announcement of its own.
Led by Charles Nutter and Thomas Enebo, the chief maintainers of JRuby, a 100% pure Java implementation of the Ruby language, Sun has released JRuby 0.9.1. Among the features of this release are:
- Overall performance is 50-60% faster than JRuby 0.9.0
- New interpreter design
- Refactoring of Method dispatch, code evaluation, and block dispatch code
- Parser performance enhancement
- Rewriting of Enumerable and StringScanner in Java
- New syntax for including Java classes into Ruby
In related news, Ola Bini has been inducted into JRuby as a core developer during this development cycle.
Details are available at Thomas Enebo's blog and Ola Bini's blog.
Do I really
have to learn _another_ programming language :-), April 24, 2005
Not a Good
Introduction or Reference, July 8, 2006
Good both
for learning Ruby and comparing it to other OO languages, May 26, 2006