Slashdot Mirror
Korundum Brings eXtreme RAD to Linux
anonymous writes "The Free Software community is on a quest for the next generation development environment. Is it .Net, is it Java? Many (including Havoc) are quick to dismiss some of the gems invented by the Free Software community itself. Yes, Ruby is an incredibly consistent and clean language designed specifically to incorporate many of the best features and ideas of predecessors. Absolutely everything in Ruby is an object and practically everything can be redefined or extended on the fly. The effects and resulting power of such flexibility can be quite astounding to those who have adapted to contemporary language limitations. Now, the Ruby environment has been seamlessly integrated into KDE through Korundum, meaning that well-integrated and first-class desktop citizens for Linux can be sketched and developed in an extremely short time. Caveat: No explicit compilation is required and programming seems so easy it feels like cheating."
JRuby is a ruby implentation for the java JVM, it isn't a binding. The current ruby implementation isn't a byte code interpreter, it evaluates the AST at runtime. Alex Kellett the QtRuby/Korundum co-author is working on a ruby JIT project called Rubydium.
-- Richard
So, is it ok as a beginner langage ?
For a tutorial, check out Why's Poignant Guide to Ruby, or if that's just a bit too bizarre you might have a look at this Ruby tutorial.
First off, this concept is by no means unique to Ruby, so give credit where credit's due. The whole concept of "blocks" as first class objects was stolen from Smalltalk, which has had this concept since the beginning (back in the 80s). And, of course, this concept was basically taken from Lisp and other functional languages, where they're referred to as closures, or lambda expressions. And plenty of other languages have inherited this feature as well, including Perl (but not, unfortunately, Java... *damn* I wish Java had closures).
Python, OTOH... you're absolutely right. Again, they tried to inherit from Lisp with the lambda construct, and in the process, somehow fell flat on their faces. I quite like Python for many reasons, but this is one bit of brokenness that I've never been able to understand.
Ruby and Smalltalk both think of everything as an object and have a "bullet list" of main language features that are similar, true.
However, they have a quite different environment integration, a quite different syntactic style, a different programming culture, leading to them being different in practice, with different strengths and weaknesses.
To be more specific:
Environment:
Syntactic style:
Smalltalk has a very, very simple syntax and set of control structures. It was implemented because Alan Kay felt that Lisp ended up with too many "special forms" (similar to for, if, while, switch, etc in C). Basically, Smalltalk has one operation: Send a message to an object. If is implemented by having methods for true and false on an "if object".
Ruby, on the other hand, has a rich set of control structures and syntax, in the spirit of most contemporary languages (C, Java, Python, Perl, etc). It has even added string interpolation and regular expressions to the syntax, making it very easy to deal with these constructs. (Regular expressions is, BTW, another thing that Smalltalk has no standard support for. See e.g. http://www.smalltalk.org/articles/article_20040917 _a1.html for a discussion around this.)
The Programming Culture:
The Ruby programming culture is fairly heavy on metaprogramming and library use. People use standard tools for editing files, version control, searching through the code, etc. Documentation is generally stored as standard comments in the code. If you want to make them browsable or make it possible to do easy lookups in them, you run separate tools to extract them (rdoc to extract to HTML and ri, ri to look up).
The Smalltalk community use special code browser for going through the code. This works on parse trees and the heavily normalized form of Smalltalk. If you want to add comments, this has to be done separately, and is stored separately from the code. You cannot use a standard text editor to edit the code and comments. On the other hand, the normal form of Smalltalk makes it very easy to write tools that work on the code, and this is standard practice. On result of this is the "Refactoring browser", making it possible to do refactorings directly, instead of having to do the manual edits necessary. However, there is very little use of metaprogramming, as that gets in the way of the paradigm. Version control is also handled internally in the Smalltalk image.
End result:
Ruby lets the programmer leverage the habits and tools he or she is used to, while Smalltalk only lets the programmer leverage abstract programming knowledge and the tools that are built into Smalltalk.
The tools that are built into Smalltalk are generally very, very good, but this requirement form a barrier to the wide adoption of Smalltalk. If the entire world was in Smalltalk, it might be a better place, but as it is, the world is not in Smalltalk. The end result is one more thing that Ruby is better at that Smalltalk: Getting programmer adoption. There are presently about 300,000 pages found by a search for "smalltalk language" - against 1.1 million for "ruby language".
Eivind.
Doubting the existence of evolution is like doubting the existence of China: It just shows that you're uninformed.