You might have read my previous article – Kotak Mahindra Bank – Epik Fail about my misfortune that my company had to go with Kotak Mahindra Bank for providing Salary accounts. Today I will list out another reason why Kotak Mahindra Bank not only sucks but is the employees worst nightmare when it comes to having a salary account with them.

Apparently at Kotak Mahindra Bank, the salary transactions for employees of a company (at least a small company like ours) are carried out manually (yes, you heard me right, manually!). Now you know what that means, that means that if it is a Bank Holiday, or a weekend, or a World Cup Final, or if your badass luck isn’t already bad enough that their employees are on sick leave, you won’t get salary!!! Yes, that’s right, forget salary for as long as it takes, you will have to call them, go to their bank and ask them time and again before the salary is actually credited, which could easily be at least a week long effort, and they will give you reasons like it was a holiday saaar, their staff was on sick leave saaar, it was the world cup final saaar…

It is 4th April today and no I haven’t received salary, for most of the reasons stated above. It might happen tomorrow, or maybe day after tomorrow, who knows ?

All you can do is pull your hair and curse them on the top of your voice making yourself look like a lunatic. I am not sure how long I can take this shit from them. It is now an undeniable & undisputed fact that Kotak Mahindra Bank is the most ridiculously worthless piece of shit of a bank there ever could possibly be, and worse.

At Kotak Mahindra Bank every day is an April Fool’s Day, for their customers. Sometimes there is money, sometimes there isn’t, keep guessing!

PS: To Kotak Mahindra Bank employees, if you are reading this, don’t even think about commenting on my blog.

Hi,

I have written a series of articles (in several parts) in an attempt to guide beginners to get comfortable with Ruby. This article is my attempt to build a TOC (Table of Contents) for it to act as an index for people to get a brief idea regarding what each article is about and help them get to the sections they are interested in.

• Getting started with Ruby – Part 1 : In this article I begin with an introduction to myself and my motivation behind writing these articles. I give an introduction to Ruby, about how to get started with building your development environment and introduce a few tools that ship along with Ruby which will make your life that much better.
• Getting started with Ruby – Part 2 : In this article I introduce Ruby in slightly more detail and I get started with describing different data types in Ruby. I cover Strings and Numbers in this article.
• Getting started with Ruby – Part 3 : In this article I continue from my previous article describing data types in Ruby and cover Ranges and Arrays.
• Getting started with Ruby – Part 4 : In this article I continue further and cover Hashes, one of the most commonly used data types in Ruby. I also introduce blocks and about using blocks with functions.
• Getting started with Ruby – Part 5 : In this article I move onto describing various looping constructs in Ruby, and also various flow control modifiers in Ruby. After that I introduce Variables, Symbols, Constants, Methods and Global Variables in Ruby.
• Getting started with Ruby – Part 6 : After having covered basics of various constructs in Ruby, I considered it better to take a problem statement and solve it in Ruby to bring most of what we’ve discussed into use. I chose Google Codejam 2009′s qualification round problem – Alien Language

I tried to be clear, precise and specific. My intention was write more code than to waste time in trying to explain and so I’ve used code comments to help people understand what each part of the code is meant to do. I have plans on going further and go onto describing classes & modules, sometime soon, even though I expected more people to read and give their feedback, but owing to a lot of work and hence a lack of time, I haven’t been able to do much justice to the same, but hopefully I will be able to do so very soon. I hope it helps people appreciate Ruby and motivate them to learn and understand it.

There was a requirement at one of our projects here at Artha42 Innovations Private Limited that our Mongo Mapper documents have inherent versioning so as to be able to track the changes being made and also if required revert the changes to a previous state. Since we’re using MongoMapper, I set out to create a simple plugin for the same to add the required functionality.

Initially, from the initial research I did, I found Shapado had an implementation of exactly what I wanted, however when I studied and understood their implementation in detail, I realized that it doesn’t really work that well in most scenarios, especially the ones we were tackling in our project. Shapado’s versionable allows you to define a set of keys for a document, whose changes would trigger creation of new versions. However in our project we needed to track changes at the complete document level, i.e. even for changes in the associations. Also the versions were embedded within the document itself, which implied that the document would grow in size very rapidly, even though our changes in each iteration could be minor, since each version would literally be a snapshot of the complete document itself.

So we made quite a few design changes in the same, externalized the versions, changed the way one would enable versioning since in our case we wouldn’t be keeping track of changes only in specific keys. Even here, we found that there were certain bottlenecks in the case if there were a whole lot of versions, for which we introduced the :limit feature which allows us to define how many of versions would need to be loaded instead of loading all of them at once.

The result of it was mm-versionable.

If you have any comments, suggestions, requests, queries or feedback, please do let us know in the comments section below.

In my old blog, 2 of the popular posts were about calculating MD5, SHA-1, SHA-256, SHA-384, SHA-512 hashes in Java and C#, I am still getting a little traffic from diggs of those posts :). So today I decided to post it again, and since I am now a fan of Ruby, i’ll also added that in.

Java :

public String getHash(String message, String algorithm) {
	try {
		byte[] buffer = message.getBytes();
		MessageDigest md = MessageDigest.getInstance(algorithm);
		md.update(buffer);
		byte[] digest = md.digest();
		String hexValue = null;
		for(int i = 0 ; i < digest.length ; i++) {
			int b = digest[i] & 0xff;
			if (Integer.toHexString(b).length() == 1) hex = hex + "0";
			hex  = hex + Integer.toHexString(b);
		}
		return hex;
	} catch(NoSuchAlgorithmException e) {
		e.printStackTrace();
	}
	return null;
}

C# :

using System;
using System.Text;
using System.Security.Cryptography;

public String getHash(String message, String algo) {
	byte[] sourceBytes = Encoding.Default.GetBytes(message);
	byte[] hashBytes = null;
	Console.WriteLine(algo);
	switch(algo.Trim().ToUpper()) {
		case "MD5":
			hashBytes = MD5CryptoServiceProvider.Create().ComputeHash(sourceBytes);
			break;
		case "SHA1":
			hashBytes = SHA1Managed.Create().ComputeHash(sourceBytes);
			break;
		case "SHA256":
			hashBytes = SHA256Managed.Create().ComputeHash(sourceBytes);
			break;
		case "SHA384":
			hashBytes = SHA384Managed.Create().ComputeHash(sourceBytes);
			break;
		case "SHA512":
			hashBytes = SHA512Managed.Create().ComputeHash(sourceBytes);
			break;
		default:
			break;
	}
	StringBuilder sb = new StringBuilder();
	for(int i = 0 ; hashBytes != null && i < hashBytes.Length ; i++) {
		sb.AppendFormat("{0:x2}", hashBytes[i]);
	}
	return sb.ToString();
}

Ruby:

require 'digest'

def getHash(message, algo='md5')
  case algo.strip.upcase
  when "MD5" then Digest::MD5.hexdigest(message)
  when "SHA1" then Digest::SHA1.hexdigest(message)
  when "SHA256" then Digest::SHA256.hexdigest(message)
  when "SHA384" then Digest::SHA384.hexdigest(message)
  when "SHA512" then Digest::SHA512.hexdigest(message)
  end
end

As you can see, the Ruby version is the most concise & simple.

I will now narrate 2 separate events that have happened with me, within the 2 months of my having a savings account with Kotak Mahindra Bank, which to me are both EPIC Failures!

1. 27th October morning, as I leave my house for office, I realize I am running low on cash, so I decide to go to the Corporation Bank ATM which is the nearest ATM from my residence. I have had an HDFC Bank account for over 2 years and have been using my HDFC Debit Card in this Corporation Bank ATM for nearly 6 months since it came up.So I get to the ATM, decide to use my new Kotak Mahindra Bank – Debit card for the first time to withdraw some cash. I go through the complete process in my attempt to withdraw the amount, only to be disappointed in the end by my transaction being declined with a weird error – Issuer Unavailable. Although a little confused, but running short of patience and time, I decide to well go ahead and use my HDFC Debit Card instead, only to be disappointed again to see the same error.

   Although a little irritated, I wasted no time and continued to my office. As I reach my office and settle down, I see in my mail box a notification email from the Kotak Mahindra Bank with the subject Transaction Success Alert – ATM Cash Withdrawal. I quickly opened the email and to add to my agony of the utter waste of time at the ATM this morning, Kotak Mahindra had actually debited the amount that I had tried to withdraw from my bank account!

   Not a good start to the day, I thought, I quickly opened their website (www.kotak.com), got their customer care number and called them up. After a few key presses I was finally able to get to a customer representative on the other end. I narrated the entire happening once again, requested them to lodge a complain, which they did. However, as if the day hadn’t already had a rough beginning, to my utter disgust & surprise, the customer representative told me that the process of reversal of the transaction would take upto 12 working days! I am now NEVER going to use my Kotak Mahindra Bank Debit Card in an ATM. NEVER EVER!

2. As if the previous days happenings weren’t enough to convince me how much of a FAILURE, Kotak Mahindra Bank is, on 28th October I had yet another rather interesting event and this time, it does not involve an ATM or a fake transaction.

   I am a music lover, and enjoy playing the guitar. I love the finger picking style of guitar playing and am often exploring the web trying to get my hands on nice soothing arrangements which are easy enough for me to try. I happened to come across Kelly Valleau’s video Scientist – Coldplay and I was excited to see that he offered the tabs / scores to his arrangements on his website. I quickly went over to his website, checked out a few more of his videos and was quite excited.

   After a little while, I decided that subscribing to his site would be totally worth it. I clicked on the subscribe button on his site, which took me to paypal, I logged in with my paypal account and I decided to use my Kotak Mahindra Bank Debit Card this time. I added my Debit Card details into Paypal and tried to go through with the transaction, but not to my surprise, the card was declined. I tried a couple of more times, with some hope, but gave up soon and after quite a few curse words to Kotak Mahindra Bank and a few laughs, I just let it go and continued exploring youtube.

   After a while, when I check my phone, I see that I received an SMS Alert from Kotak Mahindra Bank. And I swear to GOD this is what it read :

   Your transaction at PAYPAL, SG using Kotak Debit Card XXXX on 28th-OCT-2010 XX:XX:XX IST could not be processed due to Card not swiped properly. The transaction reference No is XXXXXXXXXXX. Swipe the card properly and try again. .

   Since I had tried a couple of times, I had a couple of those SMS’s.

Now that my friends are both EPIC Failures! As of now I am stuck with Kotak Mahindra Bank, and since I have used it barely in the past 2 months since I hold an account, I am going to give them a little more time (for more EPIC Fails).

After having covered most of the basics of Ruby, lets get started on an actual problem, just like I had promised in my previous article – Getting started with Ruby – Part 5

I am taking a relatively simple problem that came in Google Codejam 2009 qualification round. Here is the direct link to the problem – Alient Language

After years of study, scientists at Google Labs have discovered an alien language transmitted from a faraway planet. The alien language is very unique in that every word consists of exactly L lowercase letters. Also, there are exactly D words in this language.

Once the dictionary of all the words in the alien language was built, the next breakthrough was to discover that the aliens have been transmitting messages to Earth for the past decade. Unfortunately, these signals are weakened due to the distance between our two planets and some of the words may be misinterpreted. In order to help them decipher these messages, the scientists have asked you to devise an algorithm that will determine the number of possible interpretations for a given pattern.

A pattern consists of exactly L tokens. Each token is either a single lowercase letter (the scientists are very sure that this is the letter) or a group of unique lowercase letters surrounded by parenthesis ( and ). For example: (ab)d(dc) means the first letter is either a or b, the second letter is definitely d and the last letter is either d or c. Therefore, the pattern (ab)d(dc) can stand for either one of these 4 possibilities: add, adc, bdd, bdc.

Input

The first line of input contains 3 integers, L, D and N separated by a space. D lines follow, each containing one word of length L. These are the words that are known to exist in the alien language. N test cases then follow, each on its own line and each consisting of a pattern as described above. You may assume that all known words provided are unique.

Output

For each test case, output

Case #X: K

where X is the test case number, starting from 1, and K indicates how many words in the alien language match the pattern.

Limits

Small dataset

1 ≤ L ≤ 10
1 ≤ D ≤ 25
1 ≤ N ≤ 10
Large dataset

1 ≤ L ≤ 15
1 ≤ D ≤ 5000
1 ≤ N ≤ 500

Sample

Input				Output

3 5 4				Case #1: 2
abc					Case #2: 1
abc					Case #3: 3
bca					Case #4: 0
dac
dbc
cba
(ab)(bc)(ca)
abc
(abc)(abc)(abc)
(zyx)bc

If you look at the problem, it’s pretty simple to comprehend. If you have done some reasonable amount of programming, and you have come across Regular Expressions, you should be easily able to identify the pattern here that we need to apply. I am sure there might be other solutions, but here I demonstrate my solution. I am not going to dive into regular expressions here, I would recommend you to do your own research on it if you don’t know them well. So here is our solution for the problem :

L, D, N = gets.split.map{|i| i.to_i} #gets is a function that returns the input from the console as a string. Here we then call the String#split function which splits the string delimited by a space by default and will return an array of the values. However it will be an array of strings, and since we need integers, we can simply call the String#map OR String#collect function which will loop through the array and execute the block on each and return a new array with it. In this case since we call to String#to_i method, the map returns an array of 3 integers, which gets assigned to L, D, N and since we know the length of the array is 3, each L, D, N gets assigned to each element within the array.

words = []

#To fetch D words each of length L.
D.times do |i|
  words[i] = gets #Here we will get the words that exist in the alien language
end

#To fetch N test cases.
N.times do |i|
  r = Regexp.new(gets.gsub('(','[').gsub(')',']').to_s) #Here we will get the test cases and convert them to a Regular Expression. The String#gsub method is used to substitute a pattern with a given input within the string and it returns a new string object with the substituted value.
  count = 0
  words.each do |w|
    count+=1 if r.match(w) #Alternatively you could also use the syntax w =~ r, which practically does the same thing.
  end
  puts "Case ##{i+1}: #{count}\n"
end

#In order to execute the above code, save the code within a file say alien.rb. You can execute the program by calling :
ruby alien.rb
#Then you can input the sample test content manually. Although a better approach would be to save your sample input within an input file, say sample_input.txt and use redirection to pass it to your program, example :
ruby alien.rb < sample_input.txt
#The output in our program is output onto the console. If you wish to save that in a file, we can again use redirection to save the output in a file, example:
ruby alien.rb < sample_input.txt > output.txt

The above solution will help you realize how simple & intuitive it is to code in Ruby :). I hope you liked this article. I will be covering Modules & Classes from next part onwards so do Subscribe to my blog to stay up-to date with my articles. If you have any queries, suggestions or feedback please let me know in the comments below.

Hi in my previous article Getting started with Ruby – Part 4 I covered Hashes & blocks. Today I will take you through the various forms of loops in Ruby.

• While – executes code as long as the given condition is true. We can separate the code from the condition using either the keyword do, a newline or a semi-colon (;)

  	i = 0
  	while i < 5 do
  		puts "Iteration #{i}"
  		i += 1
  	end
  
  	#Output :
  	#Iteration 0
  	#Iteration 1
  	#Iteration 2
  	#Iteration 3
  	#Iteration 4
  
  	#Alternatively, it is also possible to use the while loop as a modifier towards the end of a statement or a code block
  	i = 0
  	begin
  		puts "Iteration #{i}"
  		i += 1
  	end while i < 5
  
  	#Output :
  	#Iteration 0
  	#Iteration 1
  	#Iteration 2
  	#Iteration 3
  	#Iteration 4
  	

• Until – is very similar to the while loop with respect to the syntax & usage, the only difference between the two is the fact that the while loop executes the code block as long as the condition is true, the until loop does exactly the opposite, i.e. it executes the code block as long as the condition is false.

  	until i > 4 do
  		puts "Iteration #{i}"
  		i += 1
  	end
  
  	#Output :
  	#Iteration 0
  	#Iteration 1
  	#Iteration 2
  	#Iteration 3
  	#Iteration 4
  
  	#Again we also have the alternate syntax where we can use until as a modified at the end of a statement or a code block
  	begin
  		puts "Iteration #{i}"
  		i += 1
  	end until i > 4
  
  	#Output :
  	#Iteration 0
  	#Iteration 1
  	#Iteration 2
  	#Iteration 3
  	#Iteration 4
  	

• For – executes a block of code once for each element in the expression / object passed to it. Again as in the case of while & until above, the block of code may be separated from the expression by either using the keyword do, a newline or a semi-colon (;)

  	array = 1,2,4,5
  	for i in array
  		puts "Array element #{i}"
  	end
  
  	#Output :
  	#Array element 1
  	#Array element 2
  	#Array element 4
  	#Array element 5
  
  	#OR
  
  	for i in 0...10 do #Remember '...' creates a range which excludes the last element from the range.
  		puts "Iteration #{i}"
  	end
  
  	#Output :
  	#Iteration 0
  	#Iteration 1
  	#Iteration 2
  	#Iteration 3
  	#Iteration 4
  	#Iteration 5
  	#Iteration 6
  	#Iteration 7
  	#Iteration 8
  	#Iteration 9
  	

• These are some of the other loops which are available through fixnums

  	10.times {|i| p i}
  
  	#Output :
  	#0
  	#1
  	#2
  	#3
  	#4
  	#5
  	#6
  	#7
  	#8
  	#9
  
  	1.upto(10) {|i| p i}
  
  	#Output :
  	#1
  	#2
  	#3
  	#4
  	#5
  	#6
  	#7
  	#8
  	#9
  	#10
  
  	1.step(10, 2) {|i| p i}
  
  	#Output :
  	#0
  	#2
  	#4
  	#6
  	#8
  	#10
  

• Collections provide various different & interesting forms of looping mechanisms.

  	array.each do |i|
  		puts "Array element #{i}"
  	end
  
  	#Output :
  	#Array element 1
  	#Array element 2
  	#Array element 4
  	#Array element 5
  
  	array.each_with_index do |value, index|
  		puts "array[#{index}] = #{value}"
  	end
  
  	#Output :
  	#array[0] = 1
  	#array[1] = 2
  	#array[2] = 4
  	#array[3] = 5
  
  	array.collect {|i| i.to_s} #=> ['1', '2', '4', '5']
  	array.map #same as collect
  
  	array.find {|i| i == 1} #=> 1
  	array.find {|i| i == 3} #=> nil
  	array.find('Doesn\'t Exist!') {|i| i == 3} #=> "Doesn't Exist!"
  	array.detect #same as find
  
  	array.select {|i| i == 1} #=> [1]
  	array.find_all #same as select
  
  	array.all? {|i| i.is_a?(Integer)} #=> true
  	#Loops through all the elements and executes the block for each, it returns true if the block returned true for all elements, otherwise it returns false.
  
  	array.any?{|i| i == 1} #=> true
  	#Loops through all the elements and executes the block for each, it returns true if any of the elements return true for the block, if all of them are false, it would return false.
  
  	array.each_cons(3) {|i| p i}
  	#Output :
  	#[1, 2, 4]
  	#[2, 4, 5]
  	#each_cons(n) takes 'n' consecutive elements from the array and goes from the start of the array till the end with a sub array start with each element at that index of size 'n'.
  
  	array.each_slice(3) {|i| p i}
  	#Output :
  	#[1, 2, 4]
  	#[5]
  	#each_slice(n) divides the array into slices of 'n' elements each starting from the index 0.
  
  	array.inject(0) {|s, i| s+=i} #=> 12
  	#This is a very nifty method, in the method call as argument it takes as input (in this case 0) as the initial value for a variable, within the block you get that variable as the first argument (in this case s) and the method loops through all the values within the object and executes the block for it.
  
  	#Some more useful methods for Collections
  	array.first #=> 1
  	array.last #=> 5
  
  	array.max #=> 5
  	array.min #=> 1
  
  	array.sort #=> [1, 2, 4, 5]
  	array.sort {|i, j| j <=> i} #=> [5, 4, 2, 1]
  	#This returns a new array with the same values as the caller array but in sorted order
  	array #=> [1, 2, 4, 5]
  
  	array.sort! {|i, j| j <=> i}  #=> [5, 4, 2, 1]
  	#as the ! indicates, the sort method modifies the caller object itself and updates it with the sorted array.
  	array #=> [5, 4, 2, 1]
  	

Loop flow control modifiers:

• Break – terminates the immediate loop currently executing

  	array = 1, 2, 3, 4
  	array.each do |i|
  		puts i
  		break if i == 2 #In Ruby if a condition spans a single line you can simply follow the code block with the if condition and it will be evaluated just as you can read it.
  	end
  
  	#Output :
  	#1
  	#2
  	

• Next – terminates the current iteration and beings the next.

  	array = 1, 2, 3, 4
  	array.each {|i| next if i < 3; puts i}
  
  	#Output :
  	#3
  	#4
  	

• Redo – restarts the current iteration.

  	j = 0
  	array = 1, 2, 3, 4
  	array.each do |i|
  		puts i
  		break if (j += 1) == 10
  		redo if i > 2
  	end
  
  	#Output :
  	#1
  	#2
  	#3
  	#3
  	#3
  	#3
  	#3
  	#3
  	#3
  	#3
  
  	#As you can see here, as soon as i > 2 (i == 3) the current iteration is restarted, since the value of i was 3, it remains 3. I have used the variable j to ensure that after 10 iterations the loop terminates with the help of the break modifier, otherwise the loop will keep running infinitely.
  	

That having done, let me now get started with the other basic

Variables

Any plain lowercase word is qualified to be an identifier or a variable name. Variable names may contain letters, underscores or digits except that a variable name cannot begin with a digit.

x = 0
y1 = 0
test_variable_1 = 'string'

x = y = z = 0

x, y, z = 1, 2, 3 #=> [1, 2, 3]
x #=> 1
y #=> 2
z #=> 3

a, (b, c), d = 1, 2, 3, 4
#=> a = 1, b = 2, c = nil, d = 3

a, (b, c), d = 1, [2, 3], 4
#=> a = 1, b = 2, c = 3, d = 4

Symbols

Symbols are very similar to variables, except they start with a colon (:), they too may contain letters, underscores or digits except that they can’t begin with a digit (i.e. after the colon). Symbols are lightweight strings, they take up less memory, are faster and are immutable. These are generally used where you don’t need to print them out and also are rightly used for keys in hashes.

hash = {}
hash[:key] = 'value'
#As stated above it is always recommended to use Symbols where ever possible since they take up lesser memory, are always faster to work with and most importantly are immutable.

Constants

Constants in Ruby are words again very much like variables, except that they are capitalized. Constants as the name suggests are used for storing constant values which will not change over time. The most prominent usage of constants comes in defining classes, whose names are always constants, we will see classes later in much more detail. If you try to reassign an already assigned constant, the ruby interpreter will throw a warning and let you know, however the value will still change

Methods

Classes from a generic OOPs concepts is nothing but an encapsulation of the properties & functions to work on those properties. Methods are those functions. Methods in ruby are referred to as messages that are send to the caller object, methods may optionally take arguments as input.

In Ruby all methods return something, by default the last statement within the method’s definition determines what is returned. Although we have the return keyword in ruby, we do not always need to use it since we know the fact that the last line of the method body is always returned, hence when returning a value we can simply just have that value as the last line of the method definition and it will be returned.

Global Variables

Variables that begin with a dollar ($) sign are global. They are accessible from anywhere within your program, they never go out of scope, since they are in global scope.

That covers a lot for one post :). For now I think this much is enough for us to get started with coding something more concrete than what we have up until now. So in my next article I will take up a smallish problem to work on and we’ll see the solution for it. After that we’ll move onto classes & modules. Hope these articles benefit more people than I think. If you have any queries, suggestions or feedback, please let me know in the comments below.

In my previous article Getting started with Ruby – Part 3 I started with Collections and covered basics of Ranges & Arrays. Like I mentioned towards the end of the article (in case you couldn’t manage to reach the end) I will start with one of the most commonly used Collection objects in Ruby, namely Hashes.

Hashes are essentially data structures to store key – value pairs, when you wish to store an element in the Hash you do so by assigning a unique key to it within the hash and while retrieving you do so with the help of that unique key. The beauty of hashes is the fact that the ‘key’ in question here could be just about any object in Ruby, most commonly however in practice strings or symbols (i’ll get to what these are soon) are used as keys.

Well i’ve said enough, time for some code :

hash = {} #=> {}
hash = Hash.new #=> {}
hash = {'key1' => 'value1',
        'key2' => Object.new,
        :key3 => Hash.new,
        1 => 2}

hash['key1'] #=> 'value1'
hash['key2'] #=> #<Object:0x00000001e98bc0>
hash['key3'] #=> nil
hash[:key3] #=> {}
hash[1] #=> 2

hash = Hash.new('Doesn\'t Exist!')
hash['dummy-key'] #=> "Doesn't Exist!"
#The constructor for a Hash takes the default value as input that should be returned when referencing a non-existent key, when nothing is input to the constructor the default value is nil.

hash['dummy-key'] = 'Dummy Value' #=> 'Dummy Value'
hash #=> {"dummy-key"=>"Dummy Value"}
#In order to define a new key-value pair for a hash, you simply use the assignment operation for the key, if the key doesn't already exist within the array, it creates a new key value pair based on what you assigned, however if they key had already existed in the hash, then the value of that key would get overwritten by the new assignment.

hash.store('key', 'value') #=> 'value'
hash #=> {'dummy-key'=>'Dummy Value', 'key' => 'value'}
#As you can see, you can alternatively use the store method to achieve the same, however in practice one rarely use it.

hash.has_key?('key') #=> true
hash.has_value?('value') #=> true

hash.empty? #=> false

hash.delete('key') #=> 'value'
hash #=> {'dummy-key' => 'Dummy Value'}
hash.delete('test') #=> "Doesn't Exist!"

hash.clear #=> {}
hash.empty? #=> true

hash.keys #=> ['dummy-key']
#The keys method for a hash returns an array of all the keys available by the hash object

hash.values #=> ['Dummy Value']
#The values method for a hash returns an array of all the values available in the hash object.

That just about covers the basics of Hashes, which in turn covers the basics of various built-in data type classes in Ruby.

As per my previous article Getting started with Ruby – Part 3 I have to now get started with loops in Ruby. But before I get into that, I feel it is important that I introduce you to blocks. Blocks in Ruby are essentially nameless functions, in Ruby blocks are used extensively to achieve a lot of cool stuff.

def block_test
  yield if block_given?
end

block_test { puts "test" }
#Here we call the block_test method and pass in a block. A block as I explained before is a nameless function, and hence we can do everything within a block, that we can do within a function. A block can be defined in 2 ways.

{ puts "test1"; puts "test2" }
#OR
do
  puts "test1"
  puts "test2"
end

#As you can see, the first way to define a block is using the curly braces {}, which is used to define a block in a single line of code. If you wish to still include multiple lines of code within the {} block, you may do so by using the ';' which you can use as a delimiter to have multiple Ruby statements on a single line. The other way to define blocks is using the 'do...end' which allows you to write your code in separate lines and comes in more useful when dealing with more complex code.
#In Ruby, every function can optionally receive a single block, which can be executed from within the function with the help of the "yield" function. Since it is optional, Ruby also provides a special method "block_given?" which returns true | false depending on weather a block was passed to the function during its call or not.

def block_with_args_test
  yield("string argument1", "string argument2") if block_given?
end

block_with_args_test {|arg1, arg2| puts arg1; puts arg2}

#Output :
#string argument1
#string argument2

#Here you see how you can define blocks that accept arguments. When you use the yield method, you can pass in values as arguments and they are then passed onto the block during invocation.

For now I think that  good enough to go forward, later on we should come across more complex & advanced usages of blocks & closures.

An important point about functions, it is not mandatory to use brackets ‘(‘ & ‘)’  while calling a function for passing the arguments unless you’re calling a function within a function call as an argument or when you are passing a block to it

def test(arg1, arg2)
  puts arg1
  puts arg2
  yield if block_given?
end

test 1, 2
#Output :
#1
#2

test(1,2)
#Output :
#1
#2

test(1,2) {puts 'test'}
#Output :
#1
#2
#test

test 1, 2 {puts 'test'}
syntax error, unexpected '}', expecting $end
test 1, 2, {puts 'test'}
syntax error, unexpected '}', expecting $end

Considering that the article is already quite long and loaded with a whole lot to digest, I will now take up loops in my next part. I hope the article is easy to understand. If you have any questions or suggestions, please feel free to put them in the comments below and I will make sure I address it asap.

In my previous article Getting started with Ruby – Part 2 I introduced you all to Ruby & its philosophy and I started out with data type classes in Ruby. I was able to give you an overview about Strings & Numbers in ruby. Today I will start with Collections.

• The Range – As the name suggests, ranges hold a sequential collection of numbers. Defining a range in Ruby is extremely simple, instead of explaining, i’ll show it to you. Don’t be afraid to start an IRB shell to try the code out.

  full_range = 1..10
  loop_range = 0...10
  test_range = 1..10
  
  puts full_range == loop_range #=> false
  puts full_range == test_range #=> true
  puts loop_range.eql?(loop_range) #=> false
  
  puts full_range.include?(1) #=> true
  puts test_range.include?(4) #=> true
  puts full_range.include?(10) #=> true
  puts full_range.include?(12) #=> false
  
  puts loop_range.include?(0) #=> true
  puts loop_range.include?(4) #=> true
  puts loop_range.include?(10) #=> false
  

  From the examples above, it should be clear what the syntax to define a range is, although you might be confused regarding the difference in line 1 & line 2, I can assure you it’s not a typo. Ruby provides 2 ways to create ranges, one using two periods (..) and one using triple periods (…), the difference being full_range = 1..10 is a range which starts from value 1 and ends at value 10, whereas loop_range = 0…10 is a range that starts from value 0 and ends at value 9.

  Here I have also introduced you to 3 methods of the range ==, eql? & include?, I am sure that the methods names are quite self explanatory. Although I would like to bring your attention towards a convention that is followed in ruby for method names. Method names in Ruby may end in =, ? or !. As a convention we end a method name in ? to indicate that the method will be returning a boolean value, i.e. true or false, we end a method name in = to indicate that it is a setter method used for assignment operations, and we end a method name in ! to indicate that the execution of the method will alter the state / value of the caller object. We will get into details of methods later again when we would be digging into classes.

• Array – These are simple indexed or ordered collection of elements or objects. If you have worked in C/C++/Java, Arrays are similar in concept except for the fact that the various elements within the Array need not be of the same type, they could be of any type. Let me give you some examples to make it more clear :

  empty_array = [] #=> []
  another_empty_array = Array.new #=> []
  number_array = (1..10).to_a #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  #to_a is a method that the Range class implements which converts the range to an array and returns the array
  
  random_array = [1, 'hello', (100/3).to_s, Array.new, (1..10).to_a]
  #=> [1, "hello", "33", [], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
  #As you can see, the array is dynamic in nature and the individual element can be just about any object.
  
  preinitialized_array = Array.new(10) #=> [nil, nil, nil, nil, nil, nil, nil, nil, nil, nil]
  preinitialized_array_with_values = Array.new(10) {0} #=> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  
  short_hand_array = %w(this is an array) #=> ["this", "is", "an", "array"]
  short_hand_with_interpolation = %W(this is an array of length #{1*7})
  #=> ["this", "is", "an", "array", "of", "length", "7"]
  #%w works similar to single quoted string creation except that it creates an array out of the words, whereas %W works similar to double quoted string creation and allows for interpolation by embedding results within and creates an array from the words.
  
  short_hand_with_string = 'this is an array'.split #=> ["this", "is", "an", "array"]
  short_hand_with_string = 'this is an array'.split(' ') #=> ["this", "is", "an", "array"]
  
  short_hand_with_string[0] #=> 'this'
  short_hand_with_string[-1] #=> 'array'
  short_hand_with_string[-2] #=> 'an'
  #you can access the array from reverse by using negative numbers, awesome isn't it ? :)
  
  short_hand_with_string[0..2] #=> ["this", "is", "an"]
  #you can use a range to reference multiple elements within an array and it will return an array
  
  short_hand_with_string.values_at(0, 1, 2) #=> ["this", "is", "an"]
  
  short_hand_with_string.at(-1) #=> 'array'
  short_hand_with_string.at(100) #=> nil
  short_hand_with_string.fetch(100, 'Not Found!') #=> 'Not Found!'
  

  The above are various ways in which one can create & access Arrays in Ruby, I think most of them are pretty self explanatory, there may be some minor constructs here that you may not understand, but I will be going through them more in detail later on, for now lets concentrate on just Arrays.

  Let us now take a look at various ways to manipulate arrays :

  array = (1..10).to_a #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  array[0] = 11 #=> [11, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  array[12] = 12 #=> [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12]
  array.push(13, 14) #=> [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14]
  #pushes / appends / inserts multiple comma separate values to the end of the array
  
  array.insert(-1, 16) #=> [11, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14, 16]
  array.insert(1, 100, 101) #=> [11, 100, 101, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14, 16]
  #insert method takes as input multiple comma separate values, however the first argument is the index of the position where you wish to insert th multiple values. So the values after the first argument are the values tha will be inserted into the array started from the index identified by the first argument.
  
  array<< 20 #=> [11, 100, 101, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14, 16, 20]
  array<< 21<< 22<< 23
  #=> [11, 100, 101, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14, 16, 20, 21, 22, 23]
  array.pop #=> 23
  array #=> [11, 100, 101, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14, 16, 20, 21, 22]
  
  array.pop(2) #=> [21, 22]
  array #=> [11, 100, 101, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14, 16, 20]
  #As you can see above pop method can optionally take as input an integer representing the number of elements that should be popped from the array.
  
  array.shift #=> 11
  array #=> [100, 101, 2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14, 16, 20, 21, 22]
  array.shift(2) #=> [100, 101]
  array #=> [2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 14, 16, 20]
  
  array.index(14) #=> 13
  #This returns the index of the input element in the array, it returns nil if the element doesn't exist
  
  array.include?(5) #=> true
  
  array.delete(14) #=> 14
  array #=> [2, 3, 4, 5, 6, 7, 8, 9, 10, nil, nil, 12, 13, 16, 20]
  #delete method takes as input an element which is then deleted from the caller array. In case the element does not exist within the array, it returns with nil.
  
  array.delete(1000) { 'Doesn\'t Exist!' } #=> Doesn't Exist
  #The delete method also accepts a block which it uses in case the input element does not exist
  
  array.delete_at(3) #=> 5
  array #=> [2, 3, 4, 6, 7, 8, 9, 10, nil, nil, 12, 13, 16, 20]
  #delete_at method takes the index number as input instead of the element like the delete method and deletes the element at that index within the caller array and returns it.
  

  The above should give you a very good idea on how to create & manipulate arrays, the examples should be explanatory, I have also added helpful comments along.

  I had forgotten to demonstrate some really powerful features of arrays before hand. Let me do that now :

  array1 = 1,2,3,4
  array2 = 4,5,6,7
  #As you can see, while assigning, its not necessary to have the square brackets []
  
  array1 + array2 #=> [1, 2, 3, 4, 4, 5, 6, 7]
  #union
  
  array1 - array2 #=> [1, 2, 3]
  array2 - array1 #=> [5, 6, 7]
  #difference
  
  array1 & array2 #=> [4]
  #intersection
  

  Since the article is already very long, I will cut it short here and take up the last collection data type Hash in my next article. After that I will take you through various mechanisms for looping over collections in Ruby, which will apply to all collection data types.

  In Ruby there are always several ways to do one thing, the reason for that is because there are always more than one intuitive way to do the same thing. Different developers use different ways to do what they wish to as per what suits them best. I am sure you will get there too soon enough.

  Please do feel free to launch the IRB and try out various things that I have shown here, experiment & play around with it and I am sure you will have a nice time :). After I finish with covering the looping mechanisms for collections I will also write about how you can use IRB & Ruby’s reflective nature to inspect objects.

  I hope you find the series of articles easy to understand and that it helps you getting started with Ruby. In case you have any questions or suggestions, please do let me know by adding it in the comments below.

Hi again, this is part 2 of my series of articles to help beginners getting started with the Ruby programming language. At this point of time I would like to quote the definition of Ruby from the Ruby-Lang official website.

A dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.

I know I had already quoted Ruby’s definition from wikipedia in my previous article ‘Getting started with Ruby – Part 1‘, but that was more of a technical definition. Here I wanted to draw your attention to Yukihiro Matsumoto‘s, popularly known as Matz’s philosophy behind creating Ruby, which is making programming as simple & natural as humanely possible. We will be witnessing that very soon.

NOTE : Before diving into programming, I would like to bring to your notice the fact that most of the information that I will be sharing here in my articles, would be my interpretation of publicly available information, and based on my experiences, I will try to be as expressive as possible, however I can make mistakes and would appreciate your help in pointing out the same if I do. All my examples have been ran and tested on Ruby 1.9.2-p0.

Ruby is a Pure Object Oriented Programming Language, by pure, it is implied that everything in Ruby is an object. Unlike programming languages like C++/Java/C# which are OOPLs but not pure since they have primitive data types which are not objects, in Ruby, everything is an object. However, that being said, we obviously do have types in Ruby, but these are not primitive data types, they are classes which originate from the Object class. In Ruby every class originates from the Object class. The following are the various data types in Ruby :

• String – as the name suggests, these are a sequence of characters. Any sequence of characters enclosed between single or double quotes creates a string. Let us look at some examples :

  puts 'Hello' #=> Hello
  puts 'What\'s Up?' #=> What's Up?
  puts "A\tTab." #=> A	Tab.
  puts "#{4*4}" #=> 16
  

  First example is pretty straight forward, in the second example I demonstrate what are known as escape sequences. Since the single quote (‘) is used to indicate the start & end of a string, if you wanted to use one within a string, you need to use the escape sequence using the backslash (\) to indicate the Ruby interpreter to replace it with that character and ignore it for the purpose of determining the start & end of the string. The third example is also demonstrates the use of certain special escape sequences, which when used in strings defined using double quotes (“) are parsed and replaced with appropriate value. In the example \t is replaced by the Ruby interpreter with a tab character. The fourth example demonstrates how you can evaluate expressions and embed their values within strings, again this is possible only for strings defined using double quotes (“).

  Single quoted strings are ordinary strings and have a very limited set of escape sequences, whereas Double quoted strings offer a lot more escape sequences like \t, \n, \r, \s, etc and also they allow expression interpolation, that is embedding results of expressions or variables within strings by enclosing them within #{…}

  Now I will take you through some extremely interesting examples :

  puts 'Hello ' * 3 #=> Hello Hello Hello
  puts %q{Whats Up?} #=> Whats Up?
  puts %Q{A\tTab.} #=> A	Tab.
  puts %Q;#{4*4}; #=> 16
  puts %Q(#{5*5}) #=> 25
  

  The first example might surprise you, however if you think about it logically, it does exactly what you would expect it to do. Since string literals, like everything else in Ruby are objects, multiplying it with a number makes that many copies of it.

  The following 3 examples demonstrate a short hand notation in Ruby to create strings, as you might be able to tell, %q is the equivalent to using single quotes and %Q is equivalent to using double quotes. The short hand notation allows you to use any special character as a delimiter which it uses for identifying the start and end of the expression that it will evaluate to create the string. Hence %Q.#{4*4}. == %Q{#{4*4}} == %Q@#{4*4}@ == %Q$#{4*4}$ == %Q(#{4*4}), etc etc. This is true for all short hand notations.

• Numbers – Ruby has two class Fixnum & Bignum to represent numbers. As i’ve mentioned before, everything in Ruby is an object, and so are numbers! Fixnum are numbers within the range (-2^30) and (2^30 – 1), if the value of the number goes beyond this range, ruby transparently assigns it to an instance of Bignum so you as a programmer do not need to worry about that.
  examples :

  puts 23 #=> 23
  puts 12_000_000_000 #=> 12000000000
  puts 3.14 #=> 3.14
  puts 1.0e5 #=> 100000
  

  As you can see, Ruby allows underscores (_) within numbers and so you can make use of that to make your numbers more readable. Numbers with decimal place are known as floats, last two are examples of floats.

  puts 1 + 2 #=> 3
  puts 1.+(2) #=> 3
  puts 2**3 #=> 8
  

  The above snippet demonstrates how to perform arithmetic operations within Ruby. Here I would like to point out one important point. Since numbers in Ruby are objects, all arithmetic operations that we perform are actually methods that exist with the objects, although it is not very evident most of the time. The second example demonstrates how + is actually a method that we invoke using the object with value 1 and pass to it the object with value 2, which returns an object of value 3, the sum of 1 & 2.
  All standard arithmetic operations exist in Ruby along with a special (**) operation, which is exponent operation. In the above example 2**3 can be read as 2^3 and the result of that is 8.

I will cut short the article here since the article has grown quite long already. I will continue with other data types in the next article, after which I will take you through variables, symbols, methods, classes and more. I hope you like the article and it is easy to understand. If you have any questions or suggestions, please do let me know in the comments below.