ibm_db 2.5.10 adds support for Rails 3.2 and fixes a few minor bugs that have been reported by the community. New features such as Time Travel Queries are supported seamlessly.

The biggest news is the simplified installation process. You now only need to set the DB2′s instance user home, and the gem installation process will take care of determining both which architecture (e.g., 32 vs 64 bit) and libraries to use.

All it really takes now to install ibm_db on a Linux/Unix/Mac box is something along the lines of:

$ sudo -s
$ export IBM_DB_HOME=/home/db2inst1/sqllib
$ gem install ibm_db

Windows users don’t even have to worry about setting up the home directory. It will work both on Windows 32 and 64 bit systems, but unlike with *nix systems, Ruby and ibm_db will run in 32 bit mode only.

To try out DB2 with Ruby/Rails, I recommend you download and install DB2 Express-C for free.

Possibly related posts:

1. Installing the Ruby driver for DB2 on Mac OS X Snow Leopard
2. Installing Ruby on Rails and DB2 on Ubuntu 11.04
3. DB2 support for Ruby/Rails turns 2.0

RubyMotion is not a bridge; it actually generates native applications that are as fast as the ones written in Objective-C . You can check out Ars Technica’s exclusive article for more details on the project and watch the Pragmatic Studio’s 50 minute free screencast about it to get a better idea of how RubyMotion works in practice.

For a limited time you can buy RubyMotion at an early bird discount rate of 25% off. It’s such a productive and affordable solution, that I’m sure it will quickly become popular among Ruby developers who are interested in iOS development and testing, as well as among existing iOS developers.

Many of the questions you may have can likely be found in the FAQ section, but feel free to ask any additional questions here. Enjoy it.

Possibly related posts:

1. Is the Enterprise world Rails ready?
2. Would you use a Mac mini as your development machine?
3. Mobile Development Marketshare Among Hacker News’ Participants

Among many other fields, the table Customers includes a column name defined as VARCHAR. name is used to store company names.

One of the requirements for the project was to implement a Google Suggest-like feature. That is, when the user enters a few characters for the customer’s name, they should be prompted, via AJAX, with a list of possible suggestions containing that string (or at least beginning with that string.)

The naive approach would be to use a simple LIKE predicate, to generate queries such as:

SELECT name
FROM   Customers
WHERE  name LIKE '%micro%'
ORDER  BY name

One of the main problems with this approach is performance. Using LIKE this way doesn’t allow us to take advantage of indexes that are defined on the column name.

Unsurprisingly, on a modest server, such a query takes about 25 seconds. A UI that isn’t able to respond for 25 seconds will feel like an eternity for the end user, of course, so a simple query like this obviously cannot be seen as a viable solution.

Enter DB2 Text Search. You may be familiar with other full text search engines such as Ferret, Lucene, or Sphinx. DB2 V9.7.4 ships with an extremely powerful full text search engine that has plenty of useful features, including excellent integration with native XML columns.

Using the free edition of DB2 (DB2 Express-C) which includes Text Search, we were able to implement the autocomplete functionality we were after in a heartbeat, thanks to a query like the following:

SELECT name
FROM   Customers
WHERE  CONTAINS(name, 'micro') = 1
ORDER  BY name

This query was executed in mere fractions of a second for most searches, and behaved exactly as needed. In fact, not only did we match strings that began with the searched token, but also ones that contained it elsewhere (e.g., micro would match both Microsoft and Sun Microsystems.) The results where ordered alphabetically, but could have easily been ordered by relevance via the SCORE function, also available via DB2 Text Search.

As usual, it’s a matter of using the right tool for the right job, and DB2 Text Search was created exactly for these kind of scenarios.

Let’s briefly look at how you can also go about setting up and playing with it on Linux.

Installing DB2 Text Search

To start with, you’ll need to have a 64bit Linux distro, and then follow these simple steps.

Download DB2 Express-C. Make sure you grab the db2exc_974_LNX_x86_64.tar.gz file and not the Light edition.

Next, install DB2 by following these steps (the Installing DB2 section in particular.) Make sure you select a custom installation, and that you select everything including DB2 Text Search (which is not checked by default).

After you’ve started DB2 with db2start via the instance user (e.g., db2inst1,) launch the text search server by running:

db2ts start for text

To enable text search for an existing database, run:

db2ts enable database for text connect to mydb

Next, you’ll need to create a text search index and populate it. For example:

db2ts "create index customer_name for text on customers(name) connect to mydb"
db2ts "update index customer_name for text connect to mydb"

That’s it. From now on you’ll be able to use functions such as CONTAINS to quickly search for your data.

Such a function can also be easily invoked in Rails:

Customer.where("CONTAINS(name, ?) = 1", name)

Or wrapping it a little in a model:

class Customer < ActiveRecord::Base
  # ... 
  def self.search(name, max_res = 10)
    where('CONTAINS(name, ?) = 1', name).
    order('name').
    limit(max_res)
  end
end

Which can then be invoked as follows:

Customer.search("micro")

(Technically we wouldn’t have needed limit, so long as we passed RESULTLIMIT to the CONTAINS function.)

You can read more about DB2 Text Search at the Information Center.

No related posts.

Multiply each item in a list by 2

(1..10).map { |n| n * 2 }

Sum a list of numbers

(1..1000).inject { |sum, n| sum + n }

Or using the (built in) Symbol#to_proc syntax that’s been available since Ruby 1.8.7:

(1..1000).inject(&:+)

Or even just passing a symbol directly:

(1..1000).inject(:+)

Verify if tokens exist in a string

words = ["scala", "akka", "play framework", "sbt", "typesafe"]
tweet = "This is an example tweet talking about scala and sbt."

words.any? { |word| tweet.include?(word) }

Reading a file

file_text = File.read("data.txt")
file_lines = File.readlines("data.txt")

The latter includes “\n” at the end of each element of the array, which can be trimmed by appending .map { |str| str.chop } or by using the alternative version:

File.read("data.txt").split(/\n/)

Happy Birthday

4.times { |n| puts "Happy Birthday #{n==2 ? "dear Tony" : "to You"}" }

Filter a list of numbers

[49, 58, 76, 82, 88, 90].partition { |n| n > 60 }

Fetch and parse an XML web service

require 'open-uri'
require 'hpricot'

results = Hpricot(open("http://search.twitter.com/search.atom?&q=scala"))

This example requires open-uri and hpricot or equivalent libraries (you could use builtin ones if you wish). It’s not too much code, but Scala clearly wins here.

Find minimum (or maximum) in a list

[14, 35, -7, 46, 98].min
[14, 35, -7, 46, 98].max

Parallel Processing

require 'parallel'

Parallel.map(lots_of_data) do |chunk|
  heavy_computation(chunk)
end

Unlike Scala, multicore support is not built-in. It requires parallel or a similar gem.

Sieve of Eratosthenes

The Scala one liner is very clever, but entirely unreadable. A simpler implementation that is no longer a one-liner in Ruby would be:

index = 0
while primes[index]**2 <= primes.last
      prime = primes[index]
      primes = primes.select { |x| x == prime || x % prime != 0 }
      index += 1
end
p primes

This last example is straight from StackOverflow. Not the prettiest code ever, but you get the idea.

No related posts.

• Ruby 1.8.7
• Rubygems
• Ruby on Rails
• DB2 Express-C 9.7.4
• The official Ruby driver and Rails adapter for DB2

Installing Ruby

We are going to install Ruby 1.8.7 using the Debian packages that are available in the default repositories:

$ sudo apt-get install ruby-full

Next we’ll build Rubygems from scratch, so as to obtain a recent version and be able to update it to the latest one via the gem system itself:

$ cd /tmp/
$ wget http://production.cf.rubygems.org/rubygems/rubygems-1.7.2.tgz
$ tar xvfz rubygems-1.7.2.tgz
$ cd rubygems-1.7.2
$ sudo ruby setup.rb
$ sudo gem update --system

You can now verify that Rubygems is correctly installed:

$ gem -v
1.8.1

Note: If you plan to have multiple versions of Ruby, you’ll probably want to look into RVM.

Installing Rails

We are not going to install the Rails package that ships with Ubuntu, because this is also quite obsolete at this stage. Instead, we’ll use the newly installed gem command:

$ sudo gem install rails

(Add the --no-rdoc --no-ri flags if you don’t care about the local documentation. This will speed up the installation process.)

You can verify the installed version by running:

$ rails -v
Rails 3.0.7

Installing DB2

We can now download and install DB2 Express-C 9.7.4. Download the .tar.gz installation file to a location that’s convenient for you. Then proceed to unpack it:

$ cd ~/Downloads/
$ tar xvfz db2exc_974_LNX_x86.tar.gz
$ cd expc

We’ll install one required library and then proceed with the setup:

$ sudo apt-get install libaio1
$ sudo ./db2setup

Follow the GUI wizard on screen to continue with the installation. Pay close attention to two steps:

• When prompted select a custom installation, and when choosing the components, select all of them We’ll need the Application Development Tools in order to build the Ruby driver later on. (And these are unchecked by default.)
• When asked if you’d like to create an instance user, go with that option. It greatly simplifies the setup process.

When the setup of DB2 is completed, you should receive a confirmation message informing you about the successful installation.

For good measure, add the following line to your ~/.bashrc file:

. /home/db2inst1/sqllib/db2profile

This ensures that even your regular, non-DB2, user will be able to connect and interact with the database.

Installing the ibm_db gem

The last step we need to take is to install the ibm_db gem, which includes the IBM released (and supported) open source driver for Ruby, as well as the adapter for Rails. You’ll need these in order to use Rails with DB2.

Open a new shell and run:

$ sudo -s
$ export IBM_DB_INCLUDE=/home/db2inst1/sqllib/include
$ export IBM_DB_LIB=/home/db2inst1/sqllib/lib
$ . /home/db2inst1/sqllib/db2profile
$ gem install ibm_db
$ exit

At the time of writing, this installs ibm_db-2.5.6.

A quick sanity test

To ensure that all is well with your setup, run the following command:

$ rails new db2test -d ibm_db
$ cd db2test

Now, edit config/database.yml so that the development section uses the same password you specified for the db2inst1 user during the installation of DB2. Change the database name to something like db2test. The section should look like the example below:

development:
	adapter: ibm_db
	username: db2inst1
	password: secret
	database: db2test

Create the database db2test by running:

$ su - db2inst1
$ db2start
$ db2 create db db2test
$ exit

Depending on your hardware specs, the infrequent operation of creating a database can take quite a long time (e.g., minutes).

We will now install/attach the required gems for this project:

$ bundle install

For the sake of a quick example, we’ll use scaffold to generate some super-basic code. We’ll then run migrations, and the built-in web server:

$ rails g scaffold Subject name:string
$ rake db:migrate
$ rails s

Visit http://localhost:3000/subjects and you should see a scaffold interface you can use to create, edit, show, and destroy subjects, as I’ve done in the screenshot below.

Note: As you develop, you’ll probably want to use a better web server such as mongrel, unicorn, or thin. You can easily do so by editing your Gemfile and installing the gem via bundle.

Getting help

IBM is the only database vendor to officially provide and support its Ruby driver and Rails adapter. While commercial 24/7 DB2 support is certainly available and relatively inexpensive (i.e., cheaper than MySQL), your first line of defense is posing your questions in the support forum over at Rubyforge. Alternatively, if the question is DB2-specific and not related to Ruby or Rails, you can use the DB2 Express-C forum over at developerWorks instead.

Possibly related posts:

1. Installing DB2 9.5 on Ubuntu 7.10
2. Installing Django with PostgreSQL on Ubuntu
3. Installing and configuring DB2 Express-C 9.7 on Ubuntu 9.04 Server

1. How did you go from Theoretical Physics to Ruby Programming?

I have a background in computational physics, and I learned Perl and then Python to avoid the pain of C/C++ as much as possible. (The core simulation code for my work was in C/C++ for speed, but I had lots of scripting needs as well, and using C/C++ for scripting would have been horrible.) That led naturally to experimenting with web programming, and I ended up writing my own half-baked web framework in Python. After Rails came out, I switched to Ruby, and haven’t looked back. (I generally prefer Ruby, but Python is also nice. I’ll remain silent on Perl. )

2. There wasn’t a lack of Ruby and Rails books when you started working on the Rails Tutorial. What motivated you to create it?

There were lots of Rails books, but there weren’t any that took the approach I wanted to take, namely, a single substantial sample application with features and pacing carefully chosen for pedagogical purposes. My first book, RailsSpace, filled that niche, but it was out-of-date, and I also perceived an opportunity with the (then-upcoming) release of Rails 3. I figured that a full-length tutorial book aimed at Rails 3 could find a broad audience.

3. What would you say was your biggest challenge in preparing the tutorial?

On a long-term project of this sort, it can be difficult to balance writing with the need to pay the bills. For a while at the beginning, I alternated between doing contract work and writing, and that takes its toll. Not only does contract work take time, but there is a also a big context switch when changing over to writing mode. Doing contract work was necessary given my financial situation at the time, but in the future I expect to be able to focus solely on writing and screencasting.

4. You chose an approach rarely taken by traditional publishers, by producing a free HTML version of the Rails Tutorial, while providing a DRM-free PDF version and supplementary video lessons for a fee. How is the market treating you? Is it an approach that you’d recommend to fellow programmers?

The market response has been great. The free HTML version has attracted lots of referrals and inbound links, which was its main strategic purpose, and it has also generated lots of good karma. Meanwhile, many people are happy to buy the PDF, which is easy to put on an iPad and can be read offline. Readers have also reported that having the PDF gives them a sense of ownership, and they also like knowing that they are supporting the Rails Tutorial project financially.

I have recommended this approach to other programmers (most recently in a talk at the Los Angeles Ruby Conference). Having a free HTML version is a business strategy, not charity, though it does feel good—I’ve gotten email from many readers, especially in poorer countries, thanking me for making the book available for free online.

5. The book is also in print through the excellent Ruby series by Addison-Wesley. Did they reach out to you after the huge success of your online tutorial/video course or was there a plan of world domination all along?

Partnering with a major publisher was part of the initial plan for world domination, but I didn’t think it was strictly necessary. The publisher and I attempted to get a deal in place before I wrote the book, but were unable to come to terms. After I finished the book, we got back in touch and worked out the details of a publication agreement. It’s an unusual arrangement, and I’m thankful to Addison-Wesley for being willing to try it out. Please go out and buy the print edition to reward them for their support of the Ruby community!

6. Do you have any advice for people starting out with Rails (other than reading your book and watching your screencasts, of course)?

Web development is hard, so be prepared for some challenges and occasional frustration. It’s especially good to pick a project you care about; that will help keep you motivated when the going gets tough.

7. If you had a magic wand, what would you change in the Ruby/Rails ecosystem? And how can we make it happen without said magic wand?

I’d make Ruby and Rails installation easier; the barrier to entry in some cases is still forbiddingly high. For example, a while back I spent a couple of hours just getting Ruby to compile after an upgrade to OS X Snow Leopard. (There was a subtle issue related to the location of the readline library headers.) Paradoxically, I think in the early years this may have benefited Rails by insuring that the typical Rails developer was both determined and highly skilled, but the Rails community has matured now to the point where lowering that barrier should be a priority. Happily, Engine Yard has hired the awesome Wayne E. Seguin (best known as the author of Ruby Version Manager, or RVM) to work on exactly this problem. The initial result, the Rails Installer for Windows, looks promising, and I’m excited to see where that project goes from here.

8. What’s next for you?

My O(n) Rails Tutorial workload is minimal right now, which is a good sign, but I have a large O(1) work queue to complete. For example, I’m preparing a free screencast for buyers of the print edition, and I’ve committed to making the HTML book available for translation. Once that work queue cycles down to zero, I’m going to take a little time off, and then I’ll probably start making some more Rails- and Ruby-related products. Interested readers should subscribe to the Rails Tutorial news feed to be notified when future products are available. In addition, anyone who buys the Rails Tutorial PDF/screencast bundle will likely be pleasantly surprised by exclusive coupon codes when the time comes. (Well, they won’t be surprised now, but you get the idea. )

Book giveaway: I will randomly draw one person from among those who share (retweet) this interview on Twitter, and personally ship that person a free printed copy of the Rails 3 Tutorial. All you have to do to be entered in this giveaway is to tweet about this post. I will announce the winner on Friday morning on my twitter account (follow me!) and in the comments below.

No related posts.

Those who read the Gang of Four (US | UK | CA) several years before, may have expected a highly technical reference book with examples translated from C++ to Ruby (whenever patterns applied to Ruby as well). And in theory Olsen’s book was very much like that, as it was a list of 14 design patterns extracted from the Gang of Four and applied to Ruby.

In practice though, Design Patterns in Ruby really wasn’t anything like Design Patterns: Elements of Reusable Object-Oriented Software. To start with, it wasn’t much of a reference. It was more akin to a cookbook of recipes that related to the idiomatic use of Ruby patterns.

Upon starting that book, readers may have expected a cold, dry, tough-to-fully grasp treatment of the topic at hand. Instead they were greeted with a tone that was friendly and entertaining; you could read and absorb the whole thing in a matter of days. While some people may have thought this book was aimed only at Ruby experts, it turned out to be incredibly accessible to, and suitable for, Ruby beginners as well.

Eloquent Ruby (USA | UK | CA), Olsen’s newest book, doesn’t veer much from the same description. This time the focus is not on specific design patterns, but rather on the style and essence of Ruby as a whole.

In the three plus years that separate Olsen’s two books, we’ve witnessed the language and its community mature as we’ve moved away from Ruby 1.8, and we’ve seen plenty of new tools and idioms emerge. Eloquent Ruby tries to capture the essence of writing beautiful Ruby code in this modern idiomatic manner, by focusing on Ruby 1.9 (while providing footnotes for those who are still using 1.8).

There is a certain “Ruby way” of approaching problems and elements of style that reveals if a developer is an experienced Ruby programmer or not. This book will no doubt help you better understand not only the “how” but also the “why” of this distinctive Ruby way.

The 31 short chapters in Eloquent Ruby are logically organized and easy to follow, but can be read independently from one another, too. By focusing on practical examples, these chapters cover everything from basic style considerations to object oriented design, and delve into such topics as testing, metaprogramming, DSL, packaging and deploying gems, different Ruby implementations available, and monkey patching considerations.

This useful book assumes that its readers have a basic knowledge of Ruby, yet aren’t complete and total experts yet (and indeed such experienced Ruby users may not pick up too much new information from this book). For those who consider themselves to be novice to moderately well versed Ruby programmers, this book is a delightful read that’s likely to help you further your Ruby skill set considerably.

I would classify Eloquent Ruby as a “second Ruby book”, to be read after you’ve worked your way through a canonical introduction. Yet, if you’re a bright developer who’s coming from a different language, you may consider jumping right into it as your first Ruby book.

This great title is called “Eloquent Ruby”, but I feel it could just as easily have been called Idiomatic Ruby, Elegant Ruby, or Beautiful Ruby – as all of those descriptions fit it to a tee, too.

Book giveaway: I will randomly draw one person from among those who share (retweet) this review on Twitter, and personally ship that person a free copy of Eloquent Ruby. All you have to do to be entered in this giveaway is to tweet about this post. I will announce the winner tomorrow morning on my twitter account and in the comments below.

No related posts.

The Rails page is a complete rewrite as I’ve removed any trace of Rails 2 books. I outlined a useful path of Rails books to follow based on the few available titles that are up-to-date with the latest version of the framework.

It’s likely that more books on the subject will come out in the next few months and as they do, I will update the list accordingly. That said, the existing Rails 3 books (or those that are just about to be released) are very valid, useful ones.

No related posts.

Based in San Francisco and Sacramento, StreamSend is made up of a group of really cool guys who “get” both Agile development and how to treat their employees. If you are looking for a great (and well paid) job in an economically stable (they’ve been around since 1998) and rapidly growing company, apply here.

If you follow this blog regularly you know that I normally don’t post job ads, but I can personally vouch for this position.

No related posts.

The setup

For this shootout I included a subset of the Ruby Benchmark Suite. I opted to primarily exclude tests that were executed in fractions of a second in most VMs, focusing instead of more substantial benchmarks (several of which came from the Computer Language Benchmarks Game). The best times and least memory allocations out of five runs are reported here for each benchmark.

All tests were run on Ubuntu 10.4 LTS x86_64, on an Intel Core 2 Quad Q6600 2.40 GHz, 8 GB DDR2 RAM, with two 500 GB 7200 rpm disks.

8 implementations

The implementations tested were:

• Ruby 1.8.7 p299
• Ruby 1.9.1 p378
• Ruby 1.9.2 RC2
• IronRuby 1.0 (Mono 2.4.4)
• JRuby 1.5.1 (Java HotSpot(TM) 64-Bit Server VM 1.6.0_20)
• MagLev (rev 23832)
• Ruby Enterprise Edition 2010.02
• Rubinius 1.0.1

JRuby was run with the –fast and –server optimization flags.

Disclaimer

Synthetic benchmarks cannot predict how fast your programs will be when dealing with a particular implementation. They provide an (entertaining) educated guess, but you shouldn’t draw overly definitive conclusions from them. The values reported here should be assumed to be characteristic of server-side — and long running — processes; they should be taken with a grain of salt.

Time Results

Please find below the execution times for the selected tests. Timeouts indicate that the execution of a single iteration for a given test took more than 300 seconds and had to be interrupted. Bold, green values indicate the best performer out of each test.

Warning: The bm_primes.rb benchmark was originally written to aid the development of the Prime class. As such in 1.9.2 it was rewritten in C, which makes it a poor representation of implementation performance. This benchmark will removed in the future.

If you are not interested in the individual test results, the information presented in the table above is summarized directly below:

  Ruby 1.9.2         JRuby
Min.   : 0.013   Min.   : 0.382
1st Qu.: 3.258   1st Qu.: 3.051
Median : 4.543   Median : 4.997
Mean   : 9.262   Mean   : 9.180
3rd Qu.: 8.573   3rd Qu.: 8.969
Max.   :45.009   Max.   :48.850

    MagLev         Ruby 1.9.1
Min.   : 0.351   Min.   : 0.015
1st Qu.: 2.140   1st Qu.: 3.387
Median : 6.069   Median : 6.205
Mean   : 9.100   Mean   :10.860
3rd Qu.: 9.266   3rd Qu.:11.559
Max.   :51.221   Max.   :46.849

 Ruby 1.8.7         IronRuby
Min.   : 0.708   Min.   :  3.601
1st Qu.: 5.102   1st Qu.: 10.505
Median : 8.380   Median : 12.912
Mean   :18.785   Mean   : 26.539
3rd Qu.:24.793   3rd Qu.: 36.115
Max.   :75.653   Max.   :135.204

   Rubinius           REE
Min.   : 0.484   Min.   : 0.584
1st Qu.: 3.087   1st Qu.: 4.343
Median : 9.636   Median : 6.660
Mean   :13.232   Mean   :15.036
3rd Qu.:17.674   3rd Qu.:21.336
Max.   :73.050   Max.   :61.960

For the sake of convenience, I also produced a box plot from the successful data points:

There are a few considerations based on these results that I feel are worth mentioning:

• As you can see Ruby 1.9, JRuby and MagLev converge towards a similar performance level according to these tests.
• Ruby 1.9.2 manages to squeeze in a bit of extra speed when compared to Ruby 1.9.1 (which is a welcome improvement).
• Ruby 1.9 seems to be either much faster than Ruby 1.8 or roughly as fast, depending on the test. This appears to be in line with what I’ve seen in real world programs. There are programs that will only receive a 10-20% boost from 1.9, while others improve drastically. The results really depends on what a program spends its time doing.
• Performance wise, Rubinius is really starting to be a much more serious contender.
• Ruby Enterprise Edition is slightly faster than Ruby 1.8.7, to the extent where this is clearly visible in almost all of the tests.
• IronRuby running on Mono was the worse of the lot.

Memory Results

The following table shows the approximate memory consumption for each implementation when running each benchmark:

Summarized:

  Ruby 1.9.2        Ruby 1.9.1
Min.   :  4.320   Min.   :  4.580
1st Qu.:  4.378   1st Qu.:  4.695
Median :  6.285   Median :  6.920
Mean   : 20.795   Mean   : 15.669
3rd Qu.: 10.162   3rd Qu.: 11.383
Max.   :171.500   Max.   :100.570

   Ruby 1.8            REE
Min.   :  3.040   Min.   :  8.220
1st Qu.:  4.290   1st Qu.:  9.682
Median :  7.745   Median : 15.565
Mean   : 20.698   Mean   : 27.014
3rd Qu.: 11.273   3rd Qu.: 38.620
Max.   :103.520   Max.   :125.910

  Rubinius           MagLev
Min.   : 37.63   Min.   : 81.74
1st Qu.: 39.78   1st Qu.: 82.52
Median : 45.48   Median : 83.53
Mean   : 65.70   Mean   : 96.29
3rd Qu.: 58.22   3rd Qu.: 98.10
Max.   :215.33   Max.   :175.85   

    JRuby
Min.   : 49.04
1st Qu.: 71.23
Median :176.72
Mean   :169.41
3rd Qu.:209.04
Max.   :404.06

And finally, in graph form:

A few considerations on memory:

• Memory readings for IronRuby were not available, so they were not included.
• Ruby 1.9.2 uses the least amount of memory (as one might expect).
• JRuby was by far the most memory intensive of the group.
• Ruby Enterprise Edition used less memory than 1.8.7 in a few tests, but overall was more memory hungry than 1.8.7. This is really odd and entirely unexpected.

Linux Vs. Windows

This shootout and the Windows one were both performed on the same machine, thus we can compare how the same implementation perform under different operating systems. The only adjustment that’s required is the timeout. Every result longer than 60 seconds from this shootout needs to be considered a timeout, because the previous shootout did so as well.

It is commonly believed that Ruby performs much better on Linux than on Windows (with the exception of IronRuby). Let’s find out if these test results confirm that notion.

Ruby 1.8.7:

Ruby 1.9.2:

JRuby:

Finally, in chart form (yellow entries are on Windows as indicated by the labels containing W):

To use a beloved MythBusters expression, this myth is confirmed.

Note: As requested by a few commenters, here is a comparison of IronRuby as well (.NET 4.0 Vs. Mono 2.4.4):

Conclusion

In conclusion, let me just state that it’s nice to see several implementations getting faster. Ruby 1.9.2, JRuby, MagLev and Rubinius are all becoming serious competitors and working their respective ways closer to a similar performance level. If you think these benchmark shootouts are becoming boring, then the results are becoming more stable and predictable. I suspect that as time goes on, performance will not be the real distinguishing factor when choosing a Ruby implementation, other features will be.

No related posts.