When I started working in a bioinformatics research lab I quickly discovered the wonderful dynamic language that is Perl. I’ve spent a couple of years with Mastering Perl for Bioinformatics somewhere on or around my desk. Perl itself was designed with text-processing and reporting in mind so naturally it’s become widely used when handling biological data.

So everything bioinformatics should be coded in Perl, right? A couple of years ago I might have agreed, but now I feel differently. My first “Perl, I’m leaving you.” moment came when I discovered the way that Rails does web programming. Ruby is the magic in Rails, but I soon discovered Ruby goes much beyond web frameworks. To quote Ezra:

“I came for the Rails, but I stayed for the Ruby”

I wanted to compile some links to show how an active community is positioning Ruby to be a powerful language for bioinformatics programming:

BioRuby – open source bioinformatics library

BioRuby on Github

Web Frameworks

Ruby on Rails – the famous MVC framework that made ruby popular

Merb – fast, lightweight MVC framework

Camping – 5k microframework

Sinatra – web development DSL

Ramaze – simple, light, and modular web application framework

Rack – Webserver interface

Distributed/Parallel Computing

DRb- Distributed Ruby

SkyNet- Map Reduce in Ruby

Rinda – Linda parallel programming model in Ruby

rxgrid – Xgrid batch language

MPI Ruby – MPI bindings for Ruby

amazon-ec2 – Amazon EC2 API

Testing/Spec

RSpec – BDD framework

Test::Unit – Unit testing in the Ruby standard library

Integration with other programming languages

JRuby – JVM ruby implementation

SWIG and Ruby – automatically generate C interfaces

Ruby C extensions

Math/Statistics

Ruby-GSL – wrapper for the GNU Scientific Library

RSRuby- R statistics package in Ruby

SciRuby

Ruby NArray – similar to NumPy

Visualization/Graphics

Ruby Gnuplot – Gnuplot bindings

Ruby-Processing – The Processing language in Ruby

ruby-opengl – OpenGL bindings

Gruff – Graph API

Ruby-SVG – SVG Graphics

Ruby Gnuplot

Machine Learning

AI Related Ruby Extensions

Support Vector Machines in Ruby

Fast Artificial Neural Network library

Blogs about bioinformatics and Ruby

Saaien Tist – Jan Aerts, on bioinformatics and personal productivity

Bioinformatics Zen – Micheal Barton

Be sure to visit the Ruby for Bioinformatics room on FriendFeed for even more Ruby goodness.

image credit: railsenvy.com

Make and it’s other revisionings tackle the challenging problem of dependency injection which is somewhat analogous to the Strategy pattern. Make is a tried and true Unix utility that does the heavy lifting each time you type “./configure; make && make install” inside a large chunk of open source goodness. Make became such a popular tool because it drastically reduced compilation times for large programs. In compiled languages such as C, each time a source file is changed it needs to be recomplied. Rather than rebuild the entire project everytime the source code is changed, an expert (a C programmer in this case) can specify dependencies so that make will build only the files that change and their dependencies. In that sense, it’s easy to take for granted how powerful a Makefile actually is. Make is an expert system that’s ubiquitous in the Unix world.

A makefile has the basic structure:

	target: dependencies

		command 1

		command 2

	          .

	          .

	          .

		command n

Which brings us to the actual point of this post; how to use Makefiles in bioinformatics. There’s a discussion on nodalpoint from 2007 that calls for the use of `make` more often when programming pipelines. This made perfect sense. In bioinformatics we do pipelines all the time.

Sequence analysis

Blast search -> Multiple sequence alignment -> Phylogenetic analysis

Homology Modeling

Find Template -> Align target-template -> Build model

Molecular Dynamics

Solvate -> Equilibrate -> Simulate -> Analyze

Those aren’t the most detailed examples but hopefully you get the idea. Each step is dependent on the previous step. If one single step takes a lot of computation time, it would be nice to skip that step if it’s already been done. There’s also a benefit to encoding expert knowledge. For example, how do you convert a .fasta sequence file to a .pir sequence file? By specifying a rule, a build system will know what to do everytime is sees a ‘*.fasta’ file in your project.

	%.pir: %.fasta

	./fasta2pir $< $@

But Makefile syntax can be tricky (is that a tab or a space?), and it's not a full blown programming language by itself. Which is why I fell in love Rake.

Anyone who has tried out Ruby on Rails probably typed something like "rake db:migrate" without realizing what rake is all about. Rake is Ruby Make. Rake was designed to be just like make, but with all the power and flexibility of the Ruby programming language. A Rakefile is simply a set of tasks, which can have one or more dependencies. Unlike make, rake is an internal DSL since it morphs Ruby into a build language without losing it's utility as a general purpose language.

A simple Rakefile in your bioinformatics project could do something like this:

	task :queryDatabase do

	  puts "Fetched Records"

	end

	task :formatData => :queryDatabase do

	  puts "Converted to XXX format"

	end

	task :createPlot => :formatData do

	  puts "Generated a Figure"

	end	

This says "before I formatData I must queryDatabase", and "before I createPlot I must formatData". So as you might expect, when you type:

	$ rake queryDatabase

	Fetched Records

	$ rake formatData

	Fetched Records

	Converted to XXX format

	$ rake createPlot

	Fetched Records

	Converted to XXX format

	Generated a Figure

And our Fasta rule in Rake would look like:

	rule '.pir' => ['.fasta'] do |t|

	  sh "./fasta2pir #{t.source} #{t.name}"

	end 

Pretty cool? Obviously these tasks don't actually do much other than show how rake resolves dependencies for you, which can be a pretty powerful thing for hacking together a pipeline.

Rake resources:

• Martin Fowler: Using the Rake Build Language
• Saaien Tist: Using Rake to manage your software project

• Rake @ Rubyforge

• Rails Envy: Rake Tutorial

• Rakefile format

Around the web, week of March 7, 2008

• Bio::Blogs #19, the engineering edition!
• BuzzClouds in science, a very cool vizualization of scientific buzzwords and trending. (service)
• Backward compatibility ≠ Forward Scalability, Intel places some caveats on the free-lunch, legacy software won’t take advantage of future architectures unless they’re redesigned. This shouldn’t be a surprise but it hasn’t always been the case. The trend of adding more cores and changing memory architectures means that some applications may get left in the dust unless they’re optimized for these new paradigms.
• DSL specification and behavior, a great example of building a DSL in Groovy for bioinformatics.
• BioRuby on Rails, some good examples of how to fetch EBI records on the web using ActiveRecord for persistance.
• Ruby-Processing, a bridge to use the Processing API in the Ruby language.

Two topics that I have been been reading a lot lately, Domain Specific Languages in Ruby and screencasting have converged to create a very cool little project called Castanaut. I found Castanaut via Peter Cooper of Ruby Inside. Castanaut is essentially a programming language for screencasts. So in castanaut you can write things like this:

launch "Safari", at(10, 10, 800, 600)

type "http://www.inventivelabs.com.au"

hit Enter

pause 2

move to(100, 100)

move to(200, 100)

move to(200, 200)

move to(100, 200)

move to(100, 100)

say "I drew a square!"

Thanks to the flexibility of Ruby, you can write your screenplay as a script and run it to automatically create a screencast. How cool is that? While this might take some of the personal touch away from screencasts, it could also be a powerful tool for those who need to create them in a more systematic way.

The Ruby fanfare on the net seems to be approaching the “multi-core” crisis and several bloggers are talking about Ruby as a language for parallel environments.

Multicore Hardware and the Future of Ruby
Multi-core hysteria and the thread confusion
News for Week 25/2007
Distributed Ruby Workers on EC2

I also learned some YAML thanks to Rubyology, so why not have a subscriptions.yaml

rPodcast.rb