It’s ironic that I just finished watching a VelocityConf video and stumbled upon this gem from TechCrunch. A choice quote:

For anyone who has seen the new Pixar movie, Up, this reminds me of the scene where they have to throw stuff out of the house to make it float again.

Every website (and that includes Facebook, Twitter, EngineYard and Flickr) recommends that your application have switches and levers in place, so that you can turn off features when load is high. This is so that the site remains functional, at the cost of ‘downtime’ for only certain features. It’s a credit to Twitter that they have such infrastructure elements in place.

Twitter has its share of problems, agreed. But it has a bunch of incredible people working on it (as do most web startups), and for them to be subject to such belittling from arm-chair experts who can’t appreciate that running a web application which has a tremendous growth rate is hard work; pisses me off. To use words such as ‘afloat’ and ‘kill-feature-time’ when Twitter has been growing at an incredible rate is misguided.

Ugh.

After half a day’s worth of data-gathering and HTML/CSS/Javascript, I present to you: the EPL GitHub App.

(Works on iPhone too)

Brought to you by: GitHub, JQuery, UiUIKit, Ruby

With inspiration from: Paul Buchheit

It’s still very rough around the edges, and there are some more features I’d like to add. But I’ve found a new interesting side project to work on.

As part of my New Years Resolution to increase my overall productivity and be more disciplined (generally in life), I’ve been experimenting with a couple of text-editors. Tried out vim first because I was quite familiar with it, but it didn’t promise the paradigm-shift that I was expecting to happen in my work-flow.

Enter Emacs

Daniel Fischer’s blog post did quite a bit to pique my curiosity and upon return from my holiday, I bought and watched the awesome Emacs peepcode as well. I’ve been trying to use Emacs continuously for the last couple of days (including at work) and even though I am still stumbling my way a little through the darkness, I am awed by how much power it has.

My likes:

• Embedded shell which gives me the power to write and test code with minimal context-switching. I’m using this one currently and it works much better than the default M-x shell.
• Embedded IRB which offers the same functionality. You can even copy-paste a function from your Ruby buffer to a terminal and execute it! How awesome is that.
• Multi-window workflow. Tabs are great, but being able to see two files side-by-side is better IMO.
• Built-in Git, where you can push/pull/branch/commit with the press of a button.
• Full-screen coding (although I’m not able to toggle it occasionally – have to figure this out).
• All these above reasons combine to give me a piece of software I rarely have to switch away  from while at work – thus effectively boosting productivity.

My dislikes:

• Found it hard to learn/configure in the beginning. Spent at least 3-4 hours trying to get my configuration (forked from topfunky) right. The peepcode was a great help.
• The different key-combinations are slightly overwhelming, but on the bright-side, unlike Vim I don’t need to switch from command-mode to edit-mode and back during coding.

It’s still early days and who knows, I might still head back to good ol’ TextMate soon. On the other hand, if I can push through the initial pain-barrier, Emacs offers an awesome and powerful cross-platform IDE.

I was going to blog about this, but thought it might be better to link to a wiki, which will be easier to update depending on when changes are made, or errors that are discovered.

So here is how you can use CouchDB with Ruby On Rails:

ActiveCouch Wiki Page describing how you can use ActiveCouch with Ruby On Rails

I caught the ‘evented’ bug last week when I started poking around EventMachine for an internal EventMachine based library at work. Basically, I wanted an HTTP library which could be used in an evented fashion while being used in an EventMachine reactor, and in the boring synchronous way, when used outside the reactor. Why do I want this, you ask? Well, the primary reason is that the HTTP client that I am writing should be able to run normally without an EventMachine reactor (for me to test out individually, write specs for, etc) but once it is used in an EventMachine reactor, it should get all the benefits of using the Deferred pattern.

Simple enough, right? Since EventMachine exposes the EM.reactor_running? method, all I need to do is to check if the reactor is running and make the appropriate call. Well, wrong! The built-in HTTPClient which comes as part of the EventMachine library (EM::Protocols::HttpClient) had a lot of problems with the initial set of tests that I was conducting. As far as I understand, it was because EventMachine’s HTTP parser is not robust enough to handle streaming HTTP data.

Enter Stage Left, Zed Shaw

Thus began my search for a proper HTTP parser which could be used as part of my networking library. I stumbled upon the Rev project (which is similar to EventMachine in many ways, and exposes the libevent library to Ruby). Rev has an HTTP client which uses Rev semantics, but whose parser is based on Zed Shaw’s immortal Mongrel parser.

Finito

Armed with Zed Shaw awesomeness, I was able to easily use the modular, fast HTTP parser from the Rev project as a Ruby-C extension and hook it up to EventMachine semantics, and thus was born EventedNet::HTTP !

The API to make a simple HTTP GET request, is like so:

EventedNet::HTTP.get(URI.parse('http://www.google.com'), :callback => Proc.new {|status, body| puts "Status: #{status}, Body: #{body}" })


Note: The callback parameter can even be a Method object, please see evented_get.rb for an example of how that works.

Installation

EventedNet is available at GitHub. In the coming weeks, I intend to add more functionality (including HTTP authentication) and more specs so as to make the library more complete. As always, patches and fork pull requests are always come!

You can also install the gem from GitHub:
$ gem sources -a http://gems.github.com (you only have to do this once)
$ sudo gem install arunthampi-evented_net

A few months ago, my friend Chu Yeow and I released a Ruby gem called ActiveCouch which was designed to be a very elegant Ruby wrapper for the exciting new phenomenon – CouchDB. ActiveCouch was my first shot at a Ruby library and I had a lot of fun creating elegant DSL’s (a lot of which were inspired from ActiveRecord and ActiveResource). In essence, ActiveCouch lets you define models like so:

class Pet < ActiveCouch::Base

  has :name, :which_is => :text, :with_default_value => 'Tom'

end

class Person < ActiveCouch::Base

  has :name, :which_is => :text, :with_default_value => 'McLovin'

  has :age, :which_is => :number, :with_default_value => 0

  has_many :dogs, :class => Pet

  has_many :cats, :class => Pet

  has_many :pets # Automagically assumes that 'pets' corresponds to the class Pet

end

While this is great, I found myself using these semantics more often in other Ruby libraries that I started to work on. Thus was born – SuperModel.

SuperModel’s aim is to wrap semantics such as has, has_one, has_many (which are familiar to many Ruby/Rails developers) in a re-usable library which can form the basis for other such libraries. For instance, I am currently in the process of re-writing ActiveCouch so that ActiveCouch::Base inherits from SuperModel::Base. By doing so, all the ‘modeling’ semantics will be taken care of by SuperModel and ActiveCouch can deal with interfacing with CouchDB.

SuperModel also gives you serialization for free (currently only JSON, but future releases will also include XML, YAML, etc.) So, methods such as to_json, to_xml and to_yaml will let you serialize/de-serialize SuperModel objects in/from any format that you want.

class Person < SuperModel::Base
  # If you don't specify a 'type', it defaults to string
  # while converting to JSON
  has :name
end

# Create a SuperModel object
p = Person.new(:name => 'McLovin')


# Another way you can create a SuperModel object
p1 = Person.new do |person|
  person.name = 'Seth'
end

# JSON serialization
p.to_json # => {"name":"McLovin"}

SuperModel is hosted at http://www.github.com/arunthampi/supermodel and the gem is available from GitHub as well. [Note: There are some problems currently with installing gems from GitHub, please refer to the GitHub RubyGems page for pointers]