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.

The approach that I used to implement this was to use a hidden item(a div with some content in this case) and clone it using the jQuery clone() method to make a new copy of the item and then append it to the collection under a parent div.  The cloning and adding worked like a charm. What bothered me was the remove of the item-row. Each item-row had a remove link/button to delete the item. The remove was supposed to work using the jQuery click event handler on the remove link/button. It did’nt work as expected .  The click event handler was’nt getting hit for some reason and I did not have clue as to why as the same remove handler was working without issues in a different section on the same page.

What I came to my rescue was FireQuery.

FireQuery is a cool little add-on for Firefox that integrates with Firebug. It allows inspection of jQuery expressions, methods, events in the firebug console making it a great debugging assistant for jQuery. Using FireQuery, I was able to confirm that the cloned item-rows did not have the click remove handler attached to them. This made me realise that the clone() was not copying the jQuery event handler after all.  Thanks to Google, I finally figured out clone(true) would fix the problem and it did! Apparently, clone(true) is like a deep copy of the DOM element/object along with its events.

I m a jQuery newbie but I have already started loving it over Prototype and other JS libraries I have used in the past. Hoping to make more use of it (and FireQuery too!) in the future.

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.

So we set out to use C#’s native GDI+ library to render the tiles for the polygon.  After trying out different approaches to accomplish the rendering of the tiles, we discovered the one that would work best. The idea was simple. Every 2-D shape on the drawing surface has a bounding rectangle that encloses the shape. Starting from the top left bounding point of the rectangle, iteratively render a rectangle (tile with whatever length and width) across the X axis until the right most edge of the rectangle and this iteration needs to happen over the Y-axis (not sure if I explained clearly enough .  So now we have rectangular tiles laid out across the bounding rectangle for the polygon. GDI+ gives us a clip method that allows us to clip the rendering surface to a specific graphics path or region. Using the clip method, clip the drawing surface to be the graphics path for just the Polygon so that only tiles within the polygon’s graphics path get rendered on the screen. We could apply other transformations to the rendered tiles like offseting, rotation or a gap between each tile.

Coming up with the most efficient way to count the number of tiles (including partial tiles) was a little trickier than rendering the tiles.  It turned out that the ideal approach was to essentially count each tile as it was drawn and checking whether the tile was partially or fully part of the polygon’s graphics path/region. So, there is this method Region.IsVisible that lets you test whether a rectangle is partially or fully contained within a graphics region. During the rendering of each rectangular tile, the method was used to check whether the tile was going to be part of the region associated with the polygon and was counted if it was going to be. Even though, this was the most efficient solution for the problem, we did nt see 100% accuracy sometimes when rotation transformation was applied to the tiles. Still havent found an answer to this anomaly.

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.

Plugins

I think this is other major pain point. If your application uses a bunch of plugins to support what it does, then be wary of the roadblocks they can pose when it is time to upgrade Rails or Ruby in your application.  The problem mostly arises because of the fact that the community or the user group that built the plugin dont continue to support it or doesnt bother to make it compatible with newer versions of Ruby or Rails. In situations like these, you get thrown into a state of dilemma thinking about whether to write a new plugin to replace the existing one or fix the existing one both of which could be time-consuming.  It makes sense to spend time finding about what exactly is the need for the plugin in the application and if it is indispensable etc before making a wise decision.

Deploying the upgraded application

Though this may not be as hairy as the first two, it could be still prove to be a challenge especially when your the application server is changing (Mongrel -> Passenger).  I think it is important to ensure the script is modified appropriately and is tested adequately in your staging environment before you deploy the upgraded application to the real-world.

Session handling issue with Rails 2.3

For the benefit of Rails community out there, I d like to briefly recount one of the problems that caused me a quite a bit of headache during the upgrade.  The application in question is a content management website with multiple subdomains. The issue that I saw after the upgrade was after user logged into the one of the subdomains in the site and navigated away to a different subdomain, the user got logged out. When the user returned to the subdomain where he logged in originally, he was logged in again.  After several hours of effort trying to debug the issue (at one point,  I was even thinking about stripping out Restful authentication and plugging in Authlogic), this post saved the day for me.  It boiled down to setting this in the <environment>.rb file for the different environments :

config.action_controller.session = {
  :domain => ""
}

This allowed the session information to be persisted across multiple subdomains of the site.

Some Advice

• Generally, the amount of effort to upgrade is going to be directly proportional to the time between the upgrades. So, upgrade your application often!
• When choosing plugins or gems to support your application, consider the upgradability of these before you decide to use them!
• Last but not the least, spend atleast 25% of the time necessary for the upgrade itself to estimate how long it might take to get it done

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.

Factory Method

This must be one of the most commonly used patterns out there. We indeed have used it the most in our projects. The crux of this pattern is essentially delegating the task of creating objects to a method that basically takes in information about what kind of object is to be created etc.  There were a number of instances in the applications we built where there was a base domain object that had a bunch of derived types. In most of these instances, single method/interface that returned the base domain object type but created instances of the appropriate the derived type was used. The benefit? The object creator is decoupled from the users of the objects and makes the code more reusable and maintainable.

Dependency Injection

I m absolutely in love with this design pattern. It is a very effective design approach in my opinion. What it advocates is lazy/runtime injection of object dependencies or modules instead of hard-wiring them.  There are a number of third party dependency injection frameworks like Spring, Object Builder etc that let you implement dependency injection out of the box. A very simple example of how I used this on a recent project : Consider the application needs to talk to a remote service for what ever reason. We also built out a fake service that mocked the real remote service to enable us to test/run the application when the real one was unavailable or being developed. We needed a way for the application to swap dependencies (basically the real service and the fake one) at run time. Spring .NET’s dependency injection enabled me to implement this.

Command Pattern

A really powerful design pattern that helped us a great deal in implementing an undo/redo feature  in one of our desktop application projects. The idea is pretty simple. Every operation that you want to be undone/redone is encapsulated in the form of a command object that contains information about the method or delegate that needs to be invoked for that operation, parameters for that method or delegate, the undo method etc. Every time, any such command is executed, it is pushed to an undo stack. If the command needs to be undone, it is simply popped off the stack and the undo method is invoked. There is a redo stack for handling redo operations.

Other patterns that I have used widely are the Singleton, Facade, MVC, Pure MVC and MVP. These are effective in their own different ways.

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.

The framework’s limitations (or should I say “perceived weaknesses”) are :

• Registering and removing components on the Facade? Could there have been a better way to accomplish this? May be.
• Named references for components were not helpful at all.
• If the framework’s notification mechanisms are not used appropriately,  there are chances of infinite message loops leading to debugging hell.

There was considerable ramp up time involved in understanding the framework’s capabilities/strengths/weaknesses. I still don’t think I have realized the complete potential of Pure MVC  and I hope to explore more of it these coming days.

Related Services: .Net Application Development, Custom Software Development

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.

 Traditional NHibernate XML mapping

 <?xml version="1.0" encoding="utf-8" ?> 
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" 
  namespace="QuickStart" assembly="QuickStart"> 
 
  <class name="Cat" table="Cat"> 
    <id name="Id"> 
      <generator class="identity" /> 
    </id> 
 
    <property name="Name"> 
      <column name="Name" length="16" not-null="true" /> 
    </property> 
    <property name="Sex" /> 
    <many-to-one name="Mate" /> 
    <bag name="Kittens"> 
      <key column="mother_id"/> 
        <one-to-many class="Cat"/> 
      </bag> 
  </class> 
</hibernate-mapping> 

Fluent NHibernate equivalent

public class CatMap : ClassMap<Cat>  
{  
  public CatMap()  
  {  
    Id(x => x.Id);  
    Map(x => x.Name)  
      .WithLengthOf(16)  
      .Not.Nullable();  
    Map(x => x.Sex);  
    References(x => x.Mate);  
    HasMany(x => x.Kittens);  
  }  
}

 Why use Fluent NHibernate? Here are some benefits that it offers:

• It favors convention over configuration and overcomes the repetitiveness that is there with NHibernate. For instance, NHibernate requires string properties to be not null and have a default value. You don’t have to handle this if you go fluent.
• By getting rid of XML based mappings, it paves way for easy-to-read code that can be refactored and maintained in a simpler way. The mappings sit along with your code so any refactorings/changes to the code will cause the mappings to be affected as well. This helps catch compile errors/bugs with mappings.
• One other obvious benefit is that the XML verbosity of NHibernate can be avoided.

I think this is a good place to start picking up Fluent. You find a nice little project example that talks about mapping a simple database schema and building an application to read data using the fluent mappings.

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.

Where the heck is print?

There is a print method that is available on this control which directly prints the current web page without popping up the print dialog. This is fine but what if I want the print dialog to be show up? After some digging into the msdn documentation and googling around, I determined there was a way to do this. The trick is to use the execcommand method on the browser’s document object. The syntax goes like this: 

 Browser.Document.ExecCommand(“Print”, false, 0)

I believe this method basically executes the specified command on the underlying Microsoft active-x/html control. There are number of different commands such as cut, copy, paste, undo, redo etc that are available. One thing to keep in mind is that all the edit commands operate directly on the DOM elements of the HTML document. 

What about Search?

This one did take quite a while to figure out.  The browser control did not offer anything directly for searching the current web page.  If  its the Control-F search (that you normally get to see on the browser) is what you want, there is a simple way to enable that on the browser control.  Set the WebBrowserShortcutsEnabled property to true and you have it. This also enables other shortcut operations like control-C, Control-V, Delete etc.  I came across a number of posts that talked about using interop to get to the underlying active-x control to accomplish functions like search, copy, cut, paste etc. I guess you can avoid all this trouble by making use of this property on the control.

Any other gotchas with this control? Feel free to let me know.

Share/Bookmark