The long-awaited mod_rails for apache was released yesterday by Phusion, a Netherlands based IT company. As many of you have already done, I hopped on board to see how it worked and was amazed on how easy it was to get up and going.

Ryan Bates, a guy whose voice many of us Rails coders have grown to know and love, assisted the Phusion team in creating a short screencast on how to install Passenger onto your Mac.

It was basically 3 steps:

1. Install the RubyGem
2. Run the passenger installer script
3. Modify your apache conf file to include the new virtual host

Can it really get easier than that? I submit that it can not.

In my opinion, Passenger is filling a void that has haunted the Ruby on Rails community for some time. Matz is quoted as saying “It is often said that Rails is weak on deployment; PHP runs fairly fast just by uploading scripts. Rails is slow on development mode, and requires restarting on production mode (and bit complex to configure). modrails might be the answer for it.”.

To get Passenger, go to http://www.modrails.com

I am often asked if I think that clones of Ruby on Rails will become available in insert-your-language-here, and my answer is always “yes and no”.

One of the biggest contributions that Rails has made to the industry as a whole was that it challenged the conventional wisdom about the way things should be done. In doing so, it showed that there was a better way by actual demonstration. Many of ideas behind Rails are, in fact, being cloned in other languages and their web frameworks. But it is my firm belief that, while these clone/borrowers can approach the productivity of Rails in their language, they will not be able to match Rails completely. The reason for this is found in one simple word: Ruby.

The Ruby programming language has a unique confluence of features that made Rails possible. Those of us who have been programming in Ruby for a long time intuitively understand what those language features are, and how they synergistically combine to form the programming language that makes Rails possible. We can even tick this feature list off in our sleep. But it is rare that we are able to articulate the gestalt of these features in a way the nubies can truly understand and appreciate. I know that I haven’t been able to do it!

Fortunately, the pressure is off because Jacob Harris knows how to do it, and he wrote a short PDF book that does precisely this: Rubyisms in Rails (available from Addison-Wesley for $9.99). This book just made my A-list of books I recommend to people who want to know what makes Ruby so special.

From the book’s web page:

Rubyisms is an examination of how the style of Ruby informs the design of Rails. In particular, it looks at a few specific examples of how Rails’ internal code is implemented in Ruby to instruct about Ruby’s design principles. The main goal is simply aesthetic appreciation. But, if you are a beginning programmer in Rails who is stymied in your understanding of Ruby-or an intermediate Rails developer still writing code that looks like Ruby-tinged PHP or Java-this Short Cut will hopefully impart enlightenment and inspiration about the Ruby way of programming. It also reveals how the revolutionary design of the Rails framework can only be built upon the beauty of Ruby.

The book is also available on O’Reilly’s Safari Online service: http://safari.oreilly.com/0321474074/pref01

Very highly recommended!

O’Reilly Ruby blogger Geoffrey “TopFunky” Grosenbach does a podcast interview with Matz.

When it comes to building a Rails application, the one site I constantly reference when finding out attributes for methods such as create_table or finding out what CallBacks I can use to hook in additional functionality, Rails Manual has been invaluable.

Just recently I updated the site with the latest version of Rannotate, which has a ton of new features and functionality enhancement by Conor Hunt.

Most importantly is the ability for you to be able to have multiple versions of a library, such as the first major version of Rails 1.0.0 or the latest version being 1.1.2. You can see all the methods within each version, as well as add comments to each of the methods within each.

The idea is to replicate the same usefulness of the PHP documentation, which I am personally sure is one of the main reasons why PHP has become so widely adopted.

It is important to note that although Rannotate is used on RailsManual exclusively for Ruby on Rails functionality, the library is excellent for documenting all types of Ruby and Rails applications, and could very well be hosted internally for your own API.

UPDATE: Like it too? Digg it!

James Edward Gray II recently announced the release of FasterCSV, which is a replacement library to Ruby’s CSV (that’s “comma separated values”).

The project aims to be faster and smaller than the original, with a better interface.

So far, it’s looks great. It is noticeably faster. The interface is a little different, though arguably a little more thought out.

If you do any parsing of CSV data, I highly recommend you give it a look.

Two great newbie resources made my attention-width this morning:

1) Learn to Program (using Ruby), by Chris Pine. There are tons of books out there that assume you know how to program already and so the title and subject end up being Learn to Program XXXX, but what about Newbies? Chris steps in and decided to use Ruby as the base. His book is due soon as well, which he assures me is even funnier.

2) Rails Weenie. Hey, that’s me! “Sign up and you start off with five points. Offer up points for your questions. The harder the question, the more points you wager.”

Though it’s safe to say you shouldn’t judge a book by it’s cover, the first 50 pages or so should give you a sufficient feel for what to expect in the rest of the book. At least that is the assumption I am making in this first look at Enterprise Integration with Ruby, a beta book currently being offered by The Pragmatic Programmers.

Just digging into the first few chapters, I’m already impressed. Immediately the reader is greeted with the standard quarky (if a bit dry) imaginary scenario to progress through the book with. The example in this case is PragBouqet, a flower shop. Though it would be wonderful to see a book that did not use some sort of E-Commerce as it’s example, this does provide a solid base for clear use cases and sample applications.

The book’s main feature as far as I can tell is the sizeable amount of code examples that fill it’s pages. The user is not given excruciating detail about what each and every line does, but is given a really wonderful description of the problem, and why it’s being solved the particular way it’s being solved.

The author takes an iterative approach, which is common in most Pragmatic titles. However, instead of being a little overwhelmed by wild refactoring at the large scale, Enterprise Integration seems to chisel off smaller chunks at a time. Though the book is intended for experienced developers, this approach is without a doubt favorable for lowering the learning curve.

The narrative approach and the copious amount of output make this book readable even without an irb prompt open. The examples are clear enough where you can get a qualitative feel for them without burning too many brain cells.

The only drawbacks of this approach is that it makes using the book as a reference a bit more complicated. Though the chapters are modular, the example spans across them and if you like to jump in midstream, this might complicate things a bit. Also, the examples are fairly specific to their domain, which means you’ll probably need to read through the example and a bit of the chapter before fully getting a feel for what is going on.

That having been said, one of the unexpected gems of this book is it’s wonderful chapter on ActiveRecord. Most other publications regarding ActiveRecord, whether online or in print, spend a ton of time talking about integrating it with Rails. Of course, this makes sense for that problem domain, but if you’re trying to get a wholistic feel for what ActiveRecord can do for you as an ORM rather than a support library to Rails. , good qualitative sources are hard to find. Of course, Agile Web Development with Rails provides a great reference for this, but if you were left scratching your head a bit… Enterprise Integration with Ruby might provide a good way to fill in the gap.

Of course, there are some of the annoying issues that are to be expected in beta books, such as code abruptly spanning pages and other minor formatting isssues, though these are minimal enough where they do not effect your experience enough for it to matter.

There is also a wonderful quotable phrase in the book:

Don’t like the sunflowers? Destroy ‘em!

Any book that tells me I can destroy wildlife if it doesn’t fit my fancy is a good book to me!

So that’s my impression after 50 pages, what’s yours?