Ruby In Air

First iPhone commercials

noreply@blogger.com (Anand) — Mon, 27 Feb 2012 10:22:00 +0000

All These Years

Amazing

Rendering HTML in Rails for Dummies!

noreply@blogger.com (Anand) — Thu, 02 Feb 2012 20:18:00 +0000

Views can be rendered in 4 simple ways from an action method.

1. Render the action's own template, named after the action's name itself. This is the default.

2. Render some other action's template from an action method, inside the same controller.

3. Render an action's template which is present in some other controller, other than the one we are calling from.

4. Render any damn template file.

To learn more details on rendering views, see Rails guides.

Difference between Proc and Lambda

noreply@blogger.com (Anand) — Sun, 14 Aug 2011 05:57:00 +0000

Proc and Lambda are used to create code blocks. After creating them, we can pass them around our code, just like variables.

But there are 2 significant differences we have to keep in mind.

1. Suppose a Proc or a lambda is used to create a code block inside of a method. If the Proc/Lambda has a return statement inside of its code, in the case of Proc, the whole method is returned. But in the case of Lambda, its not. The execution continues to any further statements inside the method. Here is the code fragment that explains this difference.

2. A Proc will not check if the arguments are passed to it are of the same number as its parameters. A Lambda will throw an error if we violate the number of parmeters.

You see, Proc is very naughty :) It won't check for the number of arguments and it will return without the permission of the method in which it resides!

RVM, RubyGems and Bundler - How gems are installed ?

noreply@blogger.com (Anand) — Sat, 18 Jun 2011 14:08:00 +0000

Earlier when I started programming using ruby (system ruby), it was all clean. I used to install gems with sudo gem install somegem . Then came rvm and it asked me to install gems without sudo like: gem install somegem. Then came bundler, which asked me to install gems by bundle install.

Since then, I was confused about how things work using these 2 tools on top of ruby. Well, I decided to put an end to that confusion and here is how they work.

When you use

rubygems would install that gem in the place defined by $GEM_HOME environment variable. Now this is the variable that dominates where rvm puts gems in and where bundler puts gems in.

I suppose you are using rvm to manage multiple rubies. When you switch rubies using rvm, the $GEM_HOME variable changes. rvm changes it.

When we use bundler install to manage dependencies, bundler simply call gem install under hood for each of the gems defined in Gemfile. Lets see this in terminal.

First create a new rails project, it comes with a Gemfile.

Lets then create a new gemset for this project and use it

Install bundler and check $GEM_HOME location for any gems installed.

Do a bundle install in this project and check $GEM_HOME again.

'class << ' merely changes the self

noreply@blogger.com (Anand) — Fri, 15 Apr 2011 16:57:00 +0000

Many ruby programmers use class << self inside some class definition to create class methods. But the actual meaning behind this class << self is completely different. Using it for creating class methods is just one usecase.

class << soomeobject, actually changes 'self' object inside a definition block. In ruby, in any place there is something called as current object or 'self'. If you are calling a method and if you don't specify a receiver or object on which the method has to be called (like someobject.methodname() ), the method will be called on 'self' or current object inside that scope.

Inside Instance methods, self is "the object instantiated from the corresponding class".
Inside class methods and class definitions, self is the "the class object".
Inside Module methods, self is either the "instance of the class that includes it" or "object that extends itself with the module".
Inside Module definition, outside of module methods, self is "the module object".

So like this, in every scope, self changes itself. If you want to enforce self to be a particular object in particular place in your program, you use class << self. Here are some self-explanatory code snippets that demonstrates this.

And now comes more familiar way of using class << self.

And there is nothing called as class methods. Classes are pure ruby objects. Going by that logic, class methods are nothing but instance methods of singleton class of an object(saying it differently, singleton methods)

Object Dynamism in Ruby

noreply@blogger.com (Anand) — Thu, 14 Apr 2011 04:13:00 +0000

When an object in Ruby is created, it has methods and instance variables that are initially defined in its class. But that doesn't stop that object from getting new capabilities. They get more powers later by their singleton classes or when their parent class gets new methods. Let me tell you about the first way.

Every object have its own class (apart from the class from which it was instantiated). That class is called as singleton class (or some would call it ghost class, eigen class, uniclass, etc.,). Singleton classes are unique to an object. And ruby will look for methods in that class before it looks into a class, when a method is called on that object. Here is code snippet that demonstrates singleton class.

The shout_hello method was added only to john's singleton class.

Here is a second way in which the original class gets more methods after the object is created. You see the class gets more methods and ruby will find and invoke them. Unlike other languages, classes are not like "strict" rules boxes of what can go into an object. In ruby, they are just scopes and they get opened and closed to give more powers to their objects.

Here is the code snippet from Rails source code where the super duper class in Ruby, "Object" gets opened for more methods to be added. http://bit.ly/gC7qSr

There is one more thing. A third way to add more capabilities/methods to an object in ruby. That is by modules. We are going to create a module, extend the object's singleton class with that module.

Cool huh !?

super is a keyword, not a method call!

noreply@blogger.com (Anand) — Sun, 10 Apr 2011 07:09:00 +0000

Methods can be overridden in subclasses of ruby. It is just a process of rewriting method definition, as it make sense in the current class/object.

Calling super .. oops, sorry - writing super anywhere in the over-ridden method will cause the method lookup to continue and the execute the first method found by the name. (If you want to learn about method lookup, here is a good writeup by Gregory Brown. Here are some examples of how super can be used.

Note the lines where super is written. super by default forwards all arguments to the previous method definition, unless and until you write parenthesis after it. super is not a method call though, it is just a keyword in ruby and should not be imagined as calling super(), as in other languages.

Ruby Classes are Objects too!

noreply@blogger.com (Anand) — Sat, 09 Apr 2011 17:21:00 +0000

To demonstrate this awesomeness, here are three ways to create your ruby classes.

And the second way,

and one step further with blocks,

All Ruby classes are instances of class "Class". Cool huh ?

Help yourself out

noreply@blogger.com (Anand) — Sat, 05 Mar 2011 03:11:00 +0000

If a new web framework comes out, we expect a book and good blog post to be written, for us to start learning about it. If we get stuck in a problem, we expect Stackoverflow and other forums to help us out. At least, I've seen this in some people (and me). There is this, sort of permanent dependency on other things, to help us out of doubts or difficult situations in progamming. What've learnt from my seniors and some of my web friends, is that, the more we become independent in solving our problems, the more skill we have.

Vim
While working with vim, we get stuck sometimes in doing repetitive tasks. We then actually browse web/google it to get the solution from a blog post or something. What we have to realize is that Vim comes with pretty extensive help system on its own. Many (at least I) didn't know how to use it well. :h can solve any problem you might have in Vim. Vim help system is the only way you can help yourself when you face problems in Vim. No blog post or no video can help you. But, to get started in Vim help system, this video is really useful.

Git
I wonder how many people using Git know about git ls-tree command. Not many of us go and reading commands more than the necessary ones (pull, push, add, commit). Again, when we get stuck, what I've realized is that knowing "Git internals" will really help us in any situation we might be in, while using git. This book is "The" book on Git Internals. Must read.

Rails
Well, for helping ourselves on Rails, knowledge about core ruby is really really essential. Instead of reading the documentation, if we read the corresponding code in Rails, it will really help on long term. Daily, on an average, 5-6 commits go into rails repository. Reading new code in the repository, will keep everyone updated. This book is the best on fundamentals of Ruby.

To sum it up, "knowing ruby", "using vim help system", "knowing Git internals" can solve problems (that are out of your actual business/application) easily. This is what I learnt from many guys whom I admire for their coding smartness.

GoShortener with API Keys

noreply@blogger.com (Anand) — Mon, 21 Feb 2011 18:50:00 +0000

Google servers are quite shy in answering api calls from strangers. So they have an upper bound on how many api calls you can make on their servers to shorten your long urls. Thus they recommend developers to register and use api keys. GoShortener gem didn't provide facility to include api keys before.

Now starting with v1.2, GoShortener can be used with/without google api keys.

Here is an example usage sessions in irb.

Test for Positive cases first

noreply@blogger.com (Anand) — Sun, 20 Feb 2011 03:15:00 +0000

TDD is a religion in Ruby and Ruby on rails community. In any project, you will have to write test cases in any form. But the depth to which testing is done varies between any two programmers. Some programmers concentrate on testing each and every dimension of the feature they are implementing. Some programmers just write small amount of tests, to concentrate on the core use case of a feature. But I would say that we have to find a sweet spot between these two levels. Neither too extreme Nor too less.

For example, if you are writing a Sign Up form page. You obviously would've set strong validations so that mal-users cannot enter invalid data into our forms.

Too Extreme testing:

In the extreme case, a developer might test the form, with his test cases, for every possible type of input and see if we throw an error to the user. So if the form may get, say 2 sets of valid data getting entered and say, 20 sets of invalid data possibilities, the programmer might write 22 test examples to check whether we catch them all and treat them appropriately.

To less testing:

The programmer might pick up just the positive cases that can be entered in the form, and then write test cases on it to check whether we handle them appropriately in our application.

Optimism:

Its always better to choose optimistic number of cases to test against. In the above case, I would pick up all the valid data sets and some frequently occurring invalid data sets and then write the test cases to test whether we handle them properly.

In my view, all we have to care about is to handle our good users really well, i.e, we have to make sure that we deliver what we promise in our application. Handling inappropriate data sets is a different subject, but our test cases should live as a living agreement to make sure that we do the right things really well.

GoShortener: gem to use goo.gl service

noreply@blogger.com (Anand) — Sat, 05 Feb 2011 07:21:00 +0000

Recently, Google released its api for its URL shortener service. I might use this service in future, so I've created a small ruby wrapper/gem "goshortener".

You can use Google's json api directly without any ruby wrapper like goshortener. But doing that involves, requesting google servers and handling & parsing the json responses, etc.,

goshortener eliminates these problems. This gem currently exposes two methods, #shorten and #lengthen, with their names clearly expressing what they do. Installation and usage instructions can be found in its github project page

Google api for this service is currently in version 1. There might be lots of improvements to this service in the future. I hope I will maintain this goshortener gem to match all the capabilities google might give via its api.

goshortener is hosted in rubygems.org and the source code is hosted in github. If you find any issues with the gem, please log them here.

jQuery Live in Prototype

noreply@blogger.com (Anand) — Tue, 01 Feb 2011 22:06:00 +0000

I am not sure whether there are any prototype plugins for doing this, but I know for sure that , at the time of this blog post, jQuery "live" method has not been implemented in Prototype. One more reason to like JQuery !

But, what if you are trapped in a project where Prototype is used and you've got to do things in prototype ways. Well, its just after all javascript. Not a problem. There are a few places where Prototype is not as comfortable as JQuery.

"live" method is one such instance. For example, in your page, if you are expecting a new element via ajax calls, which was not present during initial page load - you can hook an event handler to it using jQuery. i.e, you are hooking an handler for some element that was not even present when your script ran. thats the power of "live" method.

Since Prototype lacks a direct call like "live", people have found several ways to do it. One popular way is event delegation using parents. Let me explain it in simple words.

In this technique, we don't actually listen to the "expected new" element. we instead listen to one of its parents that already existed during initial page load. Then inside the parent's event handler, we check whether the "expected new element" was actually where the event occurred. Prototype's "Event.findElement()" method is used for it. Then, if that is true, we can do whatever we want on that event.

Simply saying, we listen to the parent. And the parent element tells us whether a new element exists and whether the event happened on that new element.

And for a specific example, here is one.

Here, we are listening to "a" tag that was loaded dynamically via ajax inside the parent "content" element. "cotent" could be a div for instance. This has been working well for me. So I pretty much use this technique whenever I need such functionality using Prototype. I hope it helps somebody.

I never miss Ryan's words

noreply@blogger.com (Anand) — Sun, 23 Jan 2011 14:31:00 +0000

Apple will survive Steve Job's absence

noreply@blogger.com (Anand) — Wed, 19 Jan 2011 16:07:00 +0000

Apple will survive Steve Job's absence if there would be any such thing. Even if he retires, Apple will grow. I read an article on this thing. And they have raised same stupid questions they raised in 2009. Its completely ridiculous. Let me tell you why.

Apple has taught us many lessons. Engineers and Entrepreneurs are learning a lot from Steve job's view on products. And from those lessons, the companies around the globe are becoming successful. Steve jobs and Apple together have influenced other companies not only with its products but also with the way it operates.

Many CEOs and Startup companies will definitely agree to this. If "other" companies can be successful with the lessons learn't from Apple, Why not "Apple" can't be as successful as it is now ?

1. Apple's market value is $321 billion dollars. They have huge cash.
2. Apple have produced several good products. So they know what would work and what wouldn't.
3. Apple have awesome engineers. They have been with Steve Jobs. And they know how to make good, beautiful and useful products in the coming days.
4. Apple have a very very strong and sincere community.
5. Apple have "the" huge platforms to capitalize - iTunes Market, iPhone market and Mac app market.
6. Apple has a very strong product line. Mac family, Macbook family, iPod, iPhone, iPad. These are enough to sail them through any disaster.

So, Stop thinking about Apple's demise !

Produce Documentation from your RSpec test cases

noreply@blogger.com (Anand) — Thu, 06 Jan 2011 16:28:00 +0000

Well, if you are not in the habit of writing test cases, this post is not for you. So if you are in the other jungle, writing test cases for your app, this post hopefully will show you something cool about rspec.

Ruby community generally believes a lot in test cases. Why? well, there are many reasons. One primary thing is that test cases document your code. what does that mean ... ? let me show you.

If you have rspec test cases written in your ruby app ( a rails project for example) , in PROJECT_ROOT/spec/, here is a way in which you can get the documentation of your app.

Give this command to get a neat output of rspec test cases

If you want the same in a text file, probably to print it out at later stage, you can give like

You can open that txt file to see your App's documentation. There are a lot of nice command line options that rspec provides you. Tweak them to your interests.

How to install RVM on MacOS X Snow Leopard

noreply@blogger.com (Anand) — Thu, 30 Dec 2010 19:20:00 +0000

Managing multiple versions of rubies and ruby gems is a very difficult task. One of your projects might be using Ruby 1.9.2, while your other old project might be using Ruby 1.8.7. Adding to this complexity, each of your project might be using different versions of a same ruby gem. (For example rails 3.0.1, rails 2.3.8, rails 2.3.5).

RVM was created to solve this problem. RVM is surprisingly easy to use with its simple set of commands. I will explain how to use it in the next blog post. Here, I will explain how to install it.

Before installing rvm, make sure that you have installed XCode developer tools in your mac. Apple distributes the XCode developer tools in CD with every Mac. You can even download it from Apple developer site for free.

To Install RVM

1. Open your terminal, copy and paste the following command in it. Then press enter.

bash < <( curl http://rvm.beginrescueend.com/releases/rvm-install-head )

2. Then, go to your home directory

3. Edit your .profile file using your favorite editor.

nano ~/.profile

4. Copy and paste the below line at the end of .profile file

[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # This loads RVM into a shell session.

5. Save it and exit the file. (This step varies for different editors. For nano it is Ctrl-o and then Ctrl-x )

6. Run the following command to reload your shell settings.

source ~/.profile

7. Confirm whether rvm was installed properly in your system by typing the following command in terminal.

type rvm | head -1

You should see the following output.

rvm is a function

Your rvm is installed now.

Installing Rubies:

Ruby-1.8.7-p174 (Ruby 1.8.7 patch level 174) is installed by default in MacOSX. This is called system ruby. If you want to check its version in your mac, you can type this command and see for yourself.

ruby -v

Now, lets install ruby 1.8.7 and ruby 1.9.2 using RVM.

1. To install ruby 1.8.7, type this command in your terminal.

rvm install 1.8.7

Now, rvm will download ruby v1.8.7 source code, compile and install it automatically. This process will take some time depending on your system and internet speed.

2. Installing ruby 1.9.2 is by the same command.

rvm install 1.9.2

Note: Installing MacRuby, JRuby is similar with a few tweaks. You can refer the documentation for installing them.

After installing, you can check by typing the following command

rvm list

and it will give the following output for me.

rvm rubies

jruby-1.5.3 [ x86_64-java ]
macruby-0.7.1 [ x86_64 ]
=> ruby-1.8.7-p302 [ x86_64 ]
ruby-1.9.2-p0 [ x86_64 ]

The output shows the list of rubies that are installed in my system and the little arrow shows the version I'm using currently i.e ruby-1.8.7-p302 [ x86_64 ] .

Using Rubies:

To start using ruby 1.8.7, you need to give this command in terminal,

rvm use 1.8.7

and to start using 1.9.2, you need to give a similar command

rvm use 1.9.2

To make one ruby version as default, you need to give command like

rvm use 1.9.2 --default

You can always check the version you are using currently by one of the following commands.

rvm list

ruby -v

Please refer the documentation for more advanced use cases.

Perfect VIM Video series

noreply@blogger.com (Anand) — Thu, 30 Dec 2010 13:22:00 +0000

I have seen Vimcasts. I've seen Peepcode. But none matches Derek Wyatt Vim series.

Welcome to Vim from Derek Wyatt on Vimeo.

Simply the best

Track your rails deployments using NewRelic RPM

noreply@blogger.com (Anand) — Mon, 27 Dec 2010 08:23:00 +0000

This is applicable only if you have installed NewRelic as a gem inside your project. I am using Rails3 for my app development and adding the below lines in my deploy file worked for me.

For other details, you can read this article

Rails 3 Upgrade Made easy !

noreply@blogger.com (Anand) — Thu, 16 Sep 2010 18:35:00 +0000

With Rails 3 release, existing rails applications are getting upgraded to Rails 3. Rails has so many advantages compared to older versions and its always better to do the upgrade now if not later.

Rails community has churned out a very good plugin for making this step a painless process. You can get this plugin rails_upgrade here . Just install the plugin and follow the instructions given in its README file.

Here are some of the things which you have to take care of.

Ruby versions:
Make sure you run the compatible versions of ruby ( Ruby 1.8.7 or Ruby 1.9.2). If you are not used to working with rvm (ruby version manager), this is the right time. Use rvm to install multiple versions of ruby and install Rails 3 with either ruby 1.8.7 and ruby 1.9.2 and without disturbing your existent environments.

Plugins:
Care has to be taken in the plugins used in the rails application. This is not a fact to be worried about. Most of the popular plugins are upgraded to work with Rails and some plugins work well in the older versions itself.

Cloud Platforms:
If you application is hosted on a dedicated server, its not a problem. You can install the necessary ruby versions and you can start the upgrade process. But when you are in platforms like Heroku, you've got to take care of the ruby version they support. Heroku (at the time of this writing) supports only Ruby 1.8.7. The support for ruby 1.9.2 is on the way as per their Rails 3 help page

Resources for Upgrade
Ryan Bates has done 2 excellent screencasts on how to upgrade your applications to Rails 3. Here is another excellent post that will be of help. Rails 3 release notes gives useful information on this.