Archives

Users.each do |user|

  puts user.name

end

Ever wondered about how expensive a simple “.each” on an ActiveRecord object collection is. This essentially means for every iteration of the loop, there is going to be a database fetch. Imagine looping over a collection that has 10,000 records (forget millions..). Yes, I have made use of this very same thing a bunch of times without realising the kind of performance implications this could have. Not until last week I discovered that there was a very less-expensive way to do this.

I was perusing the Rails guides casually looking for something else when I hit upon this. “.find_each”. What does this do? It makes looping over a collection of Active record objects much much cheaper by performing a batch retreival of the database records and caching them. The batch size can be altered by passing in a batch_size param like this “.find_each(:batch_size => 500″).

Users.find_each(:batch_size => 200) do |user|

  puts user.name

end

I have almost stopped using “.each” these days and let “.find_each” do the job.

Share/Bookmark

There are a number of approaches out there for validating the format of a URL input. Looking at the different approaches, the most commonly used and the quick & dirty one was of course the regex matcher approach. This is the regex solution which is easy enough to implement but I m not sure if would handle all the different possible scenarios. Regex is tricky (atleast for me ).

validates_format_of :url ,
:with => /^(http|https)://[a-z0-9]+([-.]{1}[a-z0-9]+)* .[a-z]{2,5}(([0-9]{1,5})?/.*)?$/ix

The other possible solution was to use the URI.parse method to determine if the URL is a valid url.  This involves calling the URI.parse method passing in the url and checking if the class for the URI is a valid one.

def validate
  begin
    uri = URI.parse(url)
    if uri.class != URI::HTTP
      errors.add(:url, 'Only HTTP protocol addresses can be used')
    end
    rescue URI::InvalidURIError
      errors.add(:url, 'The format of the url is not valid.')
    end
  end

There’s probably one caveat to the above approach. Sometimes, URI.parse returns a URI::Generic which is the parent of the other URI types in which case even though the URL in question could be a like a valid non HTTP URL, our validation would fail.

The solution I came across most recently was this.

validates_format_of :url, :with => URI::regexp

I think it works great and is probably the best way to validate a URL in rails.

Share/Bookmark

So there was this need for providing ajax-style add/remove item-rows on the last project I worked on.  What I thought might be pretty straight-forward to achieve using jQuery-fu eventually turned out to be little hairy for me.

Share/Bookmark

So Opera Mini for the iPhone got approved and is available in the App store since last night.  I downloaded it this morning and should say I am mighty impressed with it. It is zippy, fast and intuitive.  There was a quite a bit of speculation around whether this would get approved by Apple.  I m happy that Apple approved it.

I did notice a few quirks with the Browser but they are in no way deal-breakers. From my brief interaction with it, the browser looks awesome to me! I dont deny Safari being a solid mobile browser itself but with Opera out now, its “Bye-Bye Safari” for me

Opera Mini for the iPhone

Share/Bookmark

Tiling a Polygon

One of the most challenging problems I came across working on a .NET PDF Annotator and Editor application was to tile a 2-D polygon and also accurately determine the number of tiles that fill the surface of the polygon.  The tiling part was not as much of a challenge as the counting part. The tiled polygon was to be rendered on a PDF document since the application in question is a PDF Annotating and Editing tool. We looked for anything the third party .NET PDF rendering/manipulation API that was used could provide for the tile rendering but there was nothing unfortunately.

Share/Bookmark

So we just went through this humongous (believe me!) effort of upgrading the technical platform for one of our existing Rails applications that was running Rails 2.1, Ruby 1.7 and Mongrel cluster. The goal was to upgrade to Rails 2.3, Enterprise Ruby 1.8.6 and Passenger. It all started out as well as you would think. Updating the Rails gem, Ruby version, installing/configuring Passenger and updating relevant gems was pretty quick and smooth. Some quick and dirty testing of the application did not reveal any major problems or issues. Great! You are thinking the upgrade is mostly done att this point before you move on to the tests in the application!

Tests

Tests can prove to be major hurdle in upgrading Rails applications.  In our specific case,  close to 70% of the tests were either broken or failing due to a number of reasons.  Actually, the number of broken tests was way way greater than failing tests which led us to think the changes in the Rails testing API caused most of these issues.  Some of the issues were also caused by a plugin or gem that was used to support the tests not being compatible with the new API. It took us quite a bit of effort to figure out the reasons for the issues and also find the fixes.

Share/Bookmark

Design patterns. I think they are the one of the most intriguing areas of object oriented application design and development. There are so many out there that can puzzle you each and every time you try to take a crack at them (I can name a few of them that I still can’t figure how they are to be used or implemented).  But a thing that most programmers would agree is if used wisely and appropriately, these design patterns can provide really powerful benefits that can enhance one’s programming experience and also the software that is being built. There are several patterns I have used/implemented in my projects that I think are awesome. I ll touch upon how I used some of them and why every Object oriented programmer needs to master them.

Share/Bookmark

Last week, Karega Scott made a nice post on how Pure MVC makes development of Windows applications using C# simple. I thought I ll piggyback on this post and share some of my thoughts regarding this popular framework. I think the framework, if understood completely and adopted intelligently, has to offer some really cool benefits like :

• Light-weight messaging mechanism (using Notification/Observer patterns) between different parts of the application without having to create custom events/hooks all over the place.
• Highly Decoupled Components allowing abstraction and seperation of logic.
• The application’s testability is enhanced greatly because of the reason stated above.
• A Centralized singleton Facade component that mediates between the different components in the application.
• The use of commands in the framework can help in building complex applications that need to perform several different UI-driven functions.

Share/Bookmark

Fluent NHibernate is an extension of the widely used and very popular NHibernate framework for Microsoft .NET. It is an open source framework that sits on top of the NHibernate layer and utilises all the core NHibernate methods. This framework provides an alternative to the standard XML based mappings (.hbm xml files) of NHibernate. It lets you define the NHibernate mappings in strongly typed and concise C# code.  For those who are new to NHibernate, here is more information.

Share/Bookmark

How many of you folks out there have used the .NET Web browser control for Windows applications? I bet most of you, at some point, must have done some head-scratching as to why Microsoft did not make this control as powerful as it should have been. This control does offer all of the navigation functions and basic browser capabilities but there is lot more that could have been done to enchance it’s utility value. After some persistent fighting with this control in our current project, here are some gotchas that I have to offer.

Share/Bookmark