Rails Development and Deployment

I've been reading up on Rails incrementally, and it looks like FastCGI is the preferred deployment method. I'm not sure how I feel about this. My past experiences with FastCGI is that it's, well, not the most lean bit of code out there. I'm curious if anyone knows this to be different now, particularly on FreeBSD.

At the moment, I'm using my own PHP-based framework for web development, so I'm trying to decide if I should look at using Rails, or continue to develop/refine the system I have and eventually release it to the public. I've found PHP itself to be just an unbelievably fast performer, so I still need to see how Ruby can match up in that department.

It also seems that perhaps there's some sort of fundamental issue with Apache and FastCGI that can make it unreliable. Some people seem to suggest using lighttpd. Apache has been so good to me that I'd need a really good reason to use something else.

As for the Ruby syntax itself, it's been a mixed bag. Some bits are quite elegant, others are just far too obfuscated for my taste. I also think the language itself might have too much syntax. My experience with Cocoa has made me a real believer in the value of reducing ambiguity and syntax complexity.

One of the reasons I don't use Perl is that there's just too much special-purpose syntax. I don't object to that because it's hard to learn, but because it's not great when you're looking at someone else's code. I think one of the reasons Objective-C is so effective is that there's very little syntax. If you understand the syntax for one Cocoa app, you understand almost all of them.

I also prefer Cocoa/Objective-C's explicit naming conventions. I've seen a lot of Ruby code like this:

def bfs(e)
   q = []
   e.mark
   yield e
   q.push e
   while not q.empty?
     u = q.shift
     u.edge_iterator do |v|
     if not v.marked?
       v.mark
       yield v
       q.push v
     end  
   end
end
bfs(e) {|v| puts v}
As well as this:

class Person
  def initialize(name, age)
    @name, @age = name, age
  end

  def <=>(person)
    @age <=> person.age
  end

  def to_s
    "#{@name} (#{@age})"
  end

  attr_reader :name, :age
end

group = [ Person.new("John", 20),
          Person.new("Markus", 63),
          Person.new("Ash", 16)
        ]

puts group.sort.reverse
(both from Wikipedia's Ruby page)

Most Cocoa programmers I know would probably wince at this. It just feels too terse. Less characters doesn't necessarily mean the code is easier to read. Don't get me wrong, I find Ruby to be a lot of fun, but clarity is absolutely vital.

Back to Rails, I'm still trying to figure out what the "it" factor is. Maybe I'm spoiled by Core Data and WebObjects, and maybe I have a different perspective from writing persistence engines myself, but I haven't yet indentified a "top 5" kind of list for Rails beyond data peristence and integration with the Prototype library.

This is still very much an in-progress evaluation of Ruby and Rails, and there's plenty I don't know. The dependence on FastCGI for deployment is a stumbling block. I was really hoping for mod_ruby to fit the bill. I'm also trying nail down what the deal is as far as templating. I'm really happy with Smarty, but I haven't found its counterpart in the Rails world yet.

Comments Temporarily Disabled

I had to temporarily disable comments due to spam. I'll re-enable them soon.