Sohan - on software artisanship

Are You Still Parsing HTML Element Ids?

2012-01-22T20:15:00.000-08:00

To render a list, often times we use repeated HTML elements with a similar template. For example, the search results in ebay.com is a list of divs, each containing different data in the same template. In a server side, this rendering code is somewhat similar to this:

If you noticed, a product with it's database id = 123 will be rendered inside a div with id="product_123", and similarly div id="product_456" will contain the product with id = 456.

With such ids, we can write JavaScript code that can extract the database id of a selected product to do interesting things, for example:

This is a useful and a common technique. However, in this era of HTML5, we can make use of its custom attributes feature to write a clean JavaScript event handler without the help of parsing. Here's an example:

I will never parse my HTML element Id again. What about you?

Object Versioning is an Open Design Problem

2012-01-17T21:20:00.000-08:00

This unsolvable maze is a local food from Bangladesh, known as Jilapi
Photo credits to udvranto pothik

Object Versioning is often required by a business rule, for example, to maintain an audit trail or to be able to revert to a previous version, etc. This is the 3rd time in my career where this Object Versioning requirement made me think like -

There's gotta be an easier solution!

But, I am yet to find one. So, I am thinking it's one of those open design problems, may be.

To clarify the requirement with an example, let's consider the following scenario:

A lawyer is preparing a document for one of her clients using a software. On January 17th, she needs to take a look at the version of the same document from May last year so that she can backtrace some changes that took place during these months.

Lets assume the lawyer is using a software that stores the documents in a relational database with the following schema.

A Document has many Evidences, each provided by an EvidenceProvider

Document (id, client_id, case_id, name)
Evidence (id, document_id, evidence_provider_id, details)
EvidenceProvider(id, name)

Now, given the versioning requirement how would you design your data model?

Here's a couple of points that your design should address at a minimum:

Going back to a version means a complete snapshot of the old version of the document. So, the version of May 1st should only bring the evidences that were there on that very day.
As a new version is created, it should inherit all previous evidences.

As I have mentioned earlier, I am yet to find a good data model that can take care of these concerns without over-complicating everything. Let me know if you got a beautiful solution to this problem.

However, in my latest project, the requirement is even harder. It's somewhat like this:

The lawyer may have some documents in the "work in progress version". This means, if she needs to print a document for the court, she only wants to print the last "good version", skipping the "work in progress version".

Also, when there is such a "work in progress version", she needs to attach any new Evidence to both the last "good version" as well as to the "work in progress version".

Well, now you see the design of a data model for Object Versioning becomes really messy and unintuitive.

So, here's my question to you - how would you design a solution for this?

Care Driven Development: Javascript

2011-11-20T17:54:00.001-08:00

There is * Driven Development, where they listed "all possible thing" driven development and dedicated a whole website to it! Well, I am adding one more to the list, "Care Driven Development", with an emphasis to Javascript coding.

Javascript coding, do you care enough?

CSS is the most hairy spagetti piece of almost any web project. And its not leading by a far distance to it's first cousin; Javascript. But, the good thing is, it just takes a little care to clean the bush out of Javascript and make it pretty.

Do you care enough not to use the following ever again?

$('#deep_under_the_ocean').parent().parent().hide()?
$.ajax(url: 'bank_accounts/transfer_money', amount: 500...)
$('#eiffel_tower').height($('#paris').height() + $('#eiffel_tower base').height() + $('#eiffel_tower tower').height() + ...)
populateNewYork('east', 'north', 50, 100, 23, ...)
$('.shark').click(function(){$('.small_fish').attacked(function(){...})})
parseInt($('.selected').id().split('-').last())

I am compiling a list of such careless JS coding examples and this is just a start. If you have a few to add to this list, please keep sending!

Enterprise Software Projects: oh, yeah!

2011-11-18T21:32:00.001-08:00

I just rolled off my first ever enterprise software project couple of weeks ago. After staying six months on the project and while the memory is still fresh, I thought I would write a retrospect on the project and on my role.

The program is rather big, I guess it had ~300 people for the last couple or so years. I joined late for the program. So, by the time I went there, a massive amount of work has already been done, meaning a huge learning curve for me. On retrospect, I think I did well :)

My team was small, 4-5 people including 3 devs. But we were responsible for really high value enterprise integration work, especially, linking the two most important applications in the program. This was a great place to learn some of the core business domain specific knowledge and I loved it!

However, enterprise integration stuff is full of XML messaging and translation. While XSLT works when it works, in our situation we had too much logic and stateful data involved in the translation. So, we had to write a hell lot of custom code for all the XML messaging... and it sucks! Why?

Service APIs change all the time!

I was mostly writing Java at work in this project for the first time in my professional career. This was a big change as well as a good exposure, considering my recent work mostly being in C# and Ruby. In retrospect, I would say, I would rather not use Java, its a great platform but offers your an aging language.

Being in the enterprise world means dealing with enterprise service buses, queues, oracle database, weblogic, load balancers, risk and compliance and you name it... sometimes the complexity of these things seemed to be unnecessarily troublesome, but then again, at times they made sense as well.

People factors matter way greater than any other factor in such a big project. In retrospect, I think a hierarchical system often leads to longer meetings, useless communication and less ownership for most people.

I will continue this post to a second episode where I will talk about development practices, challenges with multi-project communication, politics and power relations etc. Stay tuned!

Aligning an HTML DIV Inside Another One

2011-11-13T15:57:00.001-08:00

Across different projects, I have found people taking CSS shortcuts for translating the Photoshopped design templates into HTML. Back in the days, layout used to be all Table based and it was kind of straight forward to fit everything into grid cells. However, with CSS styling the extra flexibility to put elements in any arbitrary layout came extra responsibility - to make sure things still align nicely while being fluid to accommodate different screen resolutions and form factors.

Aligning the child div in red inside a parent div in green using CSS

Here's a quick and dead simple example to create CSS alignment for a div inside another one!

Pro Tip: Use position:relative for the parent div and position:absolute for the child div.

This will make sure the parent is positioned relatively to other elements in the page. However, the absolutely positioned child can be positioned anywhere inside the parent without making the whole layout fixed.

Using instanceof is mostly a Code Smell

2011-11-01T19:04:00.000-07:00

When using static programming languages such as Java, often time I have seen people writing methods that accept Object as a parameter. These methods typically don't really work on any Object, but works with multiple types of classes that don't have any common base class. Here's an example of such a method:

As you can see in this example, the process method actually expects one of CleanFloor or LaunchRocket instances. However, since the two don't have a common subclass, it falls back to an Object type. And that results in the smelly code as you see in the example.

An ideal solution would be to change the design of the classes so that you can either use a common base class or a generic method. But if you can't just do that

Get rid of the instanceof anyway!

However, this doesn't need to be smelly. Turning to basics of OO programming concepts, you will recall that there's this thing called method overloading that is specifically there to solve this very problem.

It seems so obvious in this example that you might question, why someone would use the former code? Well, I have seen quite a few of them and if you search for instanceof in your Java project, I won't be surprised if you see a few code fragments that match the former example.

Nightly Build is a Warning (or Horror)

2011-10-04T15:32:00.000-07:00

Photo credits: insidethemagic

I think, Nightly build is an anti-pattern for Continuous Integration. If you are integrating continuously, then you shouldn't need a nightly build, that would be too discrete :(

If you already have a per-commit continuous integration setup, you shouldn't need the so called nightly build unless there's something bad about the code.

Often times, builds taking >10 minutes are put in the bucket of nightly builds.
Some people put batch processing related tests under such nightly builds. A colleague told me they used nightly build to clean up resources (disk space, recreate the database etc.) on a nightly build - to ensure the apps worked fine on a fresh state.

Under most circumstances, a nighly build means something long running. That in itself can be an indication of poor performance.

But what I have seen is, when such nightly builds are broken - they are rarely looked after or cared for. Because, first thing in the morning, who the hell wants to look at that broken nightly build? Even if someone takes a look, since its long running, it might well eat up all morning to actually try/fix/commit changes and see it go green again! Since it takes longer to make the build green, people keep delaying it for later... meaning

it becomes generally acceptable to let the nightly build stay in RED.

And once people get used the redness of the nightly build, they start ignoring it, inevitably.

So, here's what I would do:

Avoid nightly builds altogether.
Avoid nightly builds altogether.
Avoid nightly builds altogether.
Otherwise, make one person from the team responsible for the build (rotate people).

The Perils of Soft Delete

2011-09-28T14:23:00.000-07:00

Often times, applications cannot get rid of the database records for business rules. For example, if you are a cable TV provider, you might have a customer calling you to stop the National Geographic Channel subscription from next month. Ideally you would like to delete this record, but you can't do it until the effective date:( If you delete it, the next invoice will not be able to charge for this channel, although it's still being used.

In such scenarios, its common to fall back to a soft delete model. As an example, here's a little code:

This code looks simple and harmless at a first sight. But, as you develop your app, you'll run into a lot of issues from this. Here's a short list:

You need to take care of cascading soft delete, for example, cancelling a customer's subscription needs to cascade down to all channels and other objects under it.
Whenever, you are listing the current subscriptions of a customer, you need to filter out the ended ones.
You need to figure out a strategy to periodically clean the ended subscriptions so that your database is not filled with outdated data.
If you have a business key used as a primary key as well, you will be in trouble if an ended subscription is restarted.
Your code will eventually have a lot of if-else blocks to apply changes to only on active objects.

So, what is the solution? Its best to avoid them as much as possible. Richard Dingwall has a detailed blog post on some alternative techniques to avoid soft-delete. But if you have to have soft delete, as shown in the example, its worth remembering the aforementioned points.

Hardcoded URLs in Javascript are too Slippery

2011-09-23T10:47:00.000-07:00

Photo credits to Esteban Cavrico

I was working on a web project that lets you delete some records using Ajax. The following is just an example, but you might be familiar with a similar code already:

This code used to work when the DELETE endpoint was indeed under '/blog/posts'. However, at some point a developer wants to remove the '/blog' from all the endpoints to put them directly under '/posts'! You can see, in such cases it is very hard to catch the bug that would be caused by the faulty JS code.

Here's a quick recommendation:

Don't hardcode the URLs (or anything that is actually a server configuration) inside your JS.

This is a code smell, as its duplicating code. But its also dangerous, because its hard to catch/fix these defects since they can be buried deep under an untested Javascript file. Instead feed this data from your server side code and you'll mitigate risk that way.

Excess of Private Methods is a Code Smell

2011-09-20T08:55:00.000-07:00

Private methods, when used meaningfully, are a great tool for writing beautiful object oriented code. But as many other things in life, excess of private methods is bad, too!

In my opinion, we use private methods to:

1. isolate a block of code to be reused inside the class.
2. extract code from another method for code readability.

Now, taking these two use cases in mind, here's an easy conclusion:

The lower the ratio of public to private methods, the harder it is to write unit tests since the "units" are potentially larger.

I don't know if there is any rule of thumb, but you will smell it when you see your unit tests require a lot of setup and assertions. Here's a code example from the Play! framework, an MVC franework for Java developers.

ActionInvoker.java

You will see there are public methods with 100+ lines. I hope you agree with me:

"The ActionInvoker.java code is not readable"

For the sake of readability, introducing private methods with good names would help. However, that doesn't eliminate any of the possible code paths from the public methods. So, if you are lucky, you will see really long unit tests with complex setup conditions and mock expectations. Otherwise, there will be no tests at all! Without any tests for such long and complex methods, use them at your own risk. I won't :(

Disclaimer: I like the play! framework a lot. However, if you take a look at their code and if you think unit testing is important, you'll see they have a lot of rooms for improvement with simple extract method refactoring.

Quiz: C# Async and Await. What is the Output of this Code?

2011-09-16T15:15:00.000-07:00

C# 5.0 (CTP version at this point) has support for async and await to allow clean implementation of non-blocking IO using a task-continuation model. I was just playing with it and here's the sample code to tease your brain. Tell me what is the output of this program?

How to Extend a Ruby Module?

2011-09-16T15:07:00.000-07:00

Modules in Ruby are like classes with a few important differences. One of the differences is, a module cannot inherit from another module using the same syntax as class inheritance. However, its pretty easy to inherit a module's method into another module, by just using the include ModuleToInclude syntax. Here's an example if you are looking for one:

Should You Unit Test Interaction with Static Methods?

2011-08-15T10:18:00.000-07:00

No. You should not. Here's an example:

If you are somehow mocking this static method, you are potentially making it dangerous for other places where this static method is used. Eventually, this will create red test results that are hard to find and make your tests dependent on each other.

How to list all classes that include a module?

2011-08-12T08:03:00.001-07:00

Here's the code:

Should you unit test methods with a lot of mocking?

2011-08-09T22:38:00.000-07:00

Well, anytime you have a lot of mocking, it is probably a smell. Particularly, a first smell is violation of the law of demeter. However, we were having discussion about whether or not we should write unit test for something like the following example:

As you can see, this method actually does a quite important task. It invokes the search method with specific parameters that will determine your search results. Now, we were debating whether or not the example unit test actually brings any value.

Here's what we have discussed:
Pros:
It confirms that you are actually calling the third party method with the right parameter.
Cons:
The test is too tightly coupled with the implementation, so it will break if something changes inside the method irrespective of its actual output.

But we failed to come to an unanimous decision on its usefulness. We all agreed on the point that it definitely needed some integration tests to make sure the search had actually worked.

Here are two questions for you:

Would you skip the unit test altogether for this method and rely completely on an integration test? Why/Why not?
If you are to rewrite this code, how would you write this using TDD?

Looking forward to see your input on this!

Ruby present? Method

2011-08-05T22:12:00.000-07:00

Ruby has a nice little keyword called unless, that checks the opposite of if. So, you are probably used to a code like this:

return customer.first_name unless customer.nil?

If you haven't used present? before, you can in fact turn the above unless into a more familiar and easy to understand if statement:

return customer.first_name if customer.present?

So, in most cases when you are using unless with a negative condition, you can use present? and if instead. I find it way easier to read.

present? does the opposite of blank?. So, you will get the following:

nil.present? #=> false
[].present? #=> false
"hello".present? => true
["a"].present? #=> true

Hope it helps!

Constructors Are Methods, too!

2011-07-26T10:52:00.000-07:00

Yes, if your constructor does something meaningful. This is just like another method and should be treated equally for unit testsing purpose. Here's an example that should need unit test:

It looks simple, so testing it should be simple, too. I would only skip the default constuctors, as long as they don't do anything interesting.

How to Annoy Your Customers? Learn from GoDaddy Account Status Email

2011-07-22T12:24:00.000-07:00

Just looking at this screenshot alone, what do you think it is?

I have a few domains registered with GoDaddy. I went with them, because at that time, I didn't know of another renowned provider. But they have always been the best of producing the most confusing ever user interface. The account status email is one step ahead in that same direction.

This is how it starts:

At the top right corner, it says July 2011, in grayed out font! A deliberate attempt to de-emphasize the statement period!

Just below the date, there is a fake input box and a button labeled Go. This is an image and if you click it, it will actually open a new page instead of asking for user input right inside the search box. This is just following the theory of most surprise (as opposed to principle of least surprise)!

Next, in red background, they welcome me by saying, Welcome, S. M. Sohan! Customer Number: ### wtf? Customer Number? Do I give a shit what my customer number is? Why is the welcome grouped together with search and contact? How are these related?

Then it says, Log in to your account on our secure website to view your most recent account statement. What does this mean? Does it mean, this statement is not recent? Is this not secure?

Then it says, Summary of your account as of 7/21/2011**. That f'ing footnote will tell you that, the information may not reflect recent changes! What? Is this good enough till 7/21? If not, why do you even send this bullshit to me?

Then it has 4 boxes side by side. The first one, Messages has Alerts: No, Notification(s): Yes. View now is a button to their site. How stupid is this? Why bother saying alerts "No"? If you know I have notifications, why not put it right here? Why are you confused about notification"(s)" - you should know if its just one (notification) or more (notifications). How lazy is that?

Items Expiring is the other funny one. It says, Domain names: No. Then it says renew now. What? You're saying nothing is expiring. Why on earth I would renew something?

Then it takes almost 50% of the screen for asking me to contact with them through a number of channels including Facebook. Really? Facebook fan of GoDaddy? Crazy people!

In the end, they don't care putting a note of thanks, let alone personalize it with the name of an actual person. Isn't it rude to end an email this way?

Now, with all these hammerings - as if it fell short of creating enough fun, it says, More for You: followed by tens of fine print links to things that don't matter at all to me. Oh boy! you are awesome!

I am not a designer by any means. However, I think, even I can design a better version than this crap. Here's my version in a screen mockup.

Avoid Duplication in Config Files

2011-07-11T12:21:00.000-07:00

Any kind of configuration file, be it an ugly xml file or a prettier yml or properties file, its been a source of frustration to me. Here's a list of few such pain points:

There are two config keys that point to the same value. e.g. db_username=master, data_source_user=master
There are two config keys for urls that point to the same domain, but different paths. e.g. market.com/cameras and market.com/undies
Config entries with placeholders. e.g. weather_url= weather.com/%s or weather_url= weather.com/%s/hourly
Config entries with default values that should not default to anything.
Config entries that are required but don't fail the application deployment when not set.

Are you having to deal with similar pain points? Some more?

How Not To Provide Feedback When Doing Code Review

2011-06-25T09:30:00.000-07:00

Code review, as any other review process, can often be an attack on someone's ego and incite anger and frustration. Being both on sending and receiving end of such code reviews for years, I have learned a few how-not-to-do-it, or as one might say, anti-patterns of providing code review feedback. Let me know if you agree/disagree with me on the following:

You are always reviewing Adam's code while Adam is never reviewing yours.
Your feedback is like "Adam, you should break down part of this method into a private method" instead of "we can probably extract a part of..."
You are always suggesting, for example "we should do x and y and z", instead of asking interesting questions "can we do x? what if we did y?"

Service API and Exceptions

2011-06-22T12:58:00.000-07:00

Too often I see I am using a REST/SOAP API to talk to a third party system that frustrates me because of poor error messaging. Here's an example to illustrate a typical frustration:

Call: city_service.update_residence_address(city_dueler, new_address)
Response: <status>Failed</status><error>Invalid address</error>

But the address just seems right to me. So, I need to know specific reason about why the address is wrong. The error message leaves this critical detail. What happens next is, I look for the log files created by the city_service, conceptually supposed to be a third party hosted service. To do this, I SSH to the server, then cd to the logs folder and get lost in many of the cryptic log files. Then eventually I find a log and if I am lucky, I find something like the following:

InvalidAddressException at:...
...
Street number is not listed..
...

Now, I know I had an issue with the streer number. But I can see this only after I looked into the log of the thirdparty server. In an ideal case, I don't have an access to their server. Even if I have it, I cannot easily understand their logs and stack traces! In most API calls to third party applications I have had this frustration to varying degrees.

Here's a lesson learned:
Next time you expose an API for another app, expose error messages as specific as possible - so that, no details is left buried into your log files.

NuGet - Why Should You Care?

2011-03-17T12:56:00.000-07:00

Traditionally the .NET community, or more appropriately the users of .NET framework relied on products from Microsoft - so, in a product stack you are likely to see almost everything coming from Microsoft. However, some community contribution made its way into the main stream - for example, NUnit or Log4Net. But you can literally count the number of such main stream non-Microsoft products in your development stacks with your fingers (sparing a few)!

NuGet makes it easy to share your reusable library/utility code to the community. So, if you've done something cool that you wanna share, you should utilize the platform.

One important difference between your and Microsoft's contribution is, whatever you are contributing is likely to be a piece of software extracted from one of your real world projects. On the other hand, Microsoft attempts to produce something based on public interest and their imagination - often missing the real pain that you or I have. So, this mismatch between the designer and the actual consumer of the product often leaves a lot of opportunity for you. If you did something to solve your own pain on a project, its likely you're not alone. So, share it with us.

NuGet official feed and website is a great place to get feedback.

Did something cool? Well, you should feel good as people will use and appreciate your work. More importantly, they will provide you with interesting ideas and reviews that you haven't thought about. Does this sound useful to you? People will go even further - they will directly contribute to the project with code!

NuGet will challenge you with competition from other contributors.

A healthy competition is a great way of learning from others too. You'll see other contributors attacking the same pain you are solving in a different approach, often directly challenging you! You love challenge, don't you?

If you need hard numbers to get motivated, here's some data from my MvcMailer project:
Downloaded 600+ times in less than 2 months.
Received 60+ emails from people using MvcMailer, mostly encouraging feedback.
300%+ increase in my blog traffic.

Bottom line is, you should publish your NuGet package if there's any cool project you have done. Or, look out for what others are doing and possibly contribute with your code/suggestions. If you need an idea, look for StackOverflow questions, you'll see there are solvable problems that people are fighting against time and again.

My 2011 Q1 developer roadmap

2011-03-14T08:56:00.000-07:00

For me, 2011 Q1 has so far been a good exposure to new techniques, tools, articles and books, thanks to ThoughtWorks book allowance! However, if you are interested, here's what's keeping me busy:

User Experience: I find a good user experience is THE thing that you want in anything you design, and if you are writing a software, its even more important. After I read a few books, I have a feeling that its not just a common sense approach, it takes some education and a deep care to produce something usable. Check out my reading list at http://smsohan.com
HTML5: HTML5 is so more than just knowing How To Meet Ladies (HTML)! The popular browsers are all way ahead of the official HTML5 release date, so if you are building something on the web, its time you give it a real shot. Again, I shared my reading list on my website.
.NET NuGet: Microsoft .NET just got a major component, NuGet package manager, that greatly simplifies the sharing and consuming of reusable libraries. Already there are tens of thousands of downloads for the popular .NET libraries and I believe its just a start. So, if you've done something cool in your project and want that to share with the .NET crowd, you should consider NuGet as a distribution channel and get some traction on it.
MvcMailer: MvcMailer has got all my developer attention in the recent past. If you haven't checked already, I highly encourage you take a look at its features at this page and you'll see its a full stack elegant emailing solution that you need in your ASP.NET MVC projects. However, while working on this, I got familiar with the internals of the ASP.NET MVC source code and I consider this as a good experience.
Functional Programming: Did you learn one? Which one? Please suggest me your favorite functional language. In the remaining of this Q1, I want to spend some time on a functional programming language, probably F#.

Its inspiring to see Calgary getting warmer these days - hope we get some outdoor soccer by the end of 2011 Q1, that would be awesome!

MvcMailer 1.0 Released

2011-03-07T09:03:00.000-08:00

Just released MvcMailer 1.0 as promised in my previous post. Download your copy using the following:

Install-Package MvcMailer

Of course, you will find a comprehensive tutorial at: this github wiki page.

Whats Coming in MvcMailer NuGet 1.0?

2011-03-04T12:17:00.000-08:00

Thanks to 365+ downloads of the MvcMailer NuGet before it hit version 1.0 and now its time to wrap up the NuGet package for an official first release. I got several encouraging feedback on this package and here's what you get from this first release:

Use Scaffold Mailer to generate your mailers with views.
Compose rich emails using your favorite ASP.NET MVC view engine.
Use master pages and pass data using ViewData/ViewBag.
Send multi-part emails for both text and html email readers.
Put images inline so that they are visible even when email client is offline.
Write unit test for your mailers and controllers that use the mailers.
Send attachments.
Send emails asynchronously.

To my knowledge, MvcMailer is gonna be the first full stack ActionMailer like Emailing library for ASP.NET MVC 3. If you are an ASP.Net MVC programmer who deeply care about high quality work and maximizing efficiency - you gotta try MvcMailer 1.0 for writing pretty email sending code.
The github wiki page has everything you will need to know about MvcMailer. Version 1.0 comes out on Monday. Stay tuned.

ActionMailer 3 - why do you call instance methods as class/self methods?

2011-01-28T09:04:00.000-08:00

I didn't even notice this little trick! As long as I didn't have to call deliver_welcome_message (or deliver_*) methods that would magically call welcome_message, I was happy that now the magic is gone. Things are transparent!
Here's an example showing the change: Say you have the following mailer:

class Notifier < ActionMailer::Base
  def welcome_message(new_user)
    #a warm welcome message
  end
end

Now, prior to Rails 3, or ActionMailer 3, you would write the following to actually call this method to get the benefits of ActionMailer magics, such as finding the view based on method name and so on:

Notifier.deliver_welcome_message(new_user_instance)

I am sure this deliver_* was a clever design decision to solve a hard problem, that is, finding the view name based on the method name. However, in ActionMailer 3, this is gone. Now the question is, if this trick is gone, how come it still finds the view name from the method name? Who sets the view name? To know the answer, first, let's take a look at how we call the welcome_message now.

Notifier.welcome_message(new_user_instance).send

Instead of

Notifier.new.welcome_message(new_user_instance).send

So, the magic deliver_ prefix is gone. But, did you see the new trick? Well, its a clever design again. The trick this time is, you call your instance method, welcome_message as if it was a class method. But there is no class method called welcome_message, so it instead goes to method_missing and thats how it sets up the view name from this call. Here's the code that does this little trick!

def method_missing(method, *args) #:nodoc:
    return super unless respond_to?(method)
    new(method, *args).message
  end

All it does is, instantiates the mailer with the method name!

However, this design decision has interesting side effects as well. Or may be not side effects, but rather core effects. For example, since you are calling your mailer methods as class methods, you cannot use a single mailer instance to send out multiple emails at the same time. In fact, every mailer has only one instance of message. So, it cannot store two messages at the same time. This is as if, you can have multiple methods in a class, but you cannot call more than one class or you will mess up the class's state!

Wonder why? Well, this is rooted in another key design choice: ActionMailer::Base is a subclass of AbstractController::Base. Now, if you look at controllers, you will notice that at any given point of time, a controller instance is only responsible for responding to a single action. This is logical for controllers. But how about mailers? I see a mismatch in my mental model and the actual implementation model. I don't see a reason why a mailer is a controller! For the sake of code reuse? But that could be done via delegation anyway.

I will end this post with one question:
Do you think mailer is a controller? hints: think about LSP.

Social Helpers in ASP.Net MVC3 (Facebook, Twitter, Gravatar etc.)

2011-01-14T10:13:00.001-08:00

This site shows the examples!
http://www.asp.net/webmatrix/tutorials/13-adding-social-networking-to-your-web-site

Now, the social links and buttons are no longer from a third-party source, its straight from Microsoft. I don't know if this is first-party or second-party :p

My Article at CodeProject: MvcMailer

2011-01-13T10:24:00.000-08:00

I just released a .Net NuGet package called MvcMailer and to get people super easily started, put an article at CodeProject.com. You are most welcome to the article at http://www.codeproject.com/KB/aspnet/MvcMailerNuGet.aspx
I welcome your comments and suggestions!

C# Named Parameters Can be Very Useful

2011-01-07T11:12:00.000-08:00

Think about the following code example:
htmlHelper.InputHelper(InputType.CheckBox, name, "true", true /* useViewData */, false /* isChecked */, true /* setId */, false /* isExplicitValue */, htmlAttributes);
This line is taken from the source code of ASP.NET MVC, or to be more specific its a line from the InputExtension class. I think the intent of the original developer is clear:
Add comment next to arguments so that one can easily read the method call without getting lost in a who's who since there are quite some arguments to pass.
To learn more about named parameters using C#, you can visit this post by ScottGu.

2011: Yet Another New Year

2011-01-02T09:28:00.000-08:00

Dear Readers:
Happy 2011. 2010 was a great year. Why?

Defended my MSc thesis after a moderate 16 months of grad school life.
Published 3 papers in 3 international conferences.
Visited 4 new countries - Netherlands, Sweden, Finland and Norway.
Visited a few interesting cities - Vancouver, Victoria, Edmonton.
100+ posts on DrinkRails.com.
25,000+ visits to my two blogs from all over the world.
Developed a fresh new app, Plexina Central, for Wairever Inc.
Lived a healthy life.
Bought my first (98 Corolla) and second (2000 CR-V) cars (also sold my first car)!

To live up to this standard, 2011 is surely challenged by 2010. Let's see how 2011 rolls: To give you a heads up, I am joining ThoughtWorks as a Consultant on January 4th!

However, 2010 was the only year in my life when I didn't see my parents and siblings. I hope, 2011 does a better job in this regard. It is getting essential now.

This is how I look at the close of 2010

And I want to look leaner at the close of 2011 or even before that :(

DRY - Total 161 Duplicate ArgumentNullException calls in ASP.Net MVC Source Code

2010-12-13T12:38:00.000-08:00

There are 161 occurrences of the following code pattern inside the ASP.Net MVC source code: See details of which class and which line at https://gist.github.com/739523
method(type argument)
{
  if(argument == null){
   throw new ArgumentNullException("argument")
  }

...
}
So, in total this pattern introduces 312 lines of duplicate code without whitespaces and 644 lines of duplicate code including whitespaces. And the pattern is simple, just check a condition and throw exception if its true. Not to mention, there are numerous other duplications where string.IsNullOrEmpty is used to check for string arguments.
This observation is interesting to me. Since, I think it adds a lot of noise to the code. In fact, if you randomly look at any of the methods - you have a good chance of seeing the first few lines doing this exactly similar thing. And this adds noise to me. Not to mention that, the developer needs to write the code, write tests for this code and if one needs to use this method, somehow should know this in advance that passing a null will result in an exception. But of course, this is not explicit from the method signature unless the developer also takes the pain to put a documentation styled comment and mention about this ArgumentNullException.
To remove this clutter, I think C# can introduce a few language keywords such as the follows:
public void Authenticate(required User user)
public void AddNewUser(nonblank string userName)
A compiler can very easily compile the code and put the exception throwing logic based on these keywords. Call it a syntactic sugar or a language keyword, this is the kind of translation that seems to be perfect for the compilers. And I can foresee it being used in almost all methods we write, since if the methods require an argument they do it for a purpose and most of the time null is not expected anyway!
I don't know if this will reach the people responsible for developing C#, but if it does, I think the community will really love this new language feature.
I know about workarounds using AOP or other hyped-but-seldom-used tricks to solve this problem. But these tricks often make life harder by introducing a learning curve and then punishing the learning by slowing down the application. So, its best to put in as a core language feature. What do you think?

Book Review: Jose Valim's Crafting Rails Applications

2010-12-10T14:41:00.000-08:00

Have you already read this?

The following excerpt by Jose Valim at the end of the book nicely summarizes it:

Finally, you understand Rails better. You can explore other areas of the source code, study other Action Controller and Active Models modules, check other generators implementations or read the source of Railties, Engines and Applications with detail! - Jose Valim

For the impatient readers, this is the best in-depth Ruby on Rails related book I have ever read and you should read this (only 172 pages). Buy the book here. But wait, you could get 40% discount and get the book for $13. I will tell you how, continue reading!
This book literally opens up the Ruby on Rails framework for the readers. So, now I am crystal clear about Metal, Rack, ActiveModel, Rendering, Templating, Migrations, Gems, Engines and so many core concepts. If you are like me, you have cloned the Ruby on Rails code and took a peek into the code to understand, patch some code or just to learn some hidden treasures of Ruby, but had tough time getting hold of the big picture. Well, this book will show you some highways and also some other useful alleys - you can find the rest by yourself!
This book embraces Test Driven Design, so all code examples, and hell yes there's a lot of them, are test driven. So, its unit test, functional test and integration test that drives the show. The topics cover customization of key Ruby on Rails components such as: models, controllers, views, mailers, generators and rack integrations. But the examples are really good as it shows:

Responding to pdf requests so that the server responds with on-the-fly PDF responses
Using Markdown templates for producing HTML and Text multipart emails from a single source template
Rendering views that are stored in a database to work as a simple CMS
Publishing and subscribing to Rails internal event such as SQL queries
Creating a simple rack application
Creating a Rails Engine
Creating custom responders so that you can DRY up your controllers that use exactly same lines for respond_to do |format|...
I18n translations using Redis key-value store and caching
Combining Sinatra with Rails in a single Rails app

To ease the process of trying out the DIY code, Jose Valim created an excellent gem called enginex. This gem gives you an incubator to try out the example code while building your own gem and using it from an embedded dummy application, writing tests and even browsing the app. The whole experience of trying out the code is awesome. Before this, I have never read a book that shipped with a gem just so that the readers could easily use the source code. Awesome idea and even better execution.

While explaining the inner workings of Ruby on Rails framework the book also discussed about a few useful gems:

devise - authentication gem.
enginex - produces incubator for gem development and makes it a breeze.
capybara - drives integrations tests and also works with browsers through selenium etc.
rdiscount - Discount is an implementation of John Gruber's Markdown markup language in C
responders - DRY up your Ruby on Rails application with a number of handy responders.
redis - an easy to use Key Value store.
prawn - Ruby PDF library.

This book also shows a number of cool tricks. Its overall a fun read. I would say, the final version will be more eye-soothing, but don't wait for that. Grab your ebook now and you will get the updates as they come!

I would like the book more if Jose Valim could reorganize some of the content. For an example, the text about Generators appear in different places. I think it would be easier to follow if it was in a separate chapter. The same applies for Engine.

I have another observation: the book is written for pro developers with substantial Ruby/Rails application. But I think the topics discussed here could also be equally useful to beginners. The later can be achieved by going a bit slow about some of the topics. Jose Valim, can you add little explanations at places for beginners?

The bottom line is, buy this book and read. To receive 40% discount, sign up at http://pragprog.com and refer to a friend and ask her to complete signup. You both get 40% discount. To claim, go to your account and you will find this as soon as your friend completes the signup.

Thank you!

This review is not sponsored and contains my opinion only.

Ruby - some mysterious language features

2010-11-11T21:52:00.000-08:00

Here I will share some of the interesting ruby features that you will notice when looking into mature ruby code by advanced level coders.

Upgrading to Ruby on Rails 3 - beware!

2010-11-10T12:36:00.000-08:00

Ryan Bates had a series of posts (1, 2 and 3) on upgrading your Rails 2.3.x apps to Rails 3.x and sure they are useful. But if you are really doing that, beware of the following changes that you will need to do. It will take a lot of time for sure if you you have a moderate sized app.

Upgrading your models:

Get rid of all validates_xxx_of with appropriate validates
Get rid of all def validate ... end methods with custom validator
Find out all occurrences of :conditions, :limit, :order and use new active record methods instead
Replace all named_scope with scope
Make sure your acts_as_xxxx plugins are all updated to use Ruby on Rails 3. I had troubles with Authlogic as it shows Based.named_scope is DEPRICATED. Still looking for a solution.
Ruby 1.9.2 doesn't work with soap42 wsdl driver. Haven't found a solution yet as it keeps reporting an error regarding "XML processor module" missing.

Upgrading your controllers:

Find out all occurrences of find method and replace with where.
Find out all calls to Mailer that looks like deliver_xxx and make it xxx.deliver

Upgrading your views:

All erb blocks must start with a has to be changed to . Do the same for all such erb blocks with a do.
All link_to_remote or remote_form_for or other remote form helpers need to be changed to their non-remote counterparts with a param :remote => true.

Upgrading your mailers:

body method is gone, instead of the hashed params to this method, just define instance variables.
All xxx.text.html.erb now becomes xxx.html.erb in the mailer views.

Upgrading the config files:

The best way is to crate a new rails app and then copy the config folder into yours.
Look at the initializers and clean up any required initializers.
Make sure you have autoload_paths setup to include the lib folder. It is not included by default, so your code from the lib folder won't be accessible.
Look at deprecation warning and you will see lots of config.action_controller.* need to changed to config.*

Plugins:

All plugin/lib/rails/tasks/*.rake needs to be copied in to plugin/lib/tasks/*.rake
Make sure your plugins don't use named_scope, if you find any, replace with scope.
Whatever applies to your models should also be applied to your plugins that act on models.

Testing:

Check you have updated shoulda, rspec or whatever lib you use.
Update test codes according to your new lib.

Upgrading IDE to use RVM:

Your IDE is not smart enough to use RVM. However use this to get TextMate ready.

Using nil.to_a or whatever.to_a in ruby

2010-09-29T16:37:00.000-07:00

Ruby is a programming language for developer happiness and productivity for customers. Here is a quick happiness and productivity tip:

4 design principles

2010-09-18T23:18:00.000-07:00

Simplicity favors regularity.
Smaller is faster.
Good design demands compromise.
Make the common case fast.

The four principles of MIPS design that applies to most design jobs we do, even with our personal lives. Agree?

OO Design Dilemma: Auditing Changes Across Hierarchical Objects

2010-09-15T15:39:00.000-07:00

Here is a sample UML class diagram of the situation that posed me the OO design dilemma a few days ago.

Let me explain with an example,

The Electronic Items catalog has many Televisions. The Sony Televisions come with different specifications, such as refresh rate of 240 Hz, 120 Hz and 60 Hz. However, the 240 Hz ones also comes in different colors - Black and Grey.

Now, a store manager needs to see the recent changes across all catalogs, such as electronic items, musical instruments and so on. So, if someone added a new Sony 240 Hz color of Dark Black or removed the Grey one, the store manager needs to see this. However, a department manager may need to see changes at all levels, for example whenever one of her Catalog, Product, Specification or its Property is changed. So, if she needs to see all changes under Sony Television, you know, she needs to see changes in the name and value of underlying specifications and their properties as well as changes at the higher level, say, the price.

Now, the above design looks good from OO perspective. However, since we need to persist the data into a relational database, we will end up with one table per class and foreign keys to interlink. If you are doing Ruby on Rails, you will possibly use polymorphic association between Auditable and the subclasses. For an example, lets consider the following E-R design (not showing all relations):

Now, given this schema, if you need to find out the latest 50 Log Messages with Author and Associated objects for the Electronics Catalog, how would you write a simple query?

Look, here is an expected outcome of the query:
Sep 15, 2010

Jane added new Color : Dark Black for Sony 240 Hz TV
Shon changed the Sony TV Price from $700 to $600
Jakie added a new Specification for Panasonic TV: Aspect Ratio -> 16:9

Sep 14, 2010

Now, you see, the date wise grouping can be done once the latest audit logs from all across the Catalog hierarchy is found. But how do you find it given a CatalogID to start with? The following query wont work:

SELECT TOP 50 * FROM Auditables WHERE AuditableTypeName='Catalog' and AuditableID=my_catalog_id ORDER BY Timestamp DESC

Because it will only produce the audit logs for the Catalog Object, whereas we are expecting to see all the recent audits for this Catalog and underlying products down to the Specification Property level.

However, one work around is to query for the Audit Logs for the Catalog. Next, find all the Products of this Catalog and query for the audits for all these products. However, if we are to select top 50 audits for the catalog and its whole hierarchy, how many should we select here? And the problem gets even worse, when you have to repeat the above steps for Specifications and Specification Properties. When you have to take the latest 50 audit logs after you run a few queries, say 10, you have to take 50 audit logs for each of them. Because, the latest 50 results can be from a single query :-(

Looks like the Auditable class and corresponding design doesn't work well for this situation. So, what is a possible solution?

It's hard. I don't readily see a great solution. However, workarounds are there. For example, we can change the Audiable class to hold references to all levels of the Catalog object hierarchy. So, in that case the Auditables table will look like the following:

With such a schema, we need to ensure if the Audit Log corresponds to a SpecificationProperty, we put references to all its higher level objects. So, the query will be simple. With this assumption, the following query will be able to fetch all audit logs for Catalog and its descendants.

SELECT TOP 50 * FROM Auditables WHERE CatalogID=my_catalog_id

Similarly, the following query will produce the audit logs for a single project and its descendents:

SELECT TOP 50 * FROM Auditables WHERE ProductID=my_product_id

However, it has its downsides as well. The Auditables is no longer a general purpose Auditable. If we add a new type of Auditable, we cannot use it unless we alter its properties! High Coupling! Less Reuse. Also, a lot of if-else will be required to show the Audit logs, as it can belong to multiple parents!

How would you solve this design dilemma? Comments welcome!

Know Your Enemies Before They Kill You!

2010-07-19T13:50:00.000-07:00

From darekb

You know what, this is a political world. So, enemies will seemingly look like your friends until the moment when.. well, its time for the kill! My dear readers, its time to know the enemies!

I have met with a few enemies off late. I will go one by one here.

If you are a software developer like me, you will often see this enemy, camouflaged variables, methods, classes and namespaces. For example, I have recently seen a Stack camouflaged as Visitor! I really mean this. I found a class called Visitor, so I was expecting a Visitor Design Pattern implementation or something similar, but what I got was a Stack under the hood with two methods Push and Pop! This enemies are very bad for your health, as they will keep you guessing all the time... you never know what they do from looking at their names!

Another enemy you will often see are the very skinny ones, to skinny to have any meat in them. I met some enemies like this as well. What happens when you do over engineering with interface explosion and a lot of one method classes? Is it really that difficult? Is it really a class? Is it really a package? I don't think so! You can spoil a piece of code by introducing a class/package for a single method. This enemy often surfaces because of the fact that, the design pattern book only shows classes with one/two key methods in them... which is of course not intended. But this is life... you gotta balance between class explosion and God classes... really, or this enemy will kill you someday.

I have just touched two common enemies... but there is another enemy we all are aware of, CMD+c (OS X) or Ctrl + C (Win). Its such a pain to copy a code fragment and use it in a different class... this is exactly the form of reuse that kills everything. Make sure you don't let this germ to grow, or it will outgrow you and leave you crying.

Have you reviewed your code by someone else today? If yes, keep up the good work. If not, beware of the enemies before they get you. Best of luck!

The Greatest Show on Earth and What Else?

2010-07-07T15:19:00.000-07:00

FIFA world cup 2010 is almost coming to an end. This is definitely the greatest show on earth and I have been all occupied with the matches...

However, the show started almost immediately after I was back from Europe. It was a nice tour, starting a day at Amsterdam. Then to Trondheim (Norway), Stockholm and the best part was the night long sea cruise to Helsinki. An experience to remember for the rest of my life.

The days were eventful to say the least. At XP 2010, I presented my paper. Here is the presentation for my caring readers :-)

But XP 2010 was also a great place to meet people from around the world who care about software, its crafts and of course impacts. In very short, I found people to be very interested and starting to explore the possibilities with Lean and Kanban. This was a little surprising, because until now it has almost always been Scrum and XP to have a covering meaning of Agile. But, the industry seems to be leaning towards Lean. This is the beauty of being agile, to be able to adapt with time!
However, Norway seemed to be an expensive place even compared to Calgary. But, don't shy away from Norway for this reason, they have spectacular beauty in their landscape. Serene and soothing. While staying in Trondheim, I visited a cathedral from early 1000's. It was amazing to see the cathedral still standing firmly after so many years... extreme engineering! The city was full of historical buildings... if you haven't heard, the Harry Potter building is actually the main academic building at NTNU. (kidding! but the locals really call it by Harry Potter building)
This is me and my wife in front of the Harry Potter Building!

The city tour and canal cruise at Amsterdam was also a pleasant experience. It was nice to see the centuries old bridges and roads still serving the people so well. It is indeed a bicycle city, everyone in the city seemed to have a bicycle... believe me, they have multi-storied parking facilities only for bicycles! No wonder, why they are so healthy as a nation.

Next, Stockholm is a city full of life. You will see people dancing, having a drink and enjoying their times with friends everywhere. Especially for people like me, who barely see any crowd in Calgary, will find the place to be very exciting and inspiring.

Our Stockholm stay was rather short as we went to Helsinki on a sea cruise with Viking line. This was very eventful. Firstly because me and my wife lost each other when I was rushing into the ship as it was just about to start... then I stepped out of the ship, rushing back to the checkin counter and heard her crying like a baby... she was so upset and so scared! But we eventually managed to get into the ship may be 1 min before the doors were locked!

But this late entrance came with a surprise! We were given a window side cabin although we didn't get one while booking... and the awesome journey began. It was around 5:30 in the evening and the view from the deck was so nice. And there were live music and dance uptill midnight, nice romantic trip altogether. When we landed at the Helsinki city, we roamed around the tourist hotspots and I slept on the grass. Really! I took the following photo before I fell asleep..

However, back to normal life and the greatest show on earth started! At office, I have kind of wrapped up the application that I was working on for the last 3 months and now heading towards another project. This time its gonna be Java after a looong time... At the lab, trying to wrap my thesis related implementations by the summer. Discovering lot of things as I am working with Lucene, Solr, Tika, Acts as Solr and these full text search engine related stuffs. Hope to push a post about these things when I get some time!

But, this is summer in Calgary. And I attended the Canada Day fireworks at the City hall. Here is a photo of the event for my reader:

This is pretty much it. Looking forward to the events at Calgary Stampedes. Hopefully this will also be a wonderful time pass. I will see if I can be back with some real "meat" in this blog shortly!

Summer of 2010! Europe, here we come!

2010-05-03T13:32:00.000-07:00

I just completed my Winter 2010 semester at school. It was so far a good one. I pushed my papers and presentations on the courses of this semester at http://smsohan.com/#courses If you are interested to read my paper about Tabletop Application Testing or Communication Challenges with Distributed Agile Teams, you are most welcome at my site.

However, its time to look ahead to the summer. And I hope this will be a good one! I just received my driving license after a wonderful training from Drashko and Gordana at the Green Light Driving School. If you are looking for a caring and professional driving school in Calgary, I highly recommend them. They will make it easy for you.

Well, driving license comes with an obligation to buy a car :-) I am right now looking for one used car, probably from Toyota, Honda or Nissan, as people told me these are more reliable than others. I am not sure if I will be buying a car soon, but I already got visa for a Europe trip, my first ever. Its gonna be our second honeymoon in the European land :-) We will be going to Norway for attending the XP 2010 conference where I will be presenting my research paper on Email Auto-Tagging with User Stories. However, we are planning to see a part of Amsterdam and Stockholm alongside Norway. I have heard all the good things about these sites during summer... staying tuned to that!

I will also be working on my research project as well as my job at Wairever Inc. This summer will be a busy one. But I am hoping the summer in Calgary will be a lot of fun with friends and at work...

One little realization: I figured out that there are two crowds in the software world. One crowd has lot of respect for open source stuffs like Ruby on Rails and another crowd has that for "established" big players like .Net or Java. With this realization, I am focusing on getting my .Net knowledge in sync with recent developments as of .Net 4.0 and VS 2010. I am always reading the blogs and MSDN... but this time I will look into one/few books that give(s) a complete and detailed picture about the deltas in .Net 4.0. However, I will keep posting on my Drink Rails blog as usual, almost daily.

Do you have any recommended book for .Net 4.0? Please use the comments area for that.

Using Authlogic and single access token for API access

2010-04-26T08:38:00.001-07:00

Bynarylogic's authlogic has gained much popularity for its out of the box solution to ruby on rails authentication. Yesterday, I was working on giving API access to my ruby on rails application so that other apps can use my RESTful services. The authenticated API access usually involves the following steps:

API_KEY or a token to identify/authenticate an API call.
Authentication of an API caller using the API_KEY.

Authlogic comes with in-built support for this. The following steps will do it for you:

flash.now - did you know?

2010-03-31T23:10:00.000-07:00

Well, I didn't know this until late. If you are like me, you have often wondered when you saw those unwanted flash messages appearing after a request, sometimes after ajax requests when you do a redirect, all on a sudden that flash shows up!
Well, as you have thought, the Ruby on Rails people have solved this problem way before now. The solution is to wisely use flash.now[] and flash[]. Here are a few tips:

Use flash.now[] when you are flashing:

on ajax requests
before a call to render :action => :my_action, as often found in failure cases of create and update actions

Use flash[] when you are flashing:

before a redirect_to, often found in the success cases of create and update actions

In general, use flash.now[] when you don't want to carry over the flash to the next http request and flash[] otherwise. The FlashHash class has more detail on this at the ruby on rails API page. Hope this helps you to get rid of those annoying and often embarrassing out-of-context flash messages!

What's up next?

2010-03-23T10:33:00.000-07:00

Hello Readers:
Wish you all are doing great as the Spring already started :-)
Recently my grad courses are keeping me busy with assignments and projects as the term comes close to an end. So, I haven't had much time to spend on blogging other than posting the Ruby on Rails link blog called www.DrinkRails.com. However, for my readers, I thought I would post the recent presentation that I put for the Agile course here:

But I am looking forward to start a new project with Wairever (www.Wairever.com), a Calgary based health care IT solution vendor. I hope that will fuel me with a lot of new concepts and as always, I will try to keep my learning posted here at my blog. Stay tuned! BTW, if you are Ruby on Rails developer or wanna be so, please let me know your feedback about the DrinkRails.com link blog.

Ruby on Rails Security Review: An Experience Report

2010-03-11T08:48:00.000-08:00

Image credits to Wink on Flickr (creative commons)

I was reviewing a Ruby on Rails source code to see the security implementations they have so far. They are about to launch their product for the first release and wanted to ensure they have the most obvious things checked. So, in a sense it was not supposed to be a hacking job for me, rather to check if the most well known security measures are in place. This is what I looked into so far:

Password: Password was encrypted using a salt. However, the default logger would log the password as they didn't use the filter_paramerer_logging method.
Cross-Site Scripting: I was able to easily inject a script by just entering <script>alert('Script')</script> when I signed up to the system and every time it would open an alert window whenever I navigated to a new page! So, I recommended them to use <%= h %>. However, Rails 3 does a good job of making this a default.
Authorization: I found the weakest measure in the implementation of Authorization. For an example, there is a calendar in the web app where one can add/remove events. I found that any logged in user, not necessarily the event owner, could change/remove any calendar event. This was a shocker. Next, I found this same thing happening to the core models as well. The catch here is, they had a filter that checked if a user was logged in, but they didn't check if a user has rights to modify an instance of the object. For example, there is a project model, that can only be modified by the project owner. However, this per object ownership was not authorized and it was a huge potential security bug in my opinion.
File uploads: The app was designed to upload the files to a folder underneath the public folder. Which means, if the rails server was down, apache would serve the files directly to the user bypassing whatever security measure was taken inside the app.
PRG violation: This is a good idea to follow a post-redirect-get pattern when an object is modified through post/delete/put to ensure pressing the browser refresh button doesn't re-invoke the change. This wasn't done at some places which might end in multiple payments and such severe risks.
Direct public release: I was a bit concerned that they wanted to go public release with their first ever release, even before having an alpha or at least in-house user. This is important because this application deals with money and credit cards. Trust is very important for such apps. So, I advised them to try this for some real works at home other than the "asdf asdf asdf...."(!) kind inputs. This will help them spotting some of the odd behaviors early and cause less embarrassment.

It was only a 4 hour assignment for me. Also, I was only limited to the source code and the test deployment that they have now. However, it seemed to me that, they might spend a few hours to fix the obvious errors and do some in-house real use before going to a public release.

Ruby on Rails or Rails on Ruby?

2010-03-09T21:01:00.000-08:00

All on a sudden, this thing popped up in my mind. What we are calling Ruby on Rails, is this actually "Ruby" on "Rails" or the other way around? Is this upside down? Here's my mental picture of the RoR framework:

Image credits to Foo Fighter on Flickr(creative commons)

Ruby is a self-sustained language. As a language this is completely ignorant of the Rails Framework. So, I think there is no dependency from Ruby to Rails.
Rails is a framework built using Ruby as a language. So, there is a strict dependency from Rails to Ruby.

What do you think? Would you call it "Rails on Ruby" or "Ruby on Rails"? I see a point of agreement for the ones who want to call it RoR, no damage done :-)

Lets see how this "on" preposition works for other language/platform pairs:

Java on Struts vs Struts on Java
PHP on Cake vs Cake on PHP
C# on .Net vs .Net on C#

Confused? Well, then you can use RoR for now!

Rails Source Code Walkthrough #1: the ActiveModel Module

2010-02-26T11:24:00.000-08:00

I was taking a look into the fresh ActiveModel module of Rails 3 as of github revision #100644. Here is what I learned:

Learned about new feature called autoload. Rails Inside has a small yet useful autoload example here. It is a mechanism to lazy load your modules, so delaying the load unless the module methods are actually called. A call to autoload simply marks it as a potential include, but the actual include takes place only when you first use something on that module. I has a syntax like the following: autoload :Callbacks
Using autoload, the ActiveModel module loads a number of other modules such as: AttributeMethods, Callbacks, Dirty, Observer, Observing etc.
Also, it initializes the I18n Internationalization with the default en locale.

What's inside AttributeMethods?

This module defines class methods that lets you define attribute methods for the objects. I learned that you can have prefix, suffix and affix appended to your attributes that go to to a default method. For example, consider the following example right from the code:

# class Person
      #
      # include ActiveModel::AttributeMethods
      # attr_accessor :name
      # attribute_method_suffix '_short?'
      # define_attribute_methods [:name]
      #
      # private
      #
      # def attribute_short?(attr)
      # send(attr).length < 5
      # end
      # end
      #
      # person = Person.new
      # person.name = "Bob"
      # person.name # => "Bob"
      # person.name_short? # => true

Isn't this amazing?

What's inside callbacks?

Callbacks module is responsible for firing your before, after and around callbacks on ActiveModel models.

What's inside Conversion?

Conversion module only has 3 methods, to_model, to_key and to_param . These methods can be overriden to allow custom conversion of the ActiveModel objects.

What's inside Dirty?

The dirty module is all about dirty tracking methods of your ActiveModels. It has methods like changes, changed?, changed, reset_attr! etc. that you can use to track changes of your model objects. Thinks like history tracking or audition on changes can be done using this module methods.

What's inside Errors module?

This module has everything that deals with generating errors on ActiveModel validations. One ruby feature I learned from this module that I didn't know before. Its something like an indexer in C#. Here is an example from the source code:

# When passed a symbol or a name of a method, returns an array of errors for the method.
    # 
    #   p.errors[:name]   #=> ["can not be nil"]
    #   p.errors['name']  #=> ["can not be nil"]
    def [](attribute)
      if errors = get(attribute.to_sym)
        errors
      else
        set(attribute.to_sym, [])
      end
    end
    # Adds to the supplied attribute the supplied error message.
    # 
    #   p.errors[:name] = "must be set"
    #   p.errors[:name] #=> ['must be set']
    def []=(attribute, error)
      self[attribute.to_sym] << error
    end

What's inside the Naming module?

Naming module is all about singular, plural, human and such names for your models! This methods are used to define the routes as well as in views. You can override such methods to provide a custom pluralized name for your model.

What's inside observing?

Rails Observers provide you a clean implementation of the Observer design pattern. It extends on top of the default observer module from Ruby. These observers are often use for implementing Aspect oriented programming as well as the code that are neither part of models or controllers, rather fall in between the two. Email notification is an useful example from Rails Guides.

What's inside the Railtie module?

Well, not much! But it glues up ActiveModel with Rails! Just two lines of code as folllows:

require "active_model"
require "rails"

What's up with Serialization?

It has only one method that generates a hash based on the serializable attributes with :only and :except filter!

What's inside Serializers?

It has two serializers, one for json and another for xml. This two works great out of the box. However, if you need to tweak it, it should be very simply done by subclassing this classes.

What's inside translation?

It translates your model attribute names to match your locale using I18n. The default skim looks for the following naming in your local yml file when called through the method human_attribute_name

activemodel.attributes.underscore_model_name.attribute_name

Whats inside Validations?

This is a freshly renovated module for Rails 3, as it merged the validates_presence like methods into a single method validate that lets you keep all your validations for a model with a single call. Also you can easily reuse custom validators through out your models.

But this forked a few more modules, one per kind of validation. All these validations and your potential custom validators will probably be descendent of the Validator class that has the following method:

# Override this method in subclasses with validation logic, adding errors
    # to the records +errors+ array where necessary.
    def validate(record)
      raise NotImplementedError
    end

Some in-built implementation of this validator are acceptance, confirmation, exclusion etc. I learned something new here, the NotImplementedError exception.

So, what's the big learning here?

I will use Modules to modularize my ruby code. This perfectly makes sense and also this is how one can come up with plugins out of their code base. Having the small bits in a module also facilitates reusability inside a project.
The source of ActiveModel is very simple and completely ignorant of its underlying database. This is the big change of liberating Rails from ActiveRecord, which I think is not a matter for most rails developer anyway! But its a good lesson learned.
Once I see some time, I would like to jump in to the development of Rails, at least make some initial contribution.

Stay tuned for more posts on Rails 3 source code.

Why would you spend $10 to learn to use Basecamp?

2010-02-25T12:05:00.000-08:00

This is sounding very strange to me indeed! 37Signals is very much known for creating the simplest of interfaces and I really found people finding it very intuitive. But this is strange... now they are asking people to buy a book for $10 to learn how to use Basecamp! Can you believe it? See the sales post (!) here at "Sams Teach Yourself Basecamp in 10 Minutes" is a comprehensive guide to Basecamp

Ruby on Rails Interview Questions: Advanced

2010-02-23T19:17:00.000-08:00

In my previous post, I listed a few general interview questions for Ruby on Rails jobs. This one is intended to be more of an advanced level, not for the rookies :-)

What is Rack?
Sketch out a deployment architecture of a Ruby on Rails application utilizing multiple servers.
How can you secure a rails application to counter for Session Fixation?
Where can I get the core rails framework source code?
How can you reuse the models from one rails project into another?
Explain one plugin that you extracted out of your source code.
What is the difference between pre-initializers and initializers?
How can you easily switch your logger to use Log4r?
How would you design the logging standard for your rails application?
How can you implement asynchronous messaging in Rails?
What will you do to look for a possible memory leak in Rails application?
How can you run a profiler?
What is lambda?
What is Proc? When did you use this?
How can you use before and after callbacks of your rails methods to halt a database insert/update/delete?
How can you reuse your before and after callback methods across multiple models?
Define an architecture to store files uploaded to an application so that they are only accessible to valid users.
How would you change your asset storage to use a static server?
Explain one situation when you used rails caching.
What kinds of caching comes in-built with Rails?
Can you explain the use of 'dynamic' features of Ruby on the core Rails framework?
How can you call a SOAP web service from a rails application?
Your application needs to send a lot of email notifications. How would you design the notification so that the end user doesn't get stuck for email sending delays?
What is a mongrel cluster?
Can you explain if the clusters share a same memory? Can one cluster handle a request from a client that was handled by another?
How would you internationalize your application interface?
How can you create a rails generator?
Have you ever used a polymorphic association?
How can you define a plugin that adds a new class method to ActiveRecord::Base?
What are the three most significant changes in Rails 3 in your eyes?
How can you implement complex reporting using ruby on rails?

I am sure this list will go on and on. But I have found most people asking questions about scalability, deployment issues, security and such architectural level questions to extract out the in-depth understanding of such core concepts. Where to learn more on such advanced stuffs? Ruby on Rails Guides and Stack Overflow are my favorite places. However, its good to keep an eye on the edge rails to see what's happening today!

Ruby on Rails Interview Questions

2010-02-22T23:12:00.000-08:00

Ruby Specific Questions
The best place for learning ruby is to get started with the programming-ruby. It fairly covers the important bits in a very readable language. Here are a few quick questions on ruby:

What is rubygems?
What is a Symbol?
What is the difference between a Symbol and String?
What is the purpose of yield?
How do you define class variables?
How do you define instance variables?
How do you define global variables?
How can you dynamically define a method body?
What is a Range?
How can you implement method overloading?
What is the difference between '&&' and 'and' operators?
What is the convention for using '!' at the end of a method name?
What is a module?
What is mixin?
How will you implement a singleton pattern?
How will you implement a observer pattern?
How can you define a constant?
How can you define a custom Exception?
How can you fire a method when a module is included inside a class?
What is the default access modifier (public/protected/private) for a method?
How can you call the base class method from inside of its overriden method?

Rails Specific Questions
A thorough reading of the articles at Ruby on Rails Guides can be very useful for starters as well as a refresher for veterans. The following bunch of questions are specific to rails, in no particular order. The Pragmatic Bookshelf has a fantastic book for beginners called Agile Web Development Using Ruby on Rails.

Define the Rails MVC implementation using an example.
What is a named scope? (or Scope in Rails 3).
Can you give an example of a class that should be inside the lib folder?
Where should you put code that is supposed to run when your application launches?
What deployment tool do you use?
How can you migrate your database schema one level down?
What is an observer?
What is a sweeper?
How can you implement caching in Rails?
What is a filter? When it is called?
How can you divide your controllers into separate modules?
What is RESTful routing?
How can you list all routes for an application?
How can you send a multi-part email?
Is it possible to embed partial views inside layouts? How?
What is the purpose of RJS?
How can you create a REST API for your application?
How can you define a new environment called 'staging'?
What is Rake?
What is Capistrano?
What is a polymorophic association?
How can you implement a polymorphic association?
What is a has and belongs to many association?
What is the difference between has_one and belongs_to?
How can you implement single table inheritance?
What is eager loading?
How can you eager load associated objects?
How can you add a custom validation on your model?
How can you implement a custom theme for your forms?
Why is fields_for used for?
What is the purpose of a helper method?
What is flash?
How can you install the missing gems that are required by your application in the simplest way?
How can you implement internationalization?
How can you show search user friendly urls instead of using only numeric ids?
How can you configure your application for different environments?
How can you instruct rails logger to ignore passwords and such fields while logging?

Test Frameworks
Ruby on Rails has a number of built-in and a few other third-party test frameworks. Here are a few sample questions on such frameworks:

Are you familiar with unit testing?
How does functional testing differ from unit testing?
Have you ever used a mocking framework?
Are you familiar with BDD using RSpec or Cucumber?
What is an alternative to using test fixtures?
How can you reuse part of a text fixture?
How do you specify associations in the test fixture yml files?

Plugins
Plugins are the principal mechanism to reuse code. The open-source community is at full-bloom when it comes about plugins. The Rails Plugins site has a really good list of such plugins from the community.

What plugin would you recommend for user authentication and authorization?
What plugin do you use for full-text search?
How can you implement a state machine?
What is the difference between a plugin and a gem?
How can you create a plugin?
Can you please name a few useful plugins?
How can you implement a search feature that searches for multiple models?
How can you upload a flie to a server?

Architecture Related Questions
This questions can be from different angles like: quality, security, scalability, manageability, interoperability, reusability and all the other ilities you name! Here are a few example questions:

Is Rails scalable?
What are the key deployment challenges?
How can you safeguard a rails application from SQL injection attack?
How can you secure a rails application?
How can rails engage with a SOA platform?

Community Related Questions
I see a fairly large community on Github, Stack Overflow, RailsCasts, The Riding Rails Blog and many more. Some interviewers may want to see if you are connected to the community. The following questions may help you prepare :-)

Can you tell me a few good community resources for Rails?
Where would you reach out to get the community to answer your questions?
What's new in Rails 3.0?
Which famous applications are built using ruby on rails?

I plan to polish this document on a later revision. But in the meanwhile, if you feel like contributing, you can start commenting with the answers, more questions or suggestions. I believe this will not only help people getting ready for their next Rails job, but also for everyone to see what knowledge we are missing...
Disclaimer: This is not a shortcut, rather its kind of a check list that may help you with an interview.

Uploading files with blog post

2010-01-21T07:48:00.000-08:00

At times I wanted to push some files with my blog so that people can download and check something locally. Up until now, it was not a straight-forward way. I either uploaded the file to my own server or google pages or somewhere. Then linked it on the blog.
However, you can now publish files from Windows Live SkyDrive (total free space of 25 GB) or Google Docs (Total free space 1GB). If you haven't checked already, google now offers you the opportunity to upload any kind of file without conversion. I know there are other services like this, but these two should be reliable.
I took some information from this Tim Anderson's ITWriting blog.

Experience notes from a RoR code review job

2010-01-20T09:28:00.000-08:00

Recently I had the opportunity to review a ruby on rails code. The project aims to create an online market place for experts, with a similar model to some other freelancing/outsourcing sites. Here is how and what I reviewed:
I had a read-only access to the code and no download was allowed locally. So, I didn't get to run the code, tests or any tool to auto-generate some reports on the code. Also, it was supposed to be a high level review and I was supposed to take 5 hours to take a look into the code and write a report on the various aspects of it. In the end, it took me 6 hours and I came up with a 14 page report. I liked this job for a few reasons:

When I was working at www.ScrumPad.com project, we got our code reviewed by Gregg Pollack of RailsEnvy. During those days we had little experience on RoR before we started the project. So, we ended up with something that was working well, but wasn't the best one in terms of confidence and reliability. I remember the review was very well-thought and presented by Gregg and that to a great extent shaped the later works on the project.
This was my first official assignment as a reviewer.
I was excited to see how other people were approaching their RoR projects.

Now coming to my review approach, here you go:

After some googling about reviewing RoR applications, I didn't find any comprehensive suggestion and decided to go my own way.
To get started, I took a look into the config/routes.rb file. I had the impression that, routes.rb would help me understand the resources and their relationships. But soon I discovered one potential issue as there were almost no nesting of resources and some resources had tens of actions apart from the standard RESTful methods.
Next, I picked the resource with most number of methods and found that, it was actually taking the responsibility of 5 different resources. Although these resources were somewhat related, it made little sense to me to have such FAT controllers.
I was also looking for logging, exception handling, ruby coding style, naming and came up with some suggestions to improve on these aspects.
I also suggested them to modularize their controllers. They already had an admin module, but they could introduce more to clean up things.
After controllers, I went to the models. By the time I found a few natural inheritance relations among the models. But the relations were not found in the models that ended up with a number of code duplications and similar looking branches at several places. So, I suggested them to install the relations using single table inheritance and cleanup the stuffs.
Apart from the relations, I also found a number of self or class methods floating here and there. While ActiveRecord models themselves offer a number of such methods, its not always wise to create one without thinking. In the code I found self methods resulted in method duplication and wrong method placement at several places.
Next coming to views, I found they did a good job with the helpers and partials. Views were better organized. But also, I found a lot, I mean a lot, of partials. Such an explosion of partials often makes it hard to find the right ones, especially for new comers.
Going to test code, I found they had a test suite with unit, functional and integration tests. But the amount of test was a concern for me. I believe test codes are there to help good design practices and managing changes over time. I suggested them to target 80% test coverage at a minimum.
Coming about deployment, I found they were using manual deployment techniques. I suggested them to use capistrano for deployment.
Overall I found a lot of reinventing the wheel scenario as they could get rid of lots of code by just using commonly known and free plugins. I suggested some plugins in this regard.
I suggested them to use named_scopes to get rid of some self methods here and there.

After the review, I felt such patterns in RoR code is expected to surface in most new to RoR teams. Although experienced and smart people often read articles and consult experts as an on going basis to get things right at the first place. I suggest every team, if they haven't already gone through, to take some time and study the resources at http://guides.rubyonrails.org and http://wiki.rubyonrails.org/
Also, its a good idea to know the Ruby language fluently to make use of the power of the language. A good learning resource comes with ruby installation named Programming Ruby, also available in the internet at http://ruby-doc.org
As a continuous learning tool, I also suggest keeping an eye on http://railscasts.com and http://stackoverflow.com/questions/tagged/ruby-on-rails

Home/End key in Mac ( MacBook Pro ) Windows on Bootcamp

2010-01-01T12:31:00.000-08:00

If you are anything like me, you love using the home and end key to quickly move to the start/end of a line of text. But, in Apple MacBook Pro, there is no default home/end key! I searched the internet and found Command + Left/Right to the rescue on OS X.

But, then I installed windows 7 on my Mac and it was nightmare to edit without the home/end keys. Today I just found that you can use fn+ Left/Right for this purpose! Hurray! It makes my time with Microsoft office and Visual studio much happier, again :-)

Added Crummy to generate breadcrumbs for CampZero.com

2009-12-27T20:30:00.000-08:00

According to google's SEO guideline, its a good idea to provide breadcrumbs to your web contents. This is good in two ways: a) It helps people to find path to move up the navigation stack and b) it helps the google and other search engines to get a feel about your web content's hierarchical organization.

To add this breadcrumbs support, in my application www.campzero.com, a going to be online service marketplace for Bangladesh, I simply used the Crummy plugin. You can take a look at the Crummy plugin at github. It took me less than 10 minutes to find, learn and use this plugin! You can see the plugin in action at the campzero site.

I recommend this plugin for your Ruby on Rails breadcrumbs needs!

acts_as_permalinkable: SEO friendly rails URLs using my first RoR plugin

2009-12-27T10:38:00.002-08:00

As a byproduct of my work on www.campzero.com, I released my first ruby on rails plugin called acts_as_permalinkable on github athttp://github.com/smsohan/acts_as_permalinkable

A comprehensive documentation is given at the github page. If you ever need to use search engine friendly urls or permalink like this blog, you may consider using the acts_as_permalinkable plugin. It takes less than 3 minutes to add the permalink feature to your rails model!

Get started by the following and you are free to contribute!

script/plugin install git://github.com/smsohan/acts_as_permalinkable.git

Sitemap-generator for your Rails App and deployment solution

2009-12-24T17:20:00.000-08:00

When talking about Search Engine Optimization for your public web pages, you probably try to follow the google guidelines for search engine optimization. Its a good one to get started with. For my recent project, www.campzero.com, I read the document and tried to follow the steps. Today, I worked on generating sitemap for www.campzero.com using the following:

Installed the site-map generator plugin following this link at Aktagon's, github link
For some reason, probably because of permission issues, my plugin install didn't generate the sample sitemap.yml file for me. However, I created the config/sitemap.yml file myself and put the following contents there:

domain: www.campzero.com
limit: 5000
priority: 1
change_frequency: weekly

Then, I put the call to the sitemap method as shown in the github documentation.
Finally, I ran the command rake sitemap:gerenate to generate my sitemap.xml file inside the public folder.
So far this went well with the local environment. However, when I deployed this code and ran the rake command in my staging environment, it said it was not finding any model with the sitemap method.
After some debugging, I found that the problem was with the code at the file generator.rb where they put model.methods.include?('sitemap_options') to see if the model contains a method named sitemap_options. But, at my staging environment, I found that this was returning false although there was this method inside the model. I changed the code to the following so that the include? check is done both for strings and symbols and it worked fine.

if((model.methods.include?(:sitemap_options) || model.methods.include?('sitemap_options')) && model.sitemap_options != nil)
models << model
end

Now, I could generate sitemap at my staging environment.
However, soon I found another issue with deployment, as I want my sitemap file to stay between deployments. So, I had to ensure the sitemap file is generated at a shared place other than the default public folder. I did the following changes to the sitemap_generator_task.rake file:

if defined?(SITEMAP_FILE_PATH)
SitemapGenerator::Generator.new(SITEMAP_FILE_PATH).find_models_and_generate
else
SitemapGenerator::Generator.run
end

I added the constant SITEMAP_FILE_PATH in my config/environments/staging.rb file to get it working.
Finally, I changed my deployment script to define a symlink from the public folder to the shared file path as follows:

run "ln -s #{shared_path}/sitemap/sitemap.xml #{release_path}/public/sitemap.xml"

How to strip html tags, truncate and highlight texts in ruby on rails

2009-12-22T13:50:00.000-08:00

Recently, I had the following requirements as I was working on CampZero.com - the going to be service marketplace of Bangladesh.

Remove all html tags other than hyperlinks and new lines from a html fragment
Truncate the text to show only first 200 characters of the text and append ellipsis (...) in case the text was truncated.
Highlight an array of words in the text to show the search query worlds that matched

The first one, getting rid of all but hyperlinks and new lines was achieved by the following code:


<%= sanitize my_html_text, :tags => %w(br a) %>

Next, to truncate the text, I simply used the following:


<%= truncate my_sanitized_text, :length => 200 %>

Lastly, to highlight my search query words, I did the following


#in the controller
@query_words = params[:query] ? params[:query].split(/\W/) : ''
#in the view

In reality, I chained the above thee methods as shown below:

<%= highlight(truncate(sanitize(my_html_text, :tags => %w(br a)), :length => 200), @query_words) %>

These methods and their siblings are great as time savers. Rails makes the web development fun by including this as built in methods. For reference, you can check the link at SanitizeHelper and TextHelper

Happy railing!

How is Rails plugins helping me in developing CampZero.com?

2009-12-18T15:24:00.000-08:00

I am up to a web venture called www.CampZero.com - an online market place for you service providers in Bangladesh. This is somewhat similar in spirit to classified sites like ebay and craigslist, but the target market it consciously chosen to be the service industry. Anyway, I will go to the point why I picked rails for this project and how it is paying off.

A little background about me. I have some good background on .Net/C# and I developed several projects using this technologies. Also, I have some experience with Rails and developed almost same number of projects as that of .Net. So, I made an informed decision about choosing the Ruby on Rails framework for my project over .Net/C#. Here's the rationale:

Story#1: As a CampZero developer, I want to deploy the system as soon as I am done with a feature.

Solution: Use capistrano to automate the deployment process. It took me less than 30 minutes to setup the automatic one-click deployment. The deployment steps are at a minimum as follows:

Get the latest code from the code repository.
Create a link to the shared log directory.
Create a link to the shared assets directory.
Create a link to the full text search configuration file.
Migrate the database schema.
Change the link to the application to the latest code.
Restart the full text search engine.
Restart the web server.
Rollback if any step of 1-8 results in a failure.

The whole process is triggered by a single line of command "cap staging deploy:migrations" and takes less that 3 minutes to complete on an average.

Story#2: As a guest user of CampZero, I would like to sign up for an account so that I can post an ad and/or rank the service providers.

The signup process is actually a three step process as follows:

Create account, with password encrypted.
Get an email with an activation link.
Verify email address by clicking an activation link.

Also, there are several related works as follows:

Login
Logout
Reset password

I used Authlogic for this purpose and it has taken care of all the aspects for me. For emailing I used ActionMailer. The whole job of authentication took no more than 4 hours! Thanks again to Authlogic.

Story#3: As a user of CampZero, I want to search for service providers using natural text.

The full text search was implemented using Sphinx and Thinking-sphinx. This also comes with default support for paginating lists. So, Thinking sphinx took care of all my search needs. I used the following features:

Search by full text in the service description, title.
Also search the service provider names and service categories.
Rank by the ratings.
Search using English morphology, for example, if searching for 'cars' it also searches for 'car'.

I spent as little as 6 hours to setup and code the whole free text search! The total coding size for search is less than even 15 lines in total!

Story#4: As a service consumer, I want to rate and write comment on my service providers so that other consumers can make informed decisions.

I used two plugins called, rate-fu and acts as commentable! These plugins are great time savers as well. All the underlying logics for handling ratings and commenting are already there and you merely plug the features in. It took me 5 hours and most of it was due to the UI part!

I am convinced that for most web applications now, Ruby on Rails is an automatic best seller. But, of course, my prior experience helped me in getting things done even faster. Lets see how this project makes a business :-)

"Promises are meant to be broken" and my 2010 promises

2009-12-17T00:45:00.000-08:00

"One must have a good memory to be able to keep the promises that one makes"

--Friedrich Nietzsche

"Promises are like the full moon, if they are not kept at once they diminish day by day"

--German Proverb

“Better a broken promise than none at all.”

--Mark Twain

Its always good to refer to previous experiences when you do a research. This doesn't only make you fair but also eliminates the reinventing the wheel problem! Well, this is what I learned from my graduate studies :-)

So, what is this about promises today? Well, you know its the time of the year when you have vacations and enjoy with family and friends... and start thinking about the next year. Make some rough plans probably for the upcoming year. Here is what I am promising-

By January 1, find two potential MS research topics and draw an outline of each!
By January 1, reduce 1kg weight!

What's next? Well, I have a vision of the future but trying to be agile here. Not doing lot of useless upfront thinking and leaving it up to the retrospect session on January 1 :-) I believe agile works and so if I can follow the spirits, I should be able to reach my vision on time.

My readers can wait till Jan 1 to get the retrospect report! I will be blatant and truthful (and this is a promise!).

What I learned from my first semester at University of Calgary as a Grad Student?

2009-12-15T11:20:00.000-08:00

In a single line, the first semester has been awesome.

Some of you already know that I came to Calgary, AB, Canada this fall to start a graduate research focusing agile software development. So, to get started I tried to come up with a research idea by hunting several resources including popular publications, blogs and books. This is not yet over...

However, I took a course called Applied Machine Learning and had the opportunity to work on a project that might lead to my MS thesis. The project, Auto Tagging Emails with User Stories, targets to grab and automatically tag emails with user stories based on a project's context information. The trick is, if you see the text similarity between an email and a user story and complement with their temporal and meta data similarity, you can make a guess about their relation. I wanted to make it an automatic process so that when people share knowledge in emails they can easily make use of this knowledge for future references. The project was successful in its scope and I submitted a paper day before yesterday. Keeping my fingers crossed to see the decision on this paper!

Apart from the project, this course also offered the unique opportunity to work with Prof. Dr. Richter. He was really helpful and spent a lot of time on my project and the paper.

Tavolo: A Tabletop Application for Conferences from Chris Luce on Vimeo.

I also did a group project for the Interactive Tabletops and Surfaces course. This project was called "Tavolo", a surface solution for conferences where people could bring their research ideas through images/videos/pdfs and annotate/share with others. This was my first ever tabletop project. We used Microsoft Surface and I liked the hardware so far. But in the end I found that the size and low resolution of the surface limited our opportunity to implement several features of the project. But in a nutshell this project gave me the opportunity to try something around Human Computer Interaction and next generation collaboration designs.

During the last week of November, I attended the ITS2009 conference. It was a 3 day international conference people came from all continents. I liked the presentations and the fact that this research community is as if its a connected web. I must say, the Bill Buxton speech was a great one. He envisioned the next generation human computer interaction and also discussed about real life commercial applications coming out of the research. It was very inspiring!

I also submitted a grant application to iCore. I am personally convinced that this was a good proposal and I have the necessary background to make it a successful research. But according to my supervisor, its a good idea to be less optimistic with iCore fund. Anyway, composing this application helped me in finding some of the holes in my writing and thinking skills. I will happily take this lesson!

In my family life, this was an eventful time as well. My wife, Shahana, got admitted to the ECE department at University of Calgary and she will start her MS this January. This means we might be graduating at similar times and be back to Bangladesh soon thereafter. Wish we make good use of the opportunity in our graduate studies.

Well, this is a pretty much a summary! But I forgot one thing, Swimming! For the last month and half, I am going to swimming 3/4 days a week and enjoying this activity. The university swimming pool, like all other games and sports venues, is really well maintained.

I am looking for a Camera and waiting for the Boxing Day sale. Let me know if you saw a good DSLR camera around $500!

Oh! I forgot another announcement! I have taken my first web venture at www.campzero.com! If you have some time stop by and let me know if you like/dislike the idea and its presentation. I am planning to go live from Jan 1 2010!

Merry Christmas!

Lean Thinking: You will probably like to learn the essence of agile

2009-11-06T14:05:00.000-08:00

Image taken from: http://www.leansoftwareinstitute.com/images/img_bigpicture.jpg

If you read the Poppendieck's book called, "Lean Software Development : An Agile Toolkit", you probably liked it because it managed to get the essence out of agile practices. So, what are these core principles? Well, most of you already know the phrase, "Inspect and Adapt". Now, you also know a bunch of specifications that facilitate this, for an instance, Scrum, XP etc.

Reading the book, I had a realization that, its good to talk using concrete facts as much as possible. So, doing a value stream mapping practice is worth than spending hours in discussing the process optimization. The same holds true with the Profit and Loss statement when figuring out which option to take - quality compromise, deadline shifting or feature squeezing. Being able to answer why questions, at least 5 in a succession, is something very critical - then you know the hidden junk thats causing the bad smell. I highly recommend reading this book, especially to people who are doing agile for a year or so and thinking about getting better at it.

I also had the opportunity to attend a speech by the authors on this Monday. The speech was a great one. But for my readers, I will write about an example from the speech.

Once Mary and Tom visited a company that creates hardware and software tools for real time video conferencing. They met the Boss there and asked what they were doing. The answer was, "We are working to improve the system so that our customers get better video conferencing solution for their businesses." They went to a section where people were working on hardware and asked one what he was doing. The person replied, "I am creating a component for the system, so that our customers can do better video conferencing". Then they went to a software developer and asked what she was doing. She replied, "I am working to improve a part of the software so that our customers can do better video conferencing".... (I am sure Mary used better words than mine and it was really interesting to hear the story in her voice :-))

So, the fact that she wanted to capture using this example is, although each individual is involved in a specific task, they envision the bigger picture from the customers' standpoint. This is really important. Because as soon as you start seeing the views from the customers' perspective, you will produce less bugs. In the book they mentioned, most software bugs are not results of coding/design errors, rather they arise from the difference in views among customers and developers.

Overall, it was a pleasure to read the book, although this blog post may not reflect all of my respect and take home from the book :-(

Now reading: Lean Software Development: An Agile Toolkit

2009-10-27T22:55:00.000-07:00

This book by Mary and Tom Poppendieck is an awesome read. I just read the first three chapters and loving it. More on this book will come later as I read more...

I am tuned to attend the next CAMUG session by the Authors! It should be a lightning session and looking forward to Nov 2nd.

Communicating tools for working on remote projects

2009-10-17T23:27:00.000-07:00

Ever since I started working in the software industry, as a freelancer or representing a company, I found the most challenging part of a remote software development project is "Communication". In agile setup, collaboration plays a leading role to be effective and efficient.

By communication, I mean the following:-

Getting the spec as intended by the client.
Asking specific questions on time.
Status update about progress, blocks and forthcoming events.
Getting feedback as intended by the client.
Making specific suggestions with rationale to the client.

I am listing a few tools that I used and recommend others to use.

A note pad: I write down small bullet points as soon as I find a question/suggestion/idea.
Voice chat/telephone call: It should be #1 preference. Its real time and most speedy after face-to-face. I use Skype for my voice calls and sometimes my phone as well.
IM: I use GoogleTalk most of the time if it works with client. Otherwise, I just use the one that my client uses most frequently.
Collaboration tool: I use ScrumPad.com. Post my messages, people get email notification and can directly reply on that notification. This way the collaboration is all captured in ScrumPad and we can also keep using Email.
A wire framing/drawing tool: Sometimes a small sketch/piece of drawing may greatly ease the communication hurdle. I use MS Visio at times. However, I also use scanned copies of hand drawings and annotations. It works. However, I am looking for a good web based wire framing tool and I believe it will off-load a lot of decision confusions.
Desktop sharing tool: Screen capture and desktop sharing also works for me. I use LogMeIn and Xing. These tools offer first class feedback capturing capability from remote clients.

I also try to follow some general rules:

Always have a prioritized list of points that I want to discuss.
Be on time.
Never stay disconnected for more than 3 business days.

I am sure out-sourcing will keep growing in the coming days, not only for its low cost but also for the fact that they are getting smarter and equally competent as people who charge many folds compared to them. I also anticipate a lot of out-sourcing job will go to individuals or 2/3 person groups, may be not from fortune 500 companies, but there are still other unfortunate millions of companies who will need such small teams. If you plan to work remotely, I am sure you will need some of the above tools, and if you are already in the business and think you have other good tools, please share with me.

Web application user interface without any Menu

2009-10-06T15:42:00.000-07:00

If you are like me, with little creativity with UI (!), on a new project you always start with a simple layout, banner followed by a row of menu and then a two column body that ends with a footer. Well, here is an example:-

----------------------------------------------------------

CampZero

zero hassle camping

----------------------------------------------------------

Home | Place a booking

----------------------------------------------------------

Welcome |

---------------------------------------------------------

Well, there are other ways and you will almost always see good visual elements in most websites. However, somehow all of these beautiful sites come with some sort of menu. This post is about a site that doesn't have a menu at all.

Yes it is possible to create a web app without a menu. The application that I recently developed is designed around an intuitive workflow. The workflow itself drives the app and it does so without any menu. For example, on landing you see a dashboard with three sections. Main section shows highlights of different projects, sidebar contains the search box and top part contains profile card. Now, you can navigate the whole application from here. For example, select a project you will see main section with the project latest activities and the search box will search in the scope of the project.

The point is, if you know the users of your app will most likely follow one of a few workflows, then you can design a UI that flows naturally.

Showing unread posts/comments: An example of rails ActiveRecord 'touch'

2009-09-21T14:47:00.000-07:00

I worked on the following story:-

"As a partner, when I visit a project's dashboard I want to see five most recently started or updated discussion threads with number of unread comments, if any. If any of these are new, I want to see them in a highlighted view. Next, if I open the thread, I want to see all new comments in a highlighted view as well. However, once seen, the threads/comments should no longer be highlighted from the rest."

I used the following steps to implement this.

Step#1: Added a model MessageReadTime (message_id, user_id, last_read_at)

class Message 
has_many :messages_read_times 
end

Step#2: Added filters in the messages_controller

after_filter :update_message_read_time, :only => [:show]
def update_message_read_time
read_time = MessageReadTime.find_or_create_by_message_id_and_user_id( params[:id], current_user.id)
read_time.last_read_at = Time.now
read_time.save!
end

Step#3: Added :touch=>true and unread? function in Comment class

class Comment
..
belongs_to :message, :touch => true
def unread?(user)
 read_time = self.message.message_read_times.find_by_user_id(user_id)
 return true unless(read_time)
 return read_time.last_read_at < (updated_at || created_at)       end   end

Step#4: Added unread_comments method in Message class like this

class Message
...
def unread_comments(user)
self.comments.collect{|comment| comment.unread?(user) ? comment : nil }.compact
end

def unread?(user)
read_time = self.message_read_times.find_by_user_id(user.id)
return true unless read_time
return self.updated_at >= read_time.last_read_at
end
...
end

This is it! If you know a better way to do this, lets discuss in the comments. You are also welcome to share your thoughts/suggestions :-)

Some useful plugins for RoR projects

2009-09-17T08:16:00.000-07:00

Previously I used a few plugins in RoR projects including ScrumPad. On a more recent work, I found the following plugins to be really useful and easy to get started:-

1. I18n: Rails Internationalization

RailsCast at http://railscasts.com/episodes/138-i18n

Guides post at http://guides.rubyonrails.org/i18n.html

2. Seed-fu: Initial data loading for application (e.g. admin user, product categories)

Tutorial http://github.com/mbleigh/seed-fu A support is now built in for Rails 2.3.4

3. Thinking-sphinx: Full text search

RailsCast http://railscasts.com/episodes/120-thinking-sphinx

Tutorial http://freelancing-god.github.com/ts/en/

4. Paperclip: File and image upload made hassle free

RailsCast http://railscasts.com/episodes/134-paperclip

Thoughtbot wiki http://wiki.github.com/thoughtbot/paperclip

If you looking for any of the above for features in your app, I suggest you give these plugins a try. It should be good for most of the apps unless you have some really unique needs.

Write in comments if you would like to share some other useful RoR plugins.

The CGI story on agile scaling success on a large project

2009-09-09T11:17:00.000-07:00

This intro is from the presenters:-

PAS was a joint venture development initiative by 4 major oil and gas
companies and CGI. Devon, Encana, Husky and Talisman joined with CGI to
develop a new Production and Revenue Application. Each company put 3 senior
business resources on the project. The development component of the PAS
initiative cost $35M over 5 years with up to 90 people on the team. This
presentation is on how we used Agile to achieve this mammoth undertaking.

The product is currently running in production at 5 major oil and gas
companies with great reviews. It is also in production for several mid and
smaller sized companies. CGI is currently marketing the product.

This was my first ever meet with the Calgary agile methods user group, CAMUG and it was a great experience. Off late, I have been looking for my graduate research topic on agile methods, especially around scaling agile beyond a single team and this was just a perfect session for me.

I noted down a few of their discussed topics that I would like to share with my readers:

The project continued in dev mode for 5 years, a $35M project.
It started with only 3 members and extended to a team of 90 following Scrum+XP.
The project had 5 sponsoring companies or clients.
They had 6 teams working in the same sprint cycles.
In each team, there were significant members from the business working full time with the team onsite and in the same open-space arrangement.
They had some 3000+ unit tests and also 300+ acceptance test.
They automated all repetitive tests.
The had external experts visiting them from time to time. Eric Evans once visited them and helped them getting better grasp on Domain Driven Design.
There had been a $800K and one month deviation from the projected cost and timeline.

They also discussed some issues related to working in a multi-team, multi-client project. I remember the following ones:-

They had to balance between features/bug fixes.
The deployment was taken care of by the respective sponsors, not the teams.
They had issues with sprint backlog management.

They highlighted some aspects with great emphasis:-

Open communication is the key to success.
Onsite and full time real user availability is very important for such a big project.
Automated tests, partial pair programming and continuous integration is a big plus.
Staying co-located was really helpful.

What about scaling beyond?

I asked them, if they felt it would still be a similar success if there had been 12 teams or even more with 200 people or so. They said, it would be challenging. But in response, they also said, following waterfall would make life much harder with such a big team, if at all it could be a success at the first place! Yes, I also believe this.
One of the audiences asked if they outsourced a part of the project and the response was 'No'. CGI has a big team in India with a very high CMM ranking, but the project manager and asst. project manager said, it would be much difficult for differing time zones. Also, it would be difficult to transfer the knowledge as well as replicate the value of onsite client presence. The development manager also added that, the cultural difference between an agile and CMM setup would also been an issue if they had to go for the off-shore team.

The session was much more eventful than what I could compile. So, if you are anywhere near Calgary and interested about meeting agile practitioners from the industry, lets meet at the next meet!

A new home at Calgary and starting days

2009-09-06T20:58:00.000-07:00

We relocated to the northwest section of Calgary, Alberta on the 26th August. I am new to this part of the world and traveling to this opposite time zone (GMT+6 to GMT-6) took around 33 hours. Did you ever take a flight on Qatar? Not? I recommend it. They offer best foods for your south asian delight. My route was Dhaka - Doha - London - Calgary. I enjoyed the trip (don't tell anyone, I was a bit scared when traveling over the Atlantic :-))

The city of Calgary is really eye soothing green during this season. The little homes and lawns look fabulous in my eyes. People here celebrate the summer in style, you will see large family camping vans every now and then. So far the people here are also very friendly and welcoming towards new comers. It has been a good experience and hopefully coming days will be even better!

On the 4th, I attended the graduate orientation program and met a lot of people. It was nice to know that the University of Calgary is equipped with all amenities required for an excellent graduate education. I am looking forward to use my free pass to the swimming pool! It'll be fun!

I met my supervisor, Frank, and also people at my Lab. My next duty will be to select a topic for my research by the end of this year. But the earlier it is selected, the better it is. Let me know if you have a good idea on your heads around agile software process/tools or digital tabletops.

My upcoming posts will be a mix of my graduate studies and my software related works. Also, I will be TAing and wish to share some of my teaching experience as well. Stay tuned!

Rambling stories from my days @ Code71 : My Takehome

2009-08-19T19:44:00.000-07:00

Today is going to be my last day with the Code71 team and this is the last post of the series on my Code71 days.

The journey started on June 1, 2006 and now at this moment, I just wanted to summarize my takehome from the last three years' of work. I will go short, just touching the bits...

Teaming is at the core of Code71's culture. It went beyond teaming just for software development as we met outside for a movie, celebrated even the smallest of personal achievements and shared the excitement of a cricket or tennis match even at midnight from home over phone!

Planning and adapting practice. I have gone through aprroximately 70 sprint planning and 50 sprint retrospect sessions at work. But this scrum habit of inspect and adapt has been engrossed in my personal life as well. I try to maintain a written to-do list with deadlines and look back at times.

Continuous learning. As I worked on different technologies (.Net/RoR) and different domains (Financial/Vehicle dealership/Project management/Web community), I learned to grab new concepts. I developed a learning attitude towards solving a problem and realizing an opportunity.

Happy memories are great as takehome gifts and I feel blessed to have a large array of such memories. Helping the team growing and maturing towards best-practices is itself a happy feeling. And there are those great memories with seeing a start-up client making millions, getting gift card from happy clients on new year... and of course the team meets at the Code71 dining.

I will end with a few thanks note here. Thanks to Nimat and Syed for believing in my competence and giving me the opportunity to work, lead and learn. (I am really sorry that the I had to turn down the L-1 offer, it really was too late!). Thanks to all of my teammates for your ever smiling faces and support. Thanks to Omar, my first mentor at Code71, for introducing me to the basics and the pathway to continuous learning. A special thanks to Sohel, our office assistant, for his ever enthusiastic service and care. Wishing best of luck to Shaer and his team, you will take the company to the next height inshaAllah.

I am going to graduate school at University of Calgary, Canada this fall to start my MS under Prof. Frank Maurer and looking forward to it. I hope my experience at Code71 will help me in my future life and who knows, may be someday I will again be a part of the Code71 team!

Rambling story from my days @ Code71: My reading list

2009-08-11T22:30:00.001-07:00

In my previous post, I got a bit nostalgic! However, ever since I posted the first one, I was looking for another post on the series. Trying to capture what I learned during the past 3 years, I found it would be really time taking for me and my readers. So, I sort of compiled the following list in this post. Hope it helps someone who is just eager to learn about software.

Books

Most visited sites

Blogs

Community

Rambling stories from my days @ Code71 : Startup days

2009-08-08T22:04:00.001-07:00

Sighs!

Back then, on Friday, May 26, 2006, I was a final year undergrad student at CSE, BUET. I was looking for a part-time software dev job opportunity and found a little one page advert for a student job at asha-technologies (lately renamed as Code71). Visited their website and thought it might be worth giving a try!

As usual, I was interviewed over phone and enjoyed a long 2 hour interview on premise. I found it really inspiring and gained more interest towards the job after this session. I started waiting for a response… but was pretty certain about a positive one!

Good things happen in quick successions in our lives. Agree?

I agree. Because I just started a soul-journey with my soul-mate, Shahana, on the March of 2006. Then got the job offer on the 26th of May! Couldn’t be happier. A job for me during that time was just beyond its compensation, it was an inspiration, opportunity to see the real world and being part of something bigger than myself.

Photo taken at Chhera dip (The Torn Island), St. Martins, Bangladesh. The last photograph taken with my first digital camera bought from my first month’s Salary!

I started my job on the 1st of June, 2006 at Asha-technologies. Asha-tech was still to find an office and Omar asked to meet him at his home office! That’s how it all started. We met a few times a week at Omar’s home until we moved to our office at the green building of green square at green road, Dhaka on the first of July.

Asha-tech signed up a client before it was even formed! So, once we moved into the office, we were building our first asha-tech product, an online loan financing gateway. We were enthusiastic about agile scrum/xp practices from the first day at office. The result was found in just less than 3 months. We rolled out our first release of the product. It was really a happy start. A fantastic start for a start-up. The client started generating revenue in less than 3 months of project inception!

The office setup was a small but adequate enough for our team. We installed long backup UPS (2 hours * 5 computers), A/C, IPS and dedicated internet connection with Wi-Fi. The work environment was full of fun. We were going for an outing to a team event every month and even more often going to delicious buffet places. We played table football and bowling… every time had a record breaking score and a new winner. We went swimming and believe me, Omar is as good a swimmer as he is a master in software technology. He would go to swimming with a flipper and flip like professional swimmers. He can even swim without using his hands/legs at all, lying side-on and in all such actions… I learned swimming keeping heads down and the easy way of breathing from him! Thanks!

Technologically we were maturing as well. Started using XPlanner for managing our project, attended daily standup meetings and started doing TDD. I won’t claim we got everything right at the first try… but, we were trying consistently, improving bit by bit… to this day.

For the most part, I was enjoying my job and became used to the pressure of a job + undergraduate studies. I said, good things happen in close succession. Another proof here! My first term final result with this job was a 4.0/4.0. I never scored 4.0 in a term before this nor had a 20+ hour/week job alongside my studies.

I strongly believe, my job taught me the attitude towards work, “plan, act and retrospect”. After over three years, I would suggest any new entrant in the software industry to start a career with passion. Its fun with passion. Its a win everyday with passion.

Rails modeling guide#2: naming convention for ruby on rails model methods

2009-07-16T19:15:00.001-07:00

Naming conventions play an important role to the software's overall architecture. It is not a rocket science, still, it may lead to unhappy consequences if not taken care of at the early stage of a project. This small best practices can make a code base significantly improved.

Rails does a good job by using the dynamic power of ruby and providing with a handful of dynamic methods with the models. ActiveRecord::Base and its included modules follow a consistent naming, which clearly represent the intended purpose of the methods. At Code71, we are working on ScrumPad, a 2nd generation agile scrum tool using ruby on rails and our model methods are named according to the following rules-

1. All boolean returning methods end with '?'

company.billable?, sprint.current?, story.in_progress?

2. Boolean methods do not start with is_ or has_ or did_ (as you might see in other popular languages)

company.is_billable? -> company.billable?
sprint.is_current? -> sprint.current?

3. find_ and find_all are used only for class (self.find or self.find_all) methods and should return a single/array of object of the class respectively.

find_* methods may return a single object of the class/nil

find_all_* methods return an array of objects of the class or [], but never a nil

4. No methods start with a get_ as other languages.

5. A method ends with ! if it alters the object itself.

sprint.close!()
story.progress!()

6. Methods that persists an object/may throw exception, should always end with ! (implied from rule 5)

invoice.update_status!(:paid)

7. Always use parentheses '()' in method names. Future versions of ruby is deprecating the support for method names without parentheses.

Following these 7 simple rules we have consistent and intuitive model method names across the whole ScrumPad. Let me know if you have any suggestion to these names to make it even better.

Rails modeling guide#1: right structure of a ruby on rails model

2009-07-16T07:52:00.000-07:00

Rails models are no exception compared to the super models! You are in the business if and only if you got a good physical structure and can stick to it for years...

At Code71, we are keeping our rails models attractive following a few guidelines. I will be posting these guidelines in a series and here goes the first one - about the physical structure of the ruby on rails models.

We keep the following order consistent in our models:-

CONSTANTS
has_one, has_many, belongs_to, has_and_belongs_to relations in dependency order
plug-ins initialization (acts_as_tree, acts_as_state_machine etc.)
validates_presence_of
validates_uniqueness_of
validates_numericality_of
validates_format_of
custom_validations
named_scopes grouped by related purposes
active record hooks (after_initialize, before_create, after_create, ...) in execution order in the format (after_initialize [:assign_default_state, :sanitize_content] )
protected
hook method implementations according to execution order
public
constructor
class methods in alphabetic order
other methods alphabetically or grouped if related
protected
methods alphabetically or grouped if related
private
self methods in alphabetic order or similar methods in a group
other methods in alphabetic order or similar methods in a group

Rule

No method gets code real estate over 20 lines. If needed, one/more private methods are used.

How is this helping us?

We are absolutely sure where to look for a method or where to write a new method.
The code base is really consistent.
The unit test methods also follow the same order, which makes managing the test suite easy.

More to come later this week. Stay tuned!

Implementing breadcrumb in rails projects – a clean approach

2009-07-07T22:23:00.001-07:00

In most web applications, breadcrumbs offer a nice way to trace back to previously visited pages. However, generating the breadcrumbs and showing them on dynamic pages sometimes need special care for the following reasons-

The links of the breadcrumb may contain dynamic links.
It is used in all the pages. So, changing the breadcrumb may trigger a series of changes.

In ScrumPad, we are using ruby on rails. There are a few plugins to help rails projects in managing breadcrumbs, but none seemed to satisfy our need. In fact, most projects come up with some distinctive ways to generate the breadcrumbs. However, we kept the breadcrumb clean in the following way in ScrumPad.

Step#1:

Encapsulated the breadcrumb generation logic into a single class and used it from all places.

class Breadcrumb
include ActionView::Helpers::UrlHelper
include ActionView::Helpers::TagHelper
include ApplicationHelper

attr_accessor :parts, :separator, :prefix

def initialize(separator = nil, parts = [])
  self.separator = separator || "<img src="\"/images/stub_arrow_right.gif\"" />"
  self.parts = parts
end

def add(title, url = nil)
  self.parts << {:title => title, :url => url}
end

def set_prefix(title, url)
  self.prefix = {:title => title, :url => url}
end

def to_s
  if(!self.parts.nil? and !self.parts.empty?)
    if(self.prefix.nil?)
      parts_with_prefix = self.parts
    else
      parts_with_prefix = [self.prefix] + self.parts
    end
  
    breadcrumb_html = []
    parts_with_prefix.each do |part|
      if(part[:url].nil? or part[:url].empty?)
        breadcrumb_html << "#{part[:title]}"
      else
        breadcrumb_html << link_to(part[:title], part[:url])
      end
    end
    return breadcrumb_html.join(" #{self.separator} ")
  end
  return ''
end
end

Step#2:

A before_filter in the ActionController initializes the breadcrumb in the following way:-

def initialize_breadcrumb()
  @breadcrumb = Breadcrumb.new
  if(project_selected?)
    @breadcrumb.prefix = {:title => "Dashboard", :url => dashboard_project_path(selected_project())}
  end
end

Step#3:

Now, @breadcrumb is available to all actions. However, if the RESTful resource definition is right, the rest of the breadcrumb generation becomes really simple. We have methods like the following in our controllers-

def generate_breadcrumb(sprint, story = nil)
  @breadcrumb.add(sprint.name, project_sprint_path(project.id, sprint.id))
  if(!story.nil?)
    @breadcrumb.add(story.display_title, story_path(story))
  elsif(self.action_name != 'index')
    @breadcrumb.add('Stories', stories_path())
  end

  current_page = self.action_name == 'index' ? 'Stories' : self.action_name.humanize
  @breadcrumb.add(current_page)
end

Step#4:

Finally, in my view layout, I just use this instance variable as shown here:-

<%= @breadcrumb %>

So, the whole breadcrumb generation is encapsulated and the implementation is clean. Let me know if you liked it. I am in the process of creating a plugin so that anyone can just drop it in any rails app and start using straight away!

Lesson#2: Pace Your Sprint Rightly

2009-06-15T00:58:00.001-07:00

In my previous post, I said about being incremental. Here come the next thing, being “ITERATIVE”. A prefer the term Sprint than Iteration.

So, once you decided to take small increments, make sure you reach the targets sprinting.

I suggest you prepare for sprinting with the right techniques and tools. A few recommendations-

Never miss a daily standup meeting. Spend only 2 minutes (or less) per person answering the three questions – what did you do yesterday, what’s on the plate for today and what is blocking the race?
Install visual clues for bringing the under the hood stuffs to daylight. Remember, being able to address the loopholes is the key. The solution usually follows automatically.

The key concept to internalize is, sprinting is a balance race. You need a good start and keep the momentum to reach the touch line on time. Its a small race and if you fall back, the touch line may seem too far to celebrate.

At Code71, ScrumPad, is helping us in sprinting. Our sprints are two week sprints in most projects. We found the team communication holds a key in meeting the deadline. Since, within a sprint, someone of the team may need an unplanned vacation or an issue may arise out of the blue, the team needs to step up and put extra efforts. Again, visual clues help the team in keeping everybody posted timely.

If a team finds it difficult to meet the deadline and find the sprint length to be too small, then what? Should they linger the sprint length? NO. The solution is to even shorten the length. To make sure, the team can plan for short spans with better accuracy. Lingering the sprint length addresses the wrong disease and hence may not solve the problem.

Lesson#1: Going Incremental is Natural!

2009-06-03T21:25:00.001-07:00

As Scrum and Agile processes tell you, do it in small sprints, 2 weeks preferably, and go incremental. Take a small piece at a time and sprint.

I took this image from internet and credits to this site.

It’s easy to work out the Natural way than to defy it! If you are iterative and incremental, you are reaching towards the right hand side of the image! And to make the evolution faster, I suggest you try out Scrumming with ScrumPad. If you value “teaming” and “delivering” in sprints, ScrumPad will give you the oxygen to breathe while you sprint!

I suggest you follow a routine to iterate. At Code71, we follow the below-

Day 1: Plan for the next 9 days. Breakdown work items into smaller tasks, estimate at hours for each of the tasks and assign each task to an individual.

Day 8: Release in test server (shadow version of the real production environment) and collect customer feedback.

Day 9: Work on customer feedback and go live in production server. Always tag the version that is put in the production following the standard -

R<ProductReleaseVersion>.S<SprintNumber>.B<BuildNumber>.P<PatchNumber>

This gives us the rollback point when there is any issue in the latest production deploy. Of course, we make sure we do not need to touch on the tags too often!

How are you sprinting? Let me know if you have a suggestion.

Its easier to get lost! Would you?

2009-06-03T02:27:00.001-07:00

I was talking to a friend of mine, who started a IT start up and working full time with a few others to foster the business. He was telling me-

“We have 13 projects running at this moment. We are working our heart out. But, we are not finding any time to do Test Driven Development, Continuous Integration and all the good things…”

Well, I understand how it feels! As the title says, “Its easier to get lost!”

Do you fancy getting stuck at this maze?

For startups, it is difficult to control the pulse. Because, you want to reach your billion dollar spot as early as possible, this week, or even earlier, today or even just in a few hours! And, as days go by, you start to feel the need for some process, to safeguard your efforts and quality, to hit the deadlines, to get in the rhythm of a sustainable pace.

But it may be really difficult to catch the ball at the first jump. We, at Code71, believe we need to be visibly competent and confident about the quality of our work. And worked hard to get the gears together in motion. Now it is cliques great. We have got the people motivated to follow the best practices, the tools to “do more with less” and the process to ensure a “sustainable pace”. I advise, you do at least the following to learn to escape the maze from tomorrow-

DIE for planning. Plan for short spans. We plan for two week sprints.
While planning, estimate honestly. Estimate all the hours necessary for following best practices. (producing automated test scripts may take 40% longer time, but bear with it)
Plan on your inputs. You cannot push your inputs. So, you may need to squeeze the output to match against your capacity.
DIE to meet the deadline according to the plan.

This is the mindset. You need to start believing to sustain. You need to plan honestly and never miss a deadline. After reaching the deadline, you retrospect. Find the loopholes and start filling those one by one. If you don’t see a loophole, find a ladder to reach higher. But do not place a ladder on a land mine!

Its not difficult if you have the preparation. To prepare, at a minimum do the following-

Have a Continuous Integration (CI) server up and running 24x7 or DIE. (We use CruiseControl, its free and great)
Make your CI server to send build, test and coverage report for you. Keep an eye on the coverage report and DIE to remain well above the the 80% line.
Keep track of your activities for retrospect. We use ScrumPad. It helps you to iterate, collaborate and deliver.

The keyword is “sustainable pace”. I found Scrum to address this sustainable pace really smartly. If you haven’t tried yet and looking for the loopholes to fill or the ladder to climb up, I suggest you learn about agile and Scrum, find an expert and give it a try. It’s worth than you might have expected.

If you know a better way to keep delivering better, I will appreciate for sharing your idea to me.

Unit/Functional Test Rails ActionController filters following DRY

2009-05-13T00:49:00.001-07:00

At ScrumPad most of our controllers are bounded by filters for authentication/authorization. Some filters apply to all actions in a controller while others apply to only a few or leave out only a few. However, since we are following TDD, we need to test the filter is invoked before each of the desired action. This makes the test code MOIST (not DRY)!

Example of Moist Code:

The following example only captures two test methods. However, if you have 30 controllers like ours and on an average 5 filters at each, you will possibly find many such duplicates making your test code so moist that it becomes shabby!

class SomeController
before_filter :authenticate
before_filter :restrict_invalid_role
end
class SomeControllerTest
def test_index_redirects_without_login
get :index
assert_redirected_to :controller=>:login, :action=>:login
end
def test_index_redirects_without_valid_role
login_as(:invalid_role)
get :index
assert_redirected_to :controller=>:exception, :action=>:not_allowed
end
end

Example of DRY Code:
I came up with the following implementation to help us with unit testing the before filters. The assumption is, if your filter is invoked, it will work fine. And we are testing the filter only once. The following code is written at the end of the test/test_helper.rb.

class ActionController::TestCase
##example: should_apply_before_filter_to_actions(:authenticate, [:index, :new])
def should_apply_before_filter_to_actions(before_filter_name, actions)
if(actions.nil? or actions.empty?)
  assert false
end
filter = find_maching_before_filter(before_filter_name)
actions.each do |action|
  assert_before_filter_applied(filter, action)
end
end
##example: should_apply_before_filter_to_action(:authenticate, :index)
def should_apply_before_filter_to_action(before_filter_name, action)
filter = find_maching_before_filter(before_filter_name)
assert_before_filter_applied(filter, action)
end

##example: should_not_apply_before_filter_to_actions(:authenticate, [:index, :new])
def should_not_apply_before_filter_to_actions(before_filter_name, actions)
if(actions.nil? or actions.empty?)
  assert false
end
filter = find_maching_before_filter(before_filter_name)
actions.each do |action|
  assert_before_filter_not_applied(filter, action)
end
end

##example: should_not_apply_before_filter_to_action(:authenticate, :index)
def should_not_apply_before_filter_to_action(before_filter_name, action)
filter = find_maching_before_filter(before_filter_name)
assert_before_filter_not_applied(filter, action)
end

##example: should_apply_before_filters([:authenticate, :session_expiry])
def should_apply_before_filters(before_filter_names)
if(before_filter_names.nil? or before_filter_names.empty?)
  assert false, "No Before Filter is Passed"
end
before_filter_names.each {|filter| should_apply_before_filter(filter)}
end

##example: should_apply_before_filter(:authenticate)
def should_apply_before_filter(before_filter_name)
filter = find_maching_before_filter(before_filter_name)
if(filter.nil?)
  assert false, "no matching filter found for #{before_filter_name}"
end
assert filter.options.empty?, "the filter #{before_filter_name} has only/except options and does not apply to all actions"
end

private
#finds the matching BeforeFilter object
def find_maching_before_filter(before_filter_name)
filters = @controller.class.filter_chain()
if !filters.nil?
  filters.each do |filter|
    if(filter.is_a?(ActionController::Filters::BeforeFilter) and filter.method == before_filter_name)
      return filter
    end
  end
end
return nil
end

#asserts a single BeforeFilter is applied on a single action
def assert_before_filter_applied(filter, action)
if(filter.nil? or action.nil?)
  assert false
end

if(filter.options.empty?)
  assert true
  return
end
if(!filter.options[:only].nil?)
  assert filter.options[:only].include?(action.to_s)
end
if(!filter.options[:except].nil?)
  assert !filter.options[:except].include?(action.to_s)
end
end

#asserts a single BeforeFilter is not applied on a single action
def assert_before_filter_not_applied(filter, action)
if(filter.nil? or action.nil?)
  assert false
end

if(filter.options.empty?)
  assert false
end

if(!filter.options[:except].nil?)
  assert filter.options[:except].include?(action.to_s)
end
if(!filter.options[:only].nil?)
  assert !filter.options[:only].include?(action.to_s)
end
end
end

Now my test code looks like the following-

  def test_filters
should_apply_before_filters(:authenticate, :restrict_invalid_role)
end

I can use the other methods as well to get finer control if the before_filter is applied using :only or :except options. And I can use these helper methods across all my controller test classes, making the whole point of testing filters really neat and short.

If you are familiar with shoulda tests, you will find the above code following shoulda like naming conventions. I found the above code to strip a lot of your efforts, since you eliminate all test codes that safeguard your filters.

Hope it helps someone with similar need.

Forget Me Not! Object Oriented Design in Custom Exception

2009-04-26T03:59:00.001-07:00

When designing custom exceptions, you may forget about old school OO fundamentals. As a reminder, lets take a look into the following custom exception classes.


StorySaveError
StoryDescopeNotAllowedError
StoryCompleteError
StoryNotFoundError
StoryDeleteError
StoryDeleteNotAllowedError

These exceptions are really useful in my application. But the bad thing is, they all derive from StandardError class, whereas there should be a base class, may be StoryError, which is more meaningful and useful. So, we can have the following-


class StoryError < StandardError
end
StorySaveError < StoryError
StoryDescopeNotAllowedError < StoryError
StoryCompleteError < StoryError
StoryNotFoundError < StoryError
StoryDeleteError < StoryError
StoryDeleteNotAllowedError < StoryError

With the addition of a base class for all Story related exceptions, I can write cleaner/better code.

When I am not interested about the specific error, I can just use rescue StoryError to catch 'em all
I can place a common error handling routine for all Story related exceptions
I can add new exception types without altering the codes where the specific type of StoryError is insignificant

From my experience, I found that most people are not cautious about OO when desiging custom exceptions. (because they are exceptions!). Nonetheless, if you follow the OO guides, it will pay off for sure.

Unit Test eager loading in Rails ActiveRecord association

2009-04-21T20:44:00.001-07:00

To avoid the n+1 problem, you need to use eager loading in ActiveRecord object associations. An easy implementation of eager loading can be done using named scope in the following way.

class User < ActiveRecord::Base
 has_many :friends
 named_scope :eager_load_friends, :include => :fiends
end
User.find(user_id).eager_load_friends

To unit test the named scope, you can use this following helper method (keep it in test_helper.rb, if you like) that I wrote for ScrumPad

def test_eager_loaded(model, association)
 assert !model.instance_variable_get("@#{association.to_s}").nil?
end

You can then test your eager loading in the following way

def test_eager_load_friends
 test_eager_loaded(User.find(1), :friends)
end

You can also use the shoulda plug-in if you like. For me, I think we should test the values returned by our named scope as opposed to shoulda approach, which tests if the code is written as expected.

Got another solution? I will appreciate if you share.

Implementing Template Method in Rails Controllers Using Module and Mixin

2009-04-15T01:44:00.001-07:00

All rails controllers are subclasses of the ApplicationController class. A typical controller class declaration will look like the following-

class LoginController < ApplicationController
#the actions go here
end

With this basic information, I would like to state the problem first.

The Problem/Job in Hand

Add an action switch_project to all the controllers (> 20) of the ScrumPad code base. The implementations of the switch_project method will be same for all the controllers only other than the fact that, the switching destination will be different.

Analysis

Placing the switch_project action in the ApplicationController would be the best option. But, the methods of application controller are not accessible as actions. So, the following won’t work

class ApplicationController
 def switch_project
   if(is_valid_switch?)
     logger.debug(“A switch is taking place”)
     destination = get_destination(new_project_id)
     redirect_to destination
   end
 end
end

if you hit http://server/login/switch_project you will get a server side error. However, if you instead place the switch_project inside the LoginController, it will work fine. But, of course at a cost. You need to copy/paste this method 20+ times as there are 20+ controllers with the same need! Horrible!

Again, as I said, the get_destination(new_project_id) is the only part that will be different for each of the controllers. So, we definitely find a template method here.

The Solution

If you need an introduction about Module and Mixin in Ruby, please read here at ruby-doc. We are going to use Mixin to implement the desired solution, efficiently.

So, I put the switch_project method in a module called, ProjectSwitchModule inside a new file at app/controllers/project_switch_module.rb like this-

module ProjectSwitchModule
 def switch_project
   if(is_valid_switch?)
     logger.debug(“A switch is taking place”)
     destination = get_destination(new_project_id)
     redirect_to destination
   end
 end
 def is_valid_switch?
   #I determine if the switch is valid at this method and return boolean
 end
end

To make it available to all my controllers, I include this module in just in the ApplicationController in the following way-

require ‘project_switch_module’
class ApplicationController
 include ProjectSwitchModule
end

Also, to provide controller specific implementation of the get_destination(project_id) method, I am just writing this method in each of the controllers in the following way-

class LoginController
 private
 def get_destination(project_id)
   #custom destination logic for LoginController
 end
end
class MessageController
 private
 def get_destination(project_id)
   #custom destination logic for MessageController
 end
end

Now, if I invoke http://server/login/switch_project or http://server/message/switch_project I will get the result of the switch_project action. So, this gives us an elegant way to follow design patterns for efficient implementation. It will save a lot of my time in future when I need to change the switch_project method, since I just need to change at a single place instead of 20s.

Afterthoughts

If, for a controller the switch_project needs to be different from the template at the module, it is achieved simply by overriding the switch_project inside the controller. No worries!

I will appreciate any feedback on this article.

Testing the SyntaxHighlighter Scripts

2009-04-11T20:58:00.001-07:00

For the last few months, I am on the lookout for a really good syntax highlighter that helps me to post blogs on all the programming languages in a pretty html with syntax coloring/highlighting. This one is taken from http://alexgorbatchev.com/wiki/SyntaxHighlighter

Ruby/Rails

class TestHighlighter
def my_highlighter
  return "SyntaxHighlighter"
end
end

CSharp

public class TestHighlighter
{
public string MyHighlighter
{
  get {return "SyntaxHighlighter";}
}
}

What did I add to my blog?

Open Edit Html and add this just before in the blog's template

<link href="http://alexgorbatchev.com/pub/sh/current/styles/shCore.css" type="text/css" rel="stylesheet" />
<link href="http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css" type="text/css" rel="stylesheet" />
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushJScript.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushRuby.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushSql.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushXml.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCSharp.js' type='text/javascript'/>
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCss.js' type='text/javascript'/>
<script type='text/javascript'>
    SyntaxHighlighter.config.bloggerMode = true;
    SyntaxHighlighter.all();
</script>

Thanks to Ashraf for informing me about the Windows Live Writer Plugin! It will be useful for sure.

Pair Programming: How am I feeling?

2009-04-09T04:51:00.001-07:00

For an explanation of Pair Programming, please visit this wiki entry.

Good

I am pair programming on the ScrumPad project now and the feeling in general is good. I have this perception is the work quality is better than doing alone. Also, the amount of time wasted to find small issues are now much reduced. Overall, its good.

Productivity Increased

I definitely found the productivity boosted by a factor of 1.5 at least. May be this is specific to my case, as I am working on a mid scale refactoring task. We worked on two user stories so far and completed the stories in 1.5 times faster compared to the individual estimates. We are doing estimation on a regular basis and the variance between estimation and actual hours are less than 5% as we see in the last 17 sprints in this project.

Disclaimer

I am yet new to this practice and not in a position to draw a conclusion yet. However, I believe our open space set-up and strong team culture helped us a lot to start this pair programming.

Are you pairing? Please, share your feelings and suggestions.

assert_equal_float : assert_equal between two float objects with precision

2009-04-07T20:17:00.001-07:00

In doing rails unit testing, sometime you need to assert the equality between two float objects in the following fashion

assert_equal 32.8, object_under_test.method_returning_float

The internal storage of float objects sometimes will contain 32.8 with additional lower precision decimal points and hence the assert may fail although the significant digits may be same. For example, the value of object_under_test.method_returning_float may be stored as 32.80000001 in memory and the above call may fail.

To solve this problem, you may wish to use the round method of Float class in the following way

assert_equal 32.8, object_under_test.method_returning_float.round(1)

The above line will evaluate true since it will round up to one decimal points. However, be careful about cases where you may have a value greater than 5 in the second decimal place! because (32.86).to_f.round(1) will become 32.9!

However, when you are talking about insignificant digits, this rounding should work fine for you.

Next step is to define a new assert_equal_float method that takes the precision as an argument. Adding this method will save you from code duplication and will improve readability.

def assert_equal_float(expected, actual, precision)
assert_equal expected.to_f.round(precision), actual.to_f.round(precision)
end

Happy float asserting!

Looking at ASP.NET MVC

2009-04-05T20:25:00.001-07:00

Being over-burdened by all the blog posts on MVC from the ASP.Net for the last few months, I am now looking to ASP.Net MVC. Still seeing the tutorials on asp.net/mvc site.

I have worked on a few rails projects and the ASP.Net MVC implementation is very much like Rails. Anyway, still early for me to comment!

named_scope : Real life examples from ScrumPad

2009-03-30T21:09:00.001-07:00

I am working on ScrumPad chat refactoring now. In rails 2, the named_scope feature works really great for ActiveRecord models. Lets start with the code first-

The Source Code:

class ChatUser < ActiveRecord::Base
belongs_to :chat
belongs_to :user
belongs_to :chat_status, :foreign_key => "status_id"

named_scope :closed, lambda {|chat_id| {:conditions => ["status_id = #{ChatStatus::CLOSED} AND chat_id = ? ", chat_id]}} do
def invite()
each { |chat_user| chat_user.update_attribute(:status_id, ChatStatus::INVITED) }
end
end

named_scope :active_chats, lambda {|user_id| {:conditions => ["user_id = ? AND status_id not in (#{ChatStatus::CLOSED}, #{ChatStatus::LEFT})", user_id]}}
named_scope :with_chat, :include => :chat
end

So, you get an idea about the ChatUser class. Its a relation object between user, chat and chat_status with some additional fields.

How am I Using My named_scope?

ChatUser.closed(chat_id)

Gives me all the chat users who closed their chat windows for the chat having chat_id.

ChatUser.closed(chat_id).with_chat

Gives me the same objects as previous but eager loads the chat object. So, it saves plenty of database calls when I need to iterate through the chats!

ChatUser.closed(chat_id).invite()

Invites all users to a chat with chat_id if the buddy closed the chat window.

Why named_scope?

named_scope is not just a syntactic sugar. It generates much less query using WHERE IN clause instead of WHERE = clause. So, reduces the number of calls to a single call.
Chaining the named_scope will generate only a single query for the chain. So, ChatUser.closed(chat_id).with_chat will produce only one query.
You get rid of looping in many cases! It will help you to write concise and clear codes.
When you can divide the objects in your classes in partitions, then you may wish to write the named_scope for partitioning the data. In my example, the :closed named_scope does this. So, I can add methods to this named_scope which actually works for the closed chats. It is kind of dividing your objects into named groups. So, it increases readability.

Let me know if you have another good example of a real life named_scope in your project.

Design/Code Review: Now, It's time to realize!

2009-03-23T10:14:00.001-07:00

Are you doing code reviews?

Thank God, you are.

Not?

Well, you are not alone. You know, most of your bugs could be killed by reviews. Most of your technical debts could be paid by reviews. Your team could collectively learn more by reviews...

Now, It's time to realize!

Start now! It's simple. I have found the following approach to be useful-

Pair up with one developer. Make it explicit to the team. So, you know who reviews your code.
Mix up a junior team member with a senior one, if possible.
Have a fixed time, at least 30 minutes for each two weeks to do a team design/code review.
Do it in small increments. We did the following-

Sprint#1: Review variable/method/class/file/folder names only.
Sprint#2: #1 + Review if/else blocks, loops.
Sprint#3: #2 + Review class responsibilities.
Sprint#4: #3 + Review test codes only.

The result is really worth

This first level feedback will help you to eliminate a lot of bugs, help in knowledge transfer and collective learning. Roughly, It takes only 10-15 minutes to review a code written in 3 days. I suggest, keep it simple.

One interesting thing is, many times I have found the developer him/herself actually found bugs/mistakes in the code before the reviewer at the time or reviewing.

A reviewer's eye will save lot of your time and money.

Update: Be constructive in your feedback! Example:-

Worst: This code is a piece of ...

Worse: This code is bad

Bad: This code is not good

Good: A better way is..

Better: We can also do it this way...

Best ?

Juggernaut on Linux

2009-03-22T23:03:00.001-07:00

I just installed Juggernaut on my linux box. The installation is simpler than windows. At least it gave me less pain.

Just run the following commands-

gem install json
gem install activemachine
gem install juggernaut
juggernaut –g juggernaut.yml
juggernaut –c juggernaut.yml

I got a little pain regarding the g++ compiler that is required to build the activemachine. I did not have it installed in my Amazon EC2 instance and after some searches, I could install it using the following-

apt-get install g++

IMPORTANT!!

Well, it was fine if I could end here! However, I found that this installation stopped my MySQL service and changed the /etc/mysql/my.cnf file. So, an attempt to start the MySQL was successful only after I removed the # comment from the line log_bin = blah blah blah…

So, if you are using Redhat Enterprise 5.0, you may find it useful. If you are using Amazon EC2, you will find it useful too. I do not know about other distros, but may be something similar will be there (at least hopefully)!

Comet and Server Push (Reverse Ajax) technology

2009-03-22T03:34:00.001-07:00

I am re-implementing an ajax based chat system. Presently an ajax request is polled continuously to look for any updates/messages from the user’s browser. However, the plan is to use the server to push the messages to the clients to off-load the server from a huge number of useless ajax calls.

I learned about Comet and found it interesting. You may read about comet here at WIKI.

Juggernaut is a rails plug-in that uses Flash to implement the server push technology. It is simple and it produces RJS script for the client. So, it can be used many other scenarios where a live update is required. of course, chat system is a good place for this.

The installation required a few tweaks as follows:-

1. Installed json_pure gem instead of json. (gem install json_pure)
2. Installed EventMachine gem (gem install eventmachine)
3. Installed juggernaut gem (gem install juggernaut –-ignore-dependencies)
4. Modified the C:\ruby\lib\ruby\gems\1.8\specifications\juggernaut-0.5.7.gemspec in places to the following

s.add_runtime_dependency(%q<json_pure>, [">= 1.1.1"])
s.add_development_dependency(%q<hoe>, [">= 1.3.1"])

s.add_dependency(%q<json_pure>, [">= 1.1.1"])
s.add_dependency(%q<hoe>, [">= 1.3.1"])

since, you do not find the required versions of all the gems, you need to change this checks to get a way.

Then, this readme helped me to get started.

Will follow up this post as I work more on this. Have a good day!

The RANK() Function for Numbering on Groups/Partitions in SQL Server

2009-03-06T10:40:00.001-08:00

Previously, I used the ROW_NUMBER() function to get the monotonically increasing row number of a result set from a SQL query. But, this time the requirement was a bit different as follows.

I have many combinations of Year, Make, Model and Trim of vehicles in my database. I also have potential profit on sale of each of the combinations. I need to produce, the top 5 trims for a Year, Make, Model combination that yields maximum profits.

So, to solve this problem, I cannot simply use ROW_NUMBER(). Basically, I need to find the row numbers starting from 1 for each group of Year, Make and Model. Then, take only those rows having a rank <= 5. Ranking based on such groups/partitions can be easily done by using the RANK() function. I am quoting the syntax from MSDN here-

RANK ( )    OVER ( [ < partition_by_clause > ] < order_by_clause > )

So, in my case the query is something like the following-

RANK ( ) OVER ( PARTITION BY Year, MAKE, MODEL ORDER BY Profit DESC, Trim )

So, the RANK() is similar to ROW_NUMBER() in the context of the PARTITION. As if, the RANK() restarts counting from 1 for each partition. I think, like me, many of you may find it new and useful in similar requirements.

Without using this function, it will be much difficult to produce the desired result set. However, if you have a nicer/alternative solution, please teach me!

Working on a Data Warehouse project

2009-02-22T21:58:00.001-08:00

I have been busy for the last month as we, at Code71, rolled out the first release of the Business Intelligence project for Vuneu Media. I will give you a brief on my project here so that you can follow my coming posts.

The used vehicle dealers buy their vehicles from different Auctions across the country. When making a buy decision, they try to find answer to these questions-

What vehicles are customers buying?
How much it costs to get those from Auctions?
How many of these are receiving cash advances and by which lenders?
What is my potential gross profit if I deal a vehicle?
Where can I find the vehicles in Auctions?

So, we are getting the information from data vendors. Since, the amount of data is really large (nearly 10 million rows per month in total) for human manipulation, we are adding real value to the business by providing software intelligence. We developed the technology to put the pieces together and make it handy for the dealers.

We are using the following software/technologies:-

SQL Server 2008, 64 Bit, Standard Edition.
SQL Server Integration Service.
SQL Server Reporting Service.
ASP.Net, C#, WCF.
SQL Server Analysis Service (is in the pipeline, not used yet!)
Windows Server 2008, 64 Bit.

I came across a number of innovations as well as issues at each step of the project. The database schema design was itself a challenge since data come from different vendors in various formats and granularities.

Here, I will start with an issue resulting from the “64 bit” SQL Server limitations-

SQL Server 64 bit versions include Integration Services, but it lacks support for some components. One such is, Microsoft Jet Driver. We use this driver to load data from Excel files.

To load Excel data using SSIS, you have the following options:-

1. Locate Program Files (x86)\Microsoft SQL Server\90\DTS\Binn\DTExec.exe. Then use this with your options. You can take a look at the command arguments by invoking DTExec –? This way you can run the SSIS packages using command line.

2. Using the SQL Server Agent Job is rather simple. Just Create/edit your job step having the Excel, then select Use 32 Bit in the Options/Execution Options tab. It will automatically use the 32 bit version of DTExec.

3. If you are using the IDE, you can turn of 64 bit by un-checking the Use 64 Bit Runtime at the Project Properties > Debugging.

More information on 64 bit SQL Server related issues are here at MSDN.

Also, I got help from Blog N-Technologies.

A good example of C# Regular Expression: Implementing InitCap or Titleize/TitleCase using C# and Regular Expression

2009-01-21T08:25:00.001-08:00

Ever since I first learned about the regular expressions, I have always been fascinated by its magical capability. When I first learned about DFA/NFA, I figured out how it is possible to evaluate a regular expression and eventually, during my Undergrad at BUET, I implemented a regular expression evaluator for the Compiler Lab.

Now, given this history, here is a simple code that I wrote today. Let me know if you liked it-

        Program()
        {
            Console.WriteLine(Titleize("hello! This is a sample string for titleize!"));
            Console.Read();
        }
 
        public string Titleize(string input)
        {
            return Regex.Replace(input.ToLower(), @"(?<space>\s*)(?<first>.)(?<rest>\S*)", new MatchEvaluator(OnMatch));
        }
 
        public string OnMatch(Match match)
        {
            return string.Format("{0}{1}{2}", match.Groups["space"].Value, match.Groups["first"].Value.ToUpper(), match.Groups["rest"].Value);
        }

For a little explanation, the pattern @"(?<space>\s*)(?<first>.)(?<rest>\S*)" matches to a series of space followed by a word. The word is further divided into two parts, the first one is just the first character and the rest understandably captures the "rest" part of the word.

Next the OnMatch method takes each occurrence of a match of the above pattern and as shown, simply regroups the word as previous but just takes the Upper case of the first letter!

Simple? You got another good example of Regular Expression? Share with me.

Solution to JavaScript File Include Problem From ASP.Net MasterPage

2008-12-23T22:12:00.001-08:00

You can include javascript files using a simple script tag. However, you will soon discover that, when you are using this master page from content pages that are at different levels in folder hierarchy then the script files will be missing at some cases. This is due to the fact that, script file paths are referenced relative to the content page and NOT to the master page. As a result, despite having the correct include wrt the master page, your content pages may still miss the scripts!

The solution is simple. Add this following line (of course, replacing the sample values with your own ones) to your master page's page load method to add the script tag through code instead of through markup.

   this.Page.ClientScript.RegisterClientScriptInclude("YourKey", ResolveUrl("~/Scripts/myscript.js");
 
Hope it saves you from the pain of adding a common js file into each of your content pages.

Asp.Net Membership: How to change a user's password from an admin account without knowing the current password?

2008-12-23T21:56:00.001-08:00

Like mine, you may also need to change a user's password from an admin account. By default, when you are using ASP.Net authentication and storing the password in the hashed format, you will not be able to see the existing password in its decrypted form. Also, to change a password using the Membership API, you will need to know the existing password. However, here is a simple solution to the problem -

The idea is, you can reset the password of a user using the following code-

   string tempPass = Membership.Provider.ResetPassword("username", string.Empty)

Make sure you have the config that allows you to change password without an answer to the security question. Now, you can invoke the ChangePassword method using this tempPass as the existing pass and your custom password as the new password. Refer to the following line for a compact implementation-

   Membership.Provider.ChangePassword("username", Membership.Provider.ResetPassword("username", string.Empty), "custompass")

I believe this will save your time with a similar need.

Part 1: How am I IMPACTing following Scrum?

2008-11-26T20:42:00.001-08:00

In a previous post in this blog, I introduced the nice little acronym IMPACT for agile. To recap, here is what IMPACT stands for -

"Iterative and Incremental development of a software by means of Merciless refactoring, Peer reviews, Automated acceptance testing, Continuous integration and of course, Test driven development"

To give you a little background around my story, let me tell you about a project that I am working since June 2006. The project is a micro-finance loan application automation server for the US financial industry. It acts as a mediator between a loan seeking customer and one of over 50 lenders in an attempt to get a loan for the customer. So, the server adds value by taking a single application to 50 odd lenders from a single submission unless no lender is left untried or some lender says 'yes' to it. This is done in real time, the processing time in average is less than 3 minutes.

Now that you have the background, let me introduce the the challenges associated with this project. The bullet points are-

Since this involves real dollars, there is nearly no margin for an error.
It processes more than a thousand loan applications per hour, so a high availability is a must.
This is done following agile Scrum and each two week one/two new lending partners need to be integrated.
The lending partners change their integration API from time to time and we need to accommodate the changes ASAP.

To address these challenges this is how we are responding-

Iterative and Incremental development (IID)

We are following Scrum and using ScrumPad to manage the IID. Basically, our clients/product owners put new requirements in terms of user stories in the product backlog at ScrumPad. So, with the prioritized product backlog we, the team, pick items to a sprint's backlog. Then as usual, we break it down to tasks and do everything that it takes to meet the deadline of two weeks. Within a sprint the following are the milestones-

Day 1	Day 2	Day 3	Day 4	Day 5	Day 6	Day 7	Day 8	Day 9	Day 10
Sprint Planning	Dev & Test	Dev & Test	Dev & Test	Dev & Test	Dev & Test	Dev & Test	Dev & Test	Test Release	Production Release

8th day - Sprint works are completed.
9th day - Test delivery at a near production environment and feedback gathering from product owner.
10th day - Incorporate feedbacks and release in production.

Note that, we generally produce a number of test releases within the first 8 days. That gives us an earlier chance to gather client feedbacks.

The beauty if this approach is, with this model in place we can release as early as in 8 working days, if not earlier. So, this helps us meeting the last two challenges as mentioned above.

Merciless refactoring

Developing incrementally offers much challenge in attaining the longevity of the product. Because, naturally as new features come in, we need to make room for that in the existing implementation.To ensure the quality and life of the product, we do merciless refactoring as we go. We have over 90% unit test coverage, which helps us in doing this continuous refactoring. So, the idea is-

Writing unit test and acceptance test.
Refactoring our code/design and validating against automated tests.

Peer reviews

This is probably the most important practice that I recommend. Because, as we had new members in the team, we found that the quality was somewhat degrading. Once, we started peer reviews, it was very helpful to the new comers as well as the veterans to keep the code quality up to the mark. We review the following things-

Naming of variables, methods, classes, files, namespaces etc.
Use of private methods for increased readability.
Hard coded string literals or constants.
Long/nested loops and long running if-else blocks.
Code commenting.
Quality of coding.

I would suggest you to try Microsoft's Stylecop, it will give you a great head start to ensure the first level code quality by enforcing the common rules. This practice is allowing us to continue the good quality over time.

I have always been shy of reading extra large text in the web. So, I thought I could better post this in two parts! I assure, next post will contain more images than texts, So, you better stay tuned for the next one...

Delving into client side capabilities of ASP.Net Ajax

2008-11-18T20:43:00.001-08:00

I believe the client side scripting capabilities of ASP.Net Ajax is not utilized by many ASP.Net developers. This is most probably due to the fact that, not many people are aware of it at the first place. Also, since most of the javascripts are rendered secretly (read, not blatantly, which is good), most developers don't even feel the existence of the underlying javascript at all.

Two very simple examples of the client side library are given here as examples -

1. Did you know, if you have the following javascript method, it will be automatically called when your page's DOM is finished loading?

function pageLoad(sender, args) {
}

2. Do you know the following javascript code will add an event handler to catch whenever an asynchronous post back is completed?

Sys.WebForms.PageRequestManager.instance.add_endRequest(endRequestHandler)

These are just very little glimpses of the big scenario. To uncover more, visit the official MSDN documentation at http://msdn.microsoft.com/en-au/library/bb398822.aspx

If you are new to this, I assure, you will have a much better knowledge about ASP.Net Ajax scripting than ever before and can produce better quality javascript for your ASP.Net websites.

Happy digging!

IMPACTing for agile software development

2008-11-18T01:40:00.001-08:00

Well, next time on a dev job interview when someone asks you the question, "Can you give us a brief idea on agile software development engineering practices?", you are probably gonna laugh on your mind and just answer, "IMPACT!". Yes, this is it, compact and right on target!

Today, I came up with this acronym about agile engineering practices and I think its a nice one :-)

IMPACT can be elaborated as follows-

I	for	Iterative and Incremental Development
M	for	Merciless Continuous Refactoring
P	for	Peer Code Reviews
A	for	Automated Acceptance Tests
C	for	Continuous Integration
T	for	Test Driven Development

For all you agile folks out there, I hope this IMPACT makes sense to you! I have found many people to take agile as a panacea and start getting skeptical as soon as they feel the heat in real life. Well, we all know, there is no free lunch! So, lets get our feet on track and do the first things first.

What are the first things? The answer is, IMPACT, if you really want to create a positive impact out of agile methods.

Comments are welcome!

RowTest Extension for NUnit

2008-11-10T00:58:00.001-08:00

Well, I was just about to implement it myself! However, its good to see that the NUnit addin named RowTest actually allows us to do the data driven unit test through declarative programming and adding parameters to the dumb test methods!

http://www.andreas-schlapsi.com/projects/rowtest-extension-for-nunit/

Check out this website for an example and get started with RowTest.

Iterative and Incremental implementation of Code Reviews

2008-11-03T01:04:00.001-08:00

Extreme Programming (XP) advocates for a pair-programming, taking the code review to its extreme. I have also found that pair programming generates a lot of speed and also helps producing better quality product in the first time. But, at the same time it's difficult to impress the management or prove return on investment associated with pair programming to the business people. So, what is the best possible solution? I believe, we can implement frequent peer code reviews to mimic the pair programming to some extent and get the benefit out of it.

In our team, we started implementing code reviews as we now recognize that there is no way to live without it. As usual, our approach is an iterative and incremental approach. So, we are taking small steps and eventually embracing the best practices in the team. I would like to share our plan here in this blog. The review process goes on the following work flow-

"When I am done with my work on task, I commit the code with the reviewer's name on the svn comment. CCNet automatically builds and sends a mail to the reviewer. The reviewer gets the review email through a filter and reviews the code and sends his feedback to me via IM/email."

Sprint #1: Review all the names or classes, files, methods, variables and so on. So, the reviewer emphasizes on the names and provides feedback on the following things-

1. Is the naming standard correctly followed?

2. Is this a meaningful identifier?

3. Does the name conform to the conventions used elsewhere in the code?

Sprint#2: Review the use of private methods and code structure. The to-do list is -

1. Would it make more sense to put some code into the private method for readability and/or reusability?

2. Is there any hard-coded constant directly used without referring to a const/readonly data type?

3. For all the methods, is it possible to reduce the dependency by using a simple parameter instead of a whole object?

4. Learn from sprint#1 and use the common learning.

Sprint#3: Review the use of loops, if-else blocks. At this iteration, the to-do is-

1. Is it possible to eliminate a loop?

2. Is it possible to avoid the nested loops?

3. Is there a large if-else-if-else block? Why is it required? Is this large conditional block a possible candidate for future change?

4. Learn from sprint#2 and use the common learning.

Well, this is pretty much it. The idea is, we feel its not practical to go with an overnight policy for implementing peer code reviews. But, its very much possible that we do it in small increments and at each sprint's retrospective we bring this point. So, we are all informed that we need to do reviews, which, eventually should sustain as a best practice!

If you think you have some ideas regarding this, please share it with me/my readers.

CruiseControl.Net (CCNet) configuration example for NCover

2008-09-06T20:50:00.001-07:00

CruiseControl.Net is a great continuous integration tool for .Net projects. It not only continuously builds your software but provides some really helpful reports to monitor your project's progress.

In agile world, we all speak of self-testing code or test driven development (TDD). If we really want to ensure our code has enough test coverage, we need to use some tool to ease our lives and NCover is a good one for this purpose. To learn more about NCover, please visit this.

When integrating to CCNet, you can use a similar configuration in ccnet.config as shown below to show NCover reports for your project-

\par ?? <\cf3 msbuild\cf1 >\par ?? <\cf3 executable\cf1 >\cf0 C:\\WINDOWS\\Microsoft.NET\\Framework\\v3.5\\MSBuild.exe\cf1 \par ?? <\cf3 projectFile\cf1 >\cf0 CISample.sln\cf1 \par ?? <\cf3 buildArgs\cf1 >\cf0 /p:Configuration=Debug\cf1 \par ?? <\cf3 targets\cf1 >\cf0 Rebuild\cf1 \par ?? <\cf3 timeout\cf1 >\cf0 300\cf1 \par ?? <\cf3 logger\cf1 >\cf0 C:\\Program Files\\CruiseControl.NET\\server\\ThoughtWorks.CruiseControl.MsBuild.dll\cf1 \par ?? \par ??\par ?? \par ?? <\cf3 nunit\cf1 >\par ?? <\cf3 path\cf1 >\cf0 C:\\Program Files\\NUnit 2.4.1\\bin\\nunit-console.exe\cf1 \par ?? <\cf3 assemblies\cf1 >\par ?? <\cf3 assembly\cf1 >\cf0 CISample\\bin\\Debug\\CISample.dll\cf1 \par ?? \par ?? \par ??\par ?? \par ?? <\cf3 exec\cf1 >\par ?? <\cf3 executable\cf1 >\cf0 ncover.console.exe\cf1 \par ?? <\cf3 baseDirectory\cf1 >\cf0 CISample\\bin\\Debug\\\cf1 \par ?? <\cf3 buildArgs\cf1 >\cf0 nunit-console CISample.dll //xml coverage.xml //ea NUnit.Framework.TestFixtureAttribute\cf1 \par ?? \par ??\par ?? \par ?? <\cf3 exec\cf1 >\par ?? <\cf3 executable\cf1 >\cf0 NCoverExplorer.Console.exe\cf1 \par ?? <\cf3 baseDirectory\cf1 >\cf0 CISample\\bin\\Debug\\\cf1 \par ?? <\cf3 buildArgs\cf1 >\cf0 coverage.xml /xml /r:ModuleMethodFunctionSummary\cf1 \par ?? \par ??\par ?? } -->

<tasks>
   <!-- Task for MSBuild -->
   <msbuild>
     <executable>C:\WINDOWS\Microsoft.NET\Framework\v3.5\MSBuild.exe</executable>
     <projectFile>CISample.sln</projectFile>
     <buildArgs>/p:Configuration=Debug</buildArgs>
     <targets>Rebuild</targets>
     <timeout>300</timeout>
     <logger>C:\Program Files\CruiseControl.NET\server\ThoughtWorks.CruiseControl.MsBuild.dll</logger>
   </msbuild>

   <!-- Task for NUnit -->
   <nunit>
     <path>C:\Program Files\NUnit 2.4.1\bin\nunit-console.exe</path>
     <assemblies>
       <assembly>CISample\bin\Debug\CISample.dll</assembly>
     </assemblies>
   </nunit>

   <!-- Task for NCover -->
   <exec>
     <executable>ncover.console.exe</executable>
     <baseDirectory>CISample\bin\Debug\</baseDirectory>
     <buildArgs>nunit-console CISample.dll //xml coverage.xml //ea NUnit.Framework.TestFixtureAttribute</buildArgs>
   </exec>

   <!-- Task for NCoverExplorer -->
   <exec>
     <executable>NCoverExplorer.Console.exe</executable>
     <baseDirectory>CISample\bin\Debug\</baseDirectory>
     <buildArgs>coverage.xml /xml /r:ModuleMethodFunctionSummary</buildArgs>
   </exec>

 </tasks>

You see that there are two NCover related <exec> nodes. The first one generates the coverage.xml. Then using this first one you can create actual report to present specifying the desired level of details of the report.

Set and Compile using C# Language Version 2.0 in Visual Studio 2008

2008-09-01T22:04:00.001-07:00

I know, while most of you are very happy with the new features in Visual Studio 2008, its sad that not all your deployment environments are upgraded to .Net framework 3.5. I had a similar situation as well on one of my projects.

Its great that you can just navigate to a VS 2008 project file properties and from the Application Tab select the Target .Net Framework version to use one of .Net 2.0, 3.0 and 3.5. But this doesn't solve all the problems. You will soon discover that, your application doesn't show an error when you write C# 3.0 code with the target framework set to 2.0. This is because, the IDE by default uses the latest language version by default.

To solve this problem, Navigate to project properties > Build > Advanced > Language Version and choose ISO-2 (or ISO-1). Now with this information, the VS 2008 will start showing compiler errors for features that don't comply to the version specification!