You can contact me, Karthikeyan A K on mindaslab@protonmail.com or via phone +91 8428050777 or on twitter @karthik_ak. I would love to hear from people who read my book, so do write to me if you feel so.

You need to install something called RVM (ruby version manager https://rvm.io) which will manage multiple ruby versions. Why? It’s because Ruby’s version changes so fast. Before you had 1.8, now 1.9, 2, and now we have Ruby 3. Apart from just using Ruby alone, you will also use it for other stuff like web development with packages such as Sinatra and Ruby on Rails. You might need to change from one version to other without uninstalling and reinstalling ruby again and again. RVM manages this for you. With simple commands we can switch between Ruby versions easily.

Installing RVM :

OK, to install RVM, you need to have curl (a program that can download things). To get curl, just type

Now install RVM using the following command

Once done give these commands into terminal. These will tell Ubuntu GNU/Linux where to find the rvm.

Installing Ruby

Once rvm is installed, you can install Ruby

Once this is done, you may need to restart your terminal. Open the terminal and type the following:

It will spit an output something like this:

Then all is OK!

You need a good IDE (Integrated development environment) to get started with Ruby. I recommend simple and lightweight IDE Geany (https://geany.org). To install the IDE on Ubuntu just type (without that $):

If the system asks for administrator password, provide it.

URL: http://ruby-lang.org

Ruby website is a great place to start with Ruby. It provides you with the installers to install Ruby on your operating system (but I recommend using RVM). It has cool links like 'Try Ruby! in your browser', which lets you try out Ruby right from your web browser and a link called 'Ruby in Twenty Minutes' teaches you the basics of Ruby programming. Ruby is such a simple language that you just need 20 minutes to grasp it! Trust me it’s true!

Also try visiting https://www.ruby-lang.org/en/community/mailing-lists/ and you will see a form like this

Type in your email and submit the form, you will receive an email to subscribe to Ruby mailing list. Follow the instructions in the email and subscribe. One you have done, congrats! You are part of Ruby community now!!

Reddit has a very active Ruby community. You can find it here https://www.reddit.com/r/ruby/ . The great thing about reddit is the stories are raked by fellow users, and whats the best bubbles up. If you are looking for what’s really trending in Ruby or any other tech topic, I find reddit being the best.

Ruby flow is a website which I use it for casual reading of whats happening in Ruby community. It’s a very clean website where Rubyists can post what they think fellow Rubyists must know about Ruby. You can access it here http://www.rubyflow.com/

URL: http://twitter.com

Twitter is a socializing website. Then why on Earth am I putting it here? Well lots of Ruby programmers use twitter, possibly because it was written with Ruby initially. To get the latest news about “Ruby Programming”, type it in the search bar and press search. You will get latest trending topics about Ruby language. Try searches like “Ruby language” and blah blah…​.

Ruby provides us a easy way to interact with it, this feature is called interactive ruby or irb ^[5]. With irb you can type small bits of ruby code in your console and see it get executed. irb is a great tool to check out small pieces of Ruby code. In your terminal type irb or irb –-simple-prompt , you will be getting prompt as shown

The above prompt will be got if you had typed irb

The above prompt will be got if you had typed irb –-simple-prompt, in examples from now on I will be using the simple prompt. Let’s write our first hello world program, in the prompt type the following (don’t type those >>)

When you press enter, you will get output as follows. In Ruby puts is used for printing something onto the console.

Very well, we have completed our hello world program under a minute. Lets check what is 56 to the power of 31 is

OOPS! You never thought it would be such a large number, did you? Any way, the ** is used to find a number raised to the power of another number.

To quit irb and return to normal console or terminal prompt type quit or press Ctrl+c on keyboard.

Ruby’s REPL that you can invoke by typing irb in your terminal is good, but imagine if you can run a vey interactive REPL in your browser. A tool called Jupyter does just that. One can learn about Jupyter here https://jupyter.org/ , one may install it on your computer. For that you need to have Python installed first.

Once you have done it you can install a gem called iruby by typing

in your terminal.

Once done you can launch Jupyter lab by typing:

Your browser will open up and you will get a screen as shown:

In the above picture one can see that I have integrated Jupyter with various languages, and Ruby is one among them. I need to click the Ruby icon to be presented with a screen as shown:

At the left I have file browser where I renamed the file as ruby_injupyter.ipynb, one can get the file here https://i-love-ruby.gitlab.io/code/ruby_injupyter.ipynb

So start typing commands like

Press kbd:[Shiift + Enter] to execute it, and now try out

One may also try to use Jupyter for almost this entire book to learn Ruby.

Computer is a device that computes, or does some math. With irb we can do easy math. If you don’t like to work with numbers, ruby can do it for you. So, first, let’s add these numbers : 1, 45, 67, 893, 72, 56 and -128. To do so in your irb prompt just type these numbers separated by a plus '+' sign, and you will get the result

Here are some common math operators that you will find useful

Addition Example: Lets say that I want to add 56 and 72 and find its result, I can do it as shown:

Subtraction Example: In this example I am subtracting 64 from 112

Division Example: Lets say I want to divide 117 by 12 and find the quotient, I can do in Ruby like this

Power Example: Lets say I want to find what we will get by cubing five (five raised to the power of three), I can do it in Ruby as shown

Modulus or Remainder Example: I want to know what we will get as remainder when we divide 21 by 4, I can do it as shown

Addition with assignment Example: Lets declare a variable i, set it to 5 and add 37 to it. In ruby you can do it as shown

At the end when we type i and see we get 42. This means i holds the value 42 in it.

Subtraction with assignment Example: Lets declare a variable j , assign it with a value 50 and take away 17 from it

At the end when we type j and see we get 33. This means j holds the value 33 in it.

Multiplication with assignment Example: Lets declare a variable k, set it to 3 and multiply it by nine

At the end when we type k and see we get 27. This means k holds the value 27 in it.

Division with assignment Example: Lets declare a variable s, set it to 25 and divide it by 5

At the end when we type s and see we get 5. This means s holds the value 5 in it.

Try other operators on your own, I’m running out of patience.

Variables are something that stores value in it. You can imagine them as a box which can hold pebbles. If a box named a holds five pebbles then its value is 5, if another box b holds three pebbles, then its value is 3. Let say you got a new box c and you want its value to be the sum of box a and box b, then you simply add number of pebbles in a and b, it totals to 8, you put 8 pebbles in c to make c = a + b. I hope you have got a hint what a variable is. Let’s program it in Ruby

Let’s try another problem, I buy 50 mangoes from a farmer at ₹ 10/- and bring it to the market and sell it at ₹ 15/- each, what is my profit?

Answer:

OK first I have 50 mangoes so in irb I type as shown:

So I have assigned the value of 50 to a variable called mangoes. Next I declare and assign a value of 10 to a variable buy_price as shown:

Similarly, I assign 15 to a variable named sell_price

Now profit per mango is the difference between sell and buy price, hence I can calculate it as shown

By selling a mango I get a profit of Rs 5/-, what will I get by selling 50 mangoes? It’s a multiple of profit with mangoes and we get it as shown

So by selling 50 mangoes we can earn a profit of ₹ 250/-. Lets say that we have bought 72 mangoes, now we want to know what profit would be, this can be easily done by changing or varying the value of mangoes from 50 to 72 and recalculating the total_profit as shown below

Now you may know why we call these things are variables, a variable is a box that can contain any value it wants. Just like you can add or take away pebbles from a box, you can do the same to math operation to variables.

Unlike variables, some values must be constant, for example the radius of the Earth is constant, the speed of light is constant. In problems that deal with these kind of issues, or in situations where you are absolutely certain that some values won’t change, you can use constants.

A constant can be thought as a variable whose value doesn’t change. Constants in Ruby starts with a capital letter, it could then be followed by alphabets, numbers or underscore. Let’s now have a constant called Pi who value will be equal to mathematical \$pi\$, to do so just type the following in irb prompt

Having assigned the value of \$pi\$ to a constant named Pi, we will now try to find area a circle whose radius is 7 units, so lets use our faithful calculator the irb. We know that area of a circle is \$pi r^2\$, where \$r\$ is the circle’s radius. In your irb prompt we can do the calculation as follows

So we find area of circle is roughly 153.9972 square units, which is very near to the exact value of 154 square units.

One can ask whether can we change value of constant? I don’t say it’s impossible, but if we change ruby gives us warning that we are changing the value of a constant, after the warning the constant gets changed anyway.

In the above example I have re-assigned the value of Pi to 5, as you can see in the second line, Ruby interpreter does throw out a warning that Pi is already initialized constant, but any way the value of Pi gets changed to 5. It is strongly discouraged not to change values of constants in professional programming.

Till now, we have seen about numbers, now let’s see something about text. In computers text are called as string ^[8]. OK lets see about strings in Ruby. Let’s start with a hello world. In your irb type hello world as shown

As a response you get an “hello world”. In short, string is any stuff that’s surrounded by " or by '

Now let’s try the above example by surrounding the above hello world with single quotes

Well you do get the same response. So what’s the difference between single and double quotes? Take a look at the following example

At first, we declare a variable called time_now and store the current time into it. The current time in Ruby is got by Time.new command. Now we have a variable, and we can embed it into a string by putting it like #{put_your_variable_here}. So we want to tell the world the time now is something, so we give a command as shown

and we get a proper result. Note that you have enclosed the string with a double quotes. Now let’s try the same thing with single quotes

We see that in this case the world is not able to see what time it is, rather it’s able to see a ugly string as shown

What ever that’s put between single quotes gets printed as it is. You might ask why # is printed as \#, well we will see it in escape sequence soon.

Till now, you have keyed in small programs into your irb, when you are developing large software you can’t expect the end user or your clients to keep keying in into the console the statements you have developed for him / her, instead you will be handing over a typed Ruby program which they can run it to accomplish certain task. Let’s see how to use a text editor to write programs. Earlier in Installing IDE section I have typed about how to install a simple Integrated Development Environment (IDE) called Geany (https://geany.org). If you are using Ubuntu, press super key, type in Geany, click on the Geany icon, and you will get it.

You can use other IDE’s too, if you want other IDE, refer to their documentation for installation instructions. In the IDE type the following program

Now save the file as hello_world.rb in a directory, note that Ruby files ends with .rb (dot rb) extension. Launch your terminal / console, migrate to the directory where program is stored and type the following in it

and here’s how you will get the output.

Wonderful! You have learned to program with a text editor, you are getting professional aye!

Study the code hello_world.rb, we have used a Ruby command called puts, this commands puts something to the output, in this case your terminal window.

The first line prints Hello World! And the second one prints This time I used a text editor. What if you want to print two things in the very same line? For it Use the print command, let’s type a new program hello_world_1.rb for it, in your text editor type the following code:

This gives the output:

A program is more useful when it interacts with the user, let’s write a program that asks us our name and says hello to us. Type the following code (I saved it as say_hello.rb)

Now run it, this is how the output will look like

Lets walkthru the program

The first line

Prints that the program name is Zigor and it’s a automated robot that wishes you Hello. Then it prints a line feed, hence the content that’s printed then on goes to the next line

The second line

prints out "Please enter your name:", note that we have used print here, not puts because we want to get the user’s name right after name:, I feel it will be awkward if we let them type name in the next line, so to avoid the line feed I am using print instead of puts.

When the user enters name and presses enter, it is caught by the gets() function and the thing you typed is stored in the variable called name because of this piece of code

Now all our Zigor needs to do is to wish hello, for which we use this code

Notice how we are embedding the variable name into string by putting it between #{ and }. The same effect can be achieved by using code like this

But doesn’t the former piece of code look better? It’s all your choice. Ruby lets you do the same thing in many ways. You can choose anything that you feel comfortable.

Any way in this topic the line you must be looking at is the one that has gets() method or function, it waits for a keyboard input, when you give an input and press enter, it takes your input and assigns the value to variable, in this case the variable is name.

Comments are small pieces of notes you can put into a program so that you or someone else when going through the program 7,658 years from now will remember or come to know what its doing. You may be smart today, but tomorrow you may not be as smart as you are now, your boss or client who has paid you will yell upon you at that moment to fix a priority bug or to update a software. Open your text editor and type this code:

You might be able to understand it now, but after 7,658 years ^[11]? At that time you might have forgotten Ruby altogether! So start commenting. See the same program comment.rb below, how it looks like?

Look at the code above, you have told something about client in the first three lines. These lines start with a # (hash or check sign). The thing that follows after a check sign is a comment, comments don’t interfere with programs execution, but it can be used to provide visual hints to humans of what’s going on in the program.

Now lets look at this line

Here you have #{name} enclosed within double quotes, hence it’s treated as an embedded ruby code in a string rather than a comment, whereas # Embeds name into the string that gets printed is treated as comment.

So I hope you understand that comment can one day help. Professionals always comment when they write code. They will take pains so that almost any Ruby coder who reads their program will be able to understand how it works.

Logical operators lets you determine whether something is true or not. For example one is one, that’s what humans think, let’s see what computers think about it. Fire your irb and type one equals to one as shown

Well, what’s that double equal to sign? A single equal to sign means assignment, for example a = 5, puts value 5 into a. A double equal to sign is comparison. So above we have checked if 1 is equal to 1 and the answer is true. Computers are intelligent, aren’t they? OK, now let’s check if 1 equals to 2, so we type 1==2 and…​.

the computer (Ruby interpreter in this case) tells its false.

Fine, if 1 is not equal to 2 to a computer when we type it, it must put out true, so type it in your console

The != stands for not equal to. The ! Stands for not

Now we check if 1 is not equal to 1 and the computer as expected gives false as output.

We now check if 2 is greater than 3, for greater than, we use > sign

We will now check if 2 is less than 3, for less than we use < sign

Cool! We found that if 2 is not greater than 3, then it’s less than 3. Well we are going to get a Nobel Prize for Math :)

The >= stands for greater than or equal to

Since 5 is greater than 3, it returns true

See the expression below, it still returns true because 5 is equal to 5

5 is not greater than 5 so it returns false below

3 is less than 5 hence the less than or equal to operator ⇐ returns true

3 is equal to 3 hence the less than or equal to operator still returns true

3 is not less than 3, its equal to 3, hence the less than operator returns false

You can also try these with numbers

And do they work? ;)

In the logic operator section you might see that irb gives true or false as output. You mustn’t confuse with “true” and “false”. The true and false are logical values whereas “true” and “false” are String.

The === operator is used to check if a particular instance ^[12] belongs to a class (i.e. type). For example “abc” is a String type object, 1 is a Integer, so lets apply === on them and check

As you can see from the above examples, we have the class name on the left and the instance on the right. The first two examples are true since “abc” is String and 1 is an Integer.

In the above example, it clearly returns false since 7 is no way a String, well that’s what you might think ;)

But there is something strange, look at the example below

So always have the class left side and instance on the right.

The if keyword is used to execute a statement if a condition is satisfied. Take a look at the program below. Execute it.

This is how the result would be if you give a name other than Zigor

Take a look at the program. Take a look at the following line

The program gets your name in variable called name. Now it checks if the name is Zigor in the code above (that is on the right side of the keyword if), if yes it executes the statement associated with it (that is the statement on the left side of keyword if), in this case it prints out that the particular name is genius. It then comes down to next statement

In this statement it checks if name is not Zigor, if yes it prints the name is idiot.

Lets write the who’s genius program in another form, here we use if else condition instead of if. Take a look at the code below named if_else.rb

The program when executed gives the same output as previous if.rb , what’s different is how the logic is represented inside the program. We see a thing called if name == "Zigor", then what has to be executed if the code is true comes after that as shown

Now we can put any number of statements after that if and all will be executed if the condition given is satisfied. Fine till now, but how will Ruby know where the if statement gets over? To say that things end here we put an end keyword as shown below.

Lets say that that condition(s) given in the if is not satisfied, and we need to do something if condition is invalid, then we put those statements that gets executed when conditions fails under the else keyword as shown

Note that the else and statements that needs to be executed when condition fails comes before the end statement. The end marks the end of if else block. It’s not always necessary to have else, instead we could have a code as shown

In the above you can put many lines of code that needs to be executed inside a if … end block.

When we use if and else, the code under if gets executed if the condition is satisfied, else the code under else section gets executed. Let’s have a new scenario where the code under if is not satisfied, then the program immediately jumps to the else section, now the logic demands that we need to check another condition at the else level too, what should we do? To deal with such a scenario we can use the elsif command. Take a look at the code below

When executed it produces the following result

Lets walkthru the code step by step. Let’s look at the line

In this line we assign values 3, 7 and 5 to variables a,b and c. Let’s now come to the if statement

In this statement we check if a is greater than b and if a is greater than c. Note the keyword and. The if condition is satisfied only if both conditions are true. a is less than b hence this condition fails so program skips the if statement and comes to the elsif statement

elsif is else plus if, here we check on another two conditions that’s separated by and, we check if b `is greater than `a and if b is greater than c, both are true and hence the statement under elsif

gets executed and we get the result. Since the elsif is satisfied other else and the code that comes under it is ignored.

There is another conditional construct with if, called the if then else, it’s not much different from if else, an example is shown below for theoretical purpose, personally it has not served any practical purpose for me, but for the sake of theory I am putting an example below, execute it and see for yourself.

Unless is another way to check a condition. Let say that one is a minor unless he or she is greater than 18 years old. So how to code it in Ruby? Consider the program below, type it in a text editor and execute it.

When executed this is what we get

The program asks your age, it says you are minor if age is not greater than 18. That is it says you are a minor if unless your age is greater than or equal to 18 as shown in this condition unless age >= 18. The p is a kind of short form for puts ^[13]. If you write puts “something”, the ruby interpreter prints something. If you use p ”something”, the ruby interpreter prints ”something” (that is with those quotes).

If we want to put more than a line of code under an unless block we can use unless …​. end block as shown below

The code in the block gets executed if the <condition> fails. unless can be thought as opposite of if. A if block gets executed if the condition in it is true, a unless block gets executed if the condition in it is false.

Just like if with else, we can have else in unless statement. Type in the program below and execute it

This is what you get when you execute it

OK, here is how it works, you get your age, convert it into integer in age = gets.to_i and store it in a variable called age. Concentrate on this piece of code:

unless the age is less than 18 “You are a minor” doesn’t get printed out. If the age is greater than or equal to 18 it gets routed to the else statement and “You are a grown up” gets printed. Note that if we use else with unless we must terminate the unless block with an end command.

Let’s now look at another program that uses unless else. We want to hire people for armed forces, the person should be between 18 and 35 years of age, our program asks the details from a person who wishes to enroll, it checks his age and tells the result. Type the program below and execute it

When executed this will be the result

I think you can explain this program on your own. If else contact me, I will write an explanation unless I am lazy.

Suppose you want to write a program that has a determined output for determined input, you can use the case when. Let’s say that we want to write a program that spells from 1 to 5, we can do it as shown in code/case_when.rb[case_when.rb], type the program in text editor and execute it.

Output

Let’s see how the above program works. First the user is prompted to enter a number, when he does enter a number, it gets converted from String to Integer in the following statement

The variable a now contains the value of number we have entered, we have the case statement as shown

In the above empty case statement we are going to write code that gets executed depending on the value of a. When a is 1 we need to spell out as “one” so we add the following code

Similarly, we add code till the case is 5 as shown

There could be a case when the human who runs this program could give a wrong input, so we need to deal with those cases too. For that we add a special statement called else, if all the when case fail, the code under else is executed, it must however be noted that it’s not mandatory to have an else between case … end block. So now the program changes as shown

Next all we must do is to print out spell which we do it in the following statements

Note that we print out only if spell contains a value, else if spell is nil nothing is printed. It is taken care by the if condition in statement above.

Sometimes it might be necessary that we need to execute same set of statements for many conditions. Let’s take a sample application in which the program determines a number from 1 to 10 (both inclusive) is odd or even. Type the code below (code/case_odd_even.rb[case_odd_even.rb]) and execute it

Output

Notice that in above program we assign a value 7 to a variable num, next we put the num in a case statement. When the number is 1, 3, 5, 7 and 9 we need to print its odd so all we do is to group the cases. When its satisfied it must print as odd, for that it’s just enough if you put it as shown in code below

Next all we need to print the number is even if its 2, 4, 6, 8 and 10, to do this task all we need to do is to add code that highlighted below

That’s it. The code will work fine for all numbers from 1 to 10. The moral of the story is we can easily group cases and execute a common code under it.

In Ruby everything is an object. Lets try out some example in irb to prove it

In the first statement, we have inquired about the class / object type of 1 and it says it’s of type Integer. When asked about class of “Zigor” it says String. In Ruby, you can use this function to know the type variables that you are using. It’s a pretty powerful feature.

Now take a look at the program below

Output

See the lines in the above program, we have two statements that like when String and when Integer, this checks the type of the variable a in case a statement. If the variable type is String it executes the statements under the when String thing, when it’s a Integer the other statement gets executed. Since this a is of type String we get a print-out Its a String.

Please check Ranges used in case .. when .

Case statements can match regular expressions too. Read Regular Expressions section to understand the example below.

Output

In the example above check the statement when /Ruby/, it checks whether the expression /Ruby/ appears in string. In above example it does appear. So it prints out string contains Ruby.

In case_odd_even.rb, when we tried to check if a number is odd or even, we gave a verbose program whose scope was limited from numbers from 1 to 10. We can write the same program as shown

Output

To understand the above example you must read Proc, Lambdas and Blocks first. Watch the code when → (n) { n % 2 == 0 }, in it, you are passing a lambda to the when, which when called would return true for n of value 76 or any even number, false if n is odd. Thus unlike previous odd and even program, this would work everywhere for all natural numbers from zero to infinite.

To understand the program below, you need to read === and case when, checking the class type. Type the program below and execute it

Output

Consider this section

The case statement checks name and sees if its instance of class type Zigor. Well isn’t that surprising? How could that be? How can one instance that belongs to String class become that of Zigor class? Well, what the case when does is this, it invokes === method in class Zigor, its definition could be seen below ^[14].

Here we define self.=== , where we take in an argument string , here the name passed to case gets copied to string, and it checks if the downcase of string is equal to “zigor” in string.downcase == "zigor" , if yes, it returns true, else false. If true the code in the when Zigor block gets executed and we get the output Nice to meet you Zigor!!! . Change name to other values and see what happens.

Don’t worry if you do not understand this section now. After completing this book revisit it, you might be in a better state to understand it.

The ? : is called ternary operator. It can be used as a simple if. Take the program shown below. Concentrate on max = a > b ? a : b

When executed the program gives the following output

Well the ?: works as follows. Its syntax is like this

You give an expression before the question mark. This expression must either return true or false. If the expression returns true it returns the stuff between ? and : , if false it returns the stuff after :

In the expression

We can substitute the values of a and b as follows

3 is not greater than 5, hence its false. Hence, the value after : is assigned to max. Hence, max becomes 5.

Wonder whether you noticed or not, in previous example max_of_nums.rb we have used a statement like this

Here a > b is logic, if its true it would return a which gets assigned to max or it returns b which gets assigned to max.

Now the same program can be written as follows

Output

Here the variable max is assigned to an if condition. So if a is greater than b it will put a into max else it will put b in max. As simple as that.

Now there is another stuff. What if there are more statements under if or else ? Since in this code block

There is only one statement under if block that is a, and under else block we just have b, so it’s straight forward. Now let’s try out the example given below

Run the above program and this is what you get

So what to infer? The rule is this, if you give many statements in a block and assign it to a variable, the output of the last statement will get returned and will be put into the variable ^[15] (max in this case).

Here is another program, a fork of case_when.rb, I guess you know how it works now

Run it and see it for yourself.

You can logically combine conditions using operators called && which is pronounced as and, and || which is pronounced as or. Let’s see few examples and hope you will get it.

Take a look at the program below. Type it and execute it.

Output

Now in the above program look at the line if age >= 18 && age ⇐ 30, you see the && operator. This && returns true, only if conditions on the both side of it is true. So in the above program the age is 21. So age >= 18 is true and age ⇐ 30, so true && true is true, so we get the output You can join the Army printed out.

Now instead of &&, we can also use and, and get the same output as shown below:

Output

But it’s said that && is more efficient than and. Right now it’s out of scope of this section to explain why. May be in future versions of this book I would try to explain it.

Similarly, if we want one of two conditions to be true, then we can use || operator which is pronounced as or. So in the program below, we are checking if the name is Zigor or R2D2. If it’s any one of them, then we conclude the name belongs to a robot, or we say it may not be a robot.

Output

Once again we can substitute || with or and get the same result as shown below, but it’s said that || is more efficient than or. May be in the future versions of this book it will be explained why.

Output

In your text editor type the following program

Run it and see. Well your program uses now a lot less code and yet it produces the same result!

Notice the thing 10.downto 1, this statement make Zigor count down from 10 to 1, while it count-downs you can do som thing with the countdown value, you can put some code in the loop block. The loop starts with a do and ends when it encounters a end command. Any code you put should be between the do and end block ^[17] as shown below

So between the do and end (technically it’s called a block) you can put the code to print the count-down number. First how to get the number? we will get it in a variable called num, so we rewrite the code as shown

Notice above that num is surrounded by | and |. All we need to do now is to print it, so we just print it as shown below

times is a very simple loop, if you want to get a code executed N number of times you put the code in it. Now let’s see what Zigor knows

Well, when executed the program prints the following

Zigor tells that it knows something seven times.

OK we have made changes in the program, we are printing the count variable this time, type the program below and execute

Here is what you get the result

Why it’s counting from zero to six rather than one to seven? Well, if all happens as you want, there will be no need of programmers like you and me, so don’t bother. Notice that in these programs we use { and } rather than do and end. Well, Ruby encourages different styles of programming.

upto counts some number upto some other number. Its like downto in reverse. Type in the program below and execute it

And here is how the output looks like

step loop can be thought as combination of upto and downto all packed in one, execute the code shown below

and here is the result. This is very similar to upto! Don’t you see!!

Now let’s modify the program as shown below and save it in another name

When executed this program produces no output. What have we done wrong? Modify the program as shown below and run it

Well here is the output of the program

What goes on in step? step receives three inputs, consider the code shown below

The first one is the number that calls step is taken as the initial number, in the above case it is 10. Next is the ending number in this case it is 1, that is this function counts from 10 to 1, we must descend in this case, so the count must be in steps of -1.

I can modify the same program to print even numbers in 10 to 1 as shown

This program prints the following output

Lets now try a program that will print even numbers from 1 to 10, this time in ascending order

Output

In the above code, have started from 2, we will end at 10, and we jump each loop by steps of 2. Inside the loop we simply print the iterating value which is captured in variable i.

While ^[18] loop is a loop that does something till a condition is satisfied. Read the code below

when executed, it produces the following output.

Let’s now see how a while loop works. A while loop normally has four important parts

Initialization

See the statement i=1, here we initialize a variable named i and set it to value 1.

Condition check

See the statement while i⇐10, in this statement we specify that we are starting a while loop, this while loop on every iteration checks the value of i, if it’s less than or equal to 10, the loops body gets blindly executed.

Loop body

Notice the do and end in the program, the do symbolizes the start of loop code block, the end symbolizes the end of loop code block. Between it, we have some statements about which we will discuss soon. One of the statement is to print the value of i, which is accomplished by print "#{i}, "

Updation

Let’s say that we forgot to include i+=1 in the loop body, at the end of each iteration the value of i will always remain 1 and i will always remain less than 10 hence, the loop will be executed infinite number of times and will print infinite 1’s. In practical terms your program will crash with possible undesirable consequence. To avoid this we must include an update statement. Here we have put i+=1 which increments i by value one every time an iteration continues, this ensures that i⇐10 to become false at some stage and hence the loops stops execution ^[19].

Hence we see that for a loop to work in an desirable manner we need to get these four parts into symphony.

while loop keeps going until a condition becomes false, until loop keeps going until a condition becomes true. Read the code below, type it in a text editor and execute it.

This is what you will get as result

So how this loop works? At first we do set i=1, then we use the until command and say that until i is greater than 10 keep doing something in this line until i>10 do. What should be done is said between the do and end keywords. So till the condition fails, the code in loops body will be executed, so we get 1 to 10 printed as output.

Suppose you want to break away from loop, that is to stop executing it, you can use the break command. An example is given below. In the example we will break if the iterating variable i becomes 6. So numbers ranging only from 1 to 5 gets printed. When i becomes 6 the loop breaks or terminates

When executed, the above program produces the following output

break, breaks out of loop and terminates it. next is somewhat different from break, instead of breaking from the loop, it’s a signal to continue the loop without executing statements that occurs after next. Here is an example for you to understand it:

Output

If you notice the output, you see that numbers from 0 to 9 are printed, but there is no 6. Notice the line next if num == 6 in next.rb here if num is 6, next is executed, in other words all lines after that in the do end block is skipped. Unlike brake, the loop is not terminated, but just the lines after next are skipped, and the loop continues on.

There is another thing called redo. next skips any execution further and the iterating variable is incremented / decremented to next possible value ^[20], redo on other hands skips further execution of code in the loop block, but the iterating variable is not incremented, instead the loop is rerun. Type the code below and execute it

Run it and hopefully you can explain it by yourself ;-)

So we have seen many types of loops till now, but I have left out a basic loop which is we call loop. Why I have left it out Because it’s dangerous to use ^[21]. Okay lets see an example. Type the program below and execute it. Note that you need to press Ctrl+C to stop it executing. So be cautious

The output will keep on printing I Love Ruby until u press Ctrl and C keys together to break. The basic is this: Anything put between loop do and end will keep on going.

So now lets say that we don’t want this loop to be continuously running forever. Let’s see how to tame it. Let’s print a program that prints from 1 to 10. Type the program below and run it.

Output

So the program prints from 1 to 10 as we wished. Let’s walk through it and see how it works. The first line i = 1, stores the value 1 in variable named i. Next we have this loop do line where anything put between this and end will run continuously.

In the next line puts i, we print the value of i and hence 1 gets printed, now in break if i == 10, it checks if i is 10, here the condition is false as i is not 10, hence the loop will continue to the next statement i = i + 1, we are adding 1 to i in i + 1 and hence its becomes 2 so by saying i = i + 1 we mean i = 1 + 1 hence i will become 2 and it (the program) meets the end statement, it does not mean end it just means iteration of loop ends so return to top (that is to loop do) once again.

So in loop do, now i is 2, so the thing goes on and on till i is 10 and in that case, in break if i == 10, i == 10 becomes true and the loop breaks.

Exercise: Try modifying the break_at_10.rb, when we have finished printing 10, the program must print "Mom I have finished printing 10"

Answer: telling_mom.rb

Exercise: These western guys don’t like 13, so write a program to print from 1 10 20, but omit 13. Answer: no_13.rb

Exercise: Explain if no_13_a.rb will work. If ya, how? If nay, why not? ^[22]

Let’s now look at an operator called flip flop. Let’s say that you are inside a loop that goes from 1 to 10, and you are capturing the number in a variable named i and printing it like this:

Now say that you want to start printing from 5 and end printing at 8. That is a mythical switch should flip and says let’s print when i reaches 5, and it must flop when i reaches 8. So you code for it like this:

Let’s execute the code:

Output

So let’s look at the statement if (i == 5) .. (i == 8), here the .. is called the flip flop operator. What it does is, it watches the left side condition that is if (i == 5), if yes it means that it flips to true and puts i gets executed, at the same time the flip flop watched for the richt side condition (i == 8), if that becomes true, it flops and becomes false, so even though the loops runs to 1 = 9 and eventually i = 10, the condition in if (i == 5) .. (i == 8) and hence puts i is unreachable, so nothing gets printed.

Now if we want to write a similar logic without flip flop it would be like this:

which is verbose.

Or if we use conditions, it would be bit confusing like this:

So flip flop is a great syntactic sugar which reduces the amount of code you write.

This section tells you the basic operations that you can do on an array of elements like search, delete, change and so on.

Lets now see some array functions. For this we will be using our favorite irb rather than a text editor

OK in the above statement we see that we create an Array named array using Array.new. Array.new creates an empty array. There is another way to create an array. We can create it by directly specifying the values that are contained in an array as shown

In the above statement, we create an array with three objects in it. The value that must be in an array is given between square brackets [ and ]. Each object in array is separated by a comma. By providing no values between [ and ] we can even create an empty array as shown

In the above example the empty [] does the same job as Array.new .

Lets create array with parameters in Array.new as shown

As you see above it fails! Don’t use it that way.

OK, let’s now try something on the array, first to get how many elements are in the array we can use the length function as shown below:

The join function joins many array elements together and returns it. So when elements in our array are joined this is what we get as result:

Note that we pass a string ', ' to the join when the array elements are joined as a string. The string we passed gets inserted into them in between.

We have created an array and we have something in it, what if we want to add something motr to it? To do so we use the push method. In the example below, we push a number 5 into the array and as we see the array gets expanded and 5 is appended to the array at the last.

The pop method does the opposite of push, it pops out or removes the last element of array. See the example below, we pop an element and the last element which is 5 gets popped out.

After popping it out lets see what’s in the array

We see that the array size has reduced by one and last element 5 is missing.

It’s not that you must only give a fixed value in push, you can give variables and Ruby expressions and any object to the push as argument. You can see below that we are pushing 2 raised to the power of 10 to the array and 1024 gets added to the array at the last.

Array elements are indexed. The first element of an array has an index number 0 and its goes on (theoretically till infinity). If one wants to access element at an index, all he needs to do is to put the index number in between square brackets. In the example below we access the third element of the array named array so we type it as follows

The pop method accepts a Integer as an argument which it uses to pop n last elements of the array.

As you see the third element gets popped out, so popping at random is possible.

We can push many elements into an array at once. Consider the code snippet below

We first push 3 new elements into the array, and so we get a bigger one.

Now we pop last 3 elements

As you can see the array size is reduced and it now only has two elements.

There is another way to append elements in an array, its by using the double less than operator <<, let’s push some elements into the array with it as shown:

as you see above we have appended a String constant “a new element” and 64 to the array using << operator.

You can find maximum and minimum values in an array using the max and min function as shown:

As you see in the above example we create an array called nums having some numbers, nums.max returns the maximum value in that array and nums.min returns the minimum value in that array.

Take a look at a simple snippet executed in irb, we have a nested array, let’s say that we want to access the string element “Treasure”, you can use the dig method as shown:

For those who know set theory you must know about intersections, unions. I read about set theory when in school and now have forgotten about it. You can treat array as set and do many operations on it. Here are a few examples which I tried out on irb.

Let’s take a college volleyball team, in it are some people names Ashok, Chavan, Karthik, Jesus and Budha. If you take a list of cricket team there are Budha, Karthik, Ragu and Ram. Lets now code it in ruby. To have a collection of people who play in volleyball team we create an array as shown:

Similarly, we create another array that contains names of those who play in cricket team as shown:

So we have two sets of people. Now to find out who are in volley ball and cricket, all we need to do is to AND (or take intersection of) both arrays using the & operator as shown:

As you see from above code snippet, the & (and) operator sniffs out those elements that are there in both arrays. In mathematics this stuff is called intersection.

Lets say in another situation we would like to find out all those who are both in volleyball and cricket team. To do so we use the or operator |. Let’s now apply it

As you see we get names of those who are in volleyball and cricket team. The | (or) operator is different from the + (plus) operator. Let’s add volleyball and cricket teams

As you can see from above code snippet the names Karthik and Budha are duplicated. This does not happen when we use the | (OR) operator.

Let’s now find that which players play only for the volleyball team. For this we will minus the players of cricket from the volleyball team using the – (minus) operator as shown

So we see three players are exclusively in volleyball team. So if you are a mathematician you will feel somewhat comfortable with Ruby.

There is another stuff that must be known by a Ruby dev. It’s regarding conditions and empty array. Fire up your irb and type these

If you see, the statement prints A even if the array passed to the if statement is empty. This is kinda against theory of least surprise, but not to get surprised imagine this. There is a book rack, and there are books in it so if you give a statement like this

It does print Books Present as expected. But in this thing

It still prints Books Present. Thats because even though the book rack is empty, there is a rack which is still an object. So there is some thing thats not nil. So its true. To make sure this is how it works take a look at the code below

When we query what’s the class of nil, it says it’s NilClass which is actually an empty thing. But when we query the class of an empty array it’s still an Array, which is not nil or false and hence its true. To check for empty array that must do as shown:

In the first one [].empty? returns true, but since it’s in unless it would fail to execute the statement dependent on it.

If you see the second one we use [].first, this returns nil. Try it in irb

So this could also be used to check emptiness of an array. Or is it so…​.. ?

Now think about whether to use first to check emptiness?

Sometimes an array would contain nil values, and you want to remove it, in that case you can call compact upon that array. Let’s try out an example. Start your irb or pry and type the following

First lets initialize the array

So in the above statement we have initialized the array with three nil values in it. Now let’s remove the nil values by compacting it as shown below

Cool! So ruby has removed nil values like magic. Now let’s' see how a looks

To our dismay a still retains the nil values, what really happened? Well, when you called compact on a, a new compacted array was created, and it was returned to our REPL ^[24], and out REPL printed it. So what to do to make a really change? Simple call compact with a bang or compact! on a as shown below ;)

Ruby comes with very powerful array operations, we would see how we can transform arrays in easy to use commands.

Definitely this book isn’t comprehensive enough to cover all of Ruby Array library. To know more read the Ruby docs here https://ruby-doc.org/core-3.0.3/Array.html

When we pass the index to an hash and if its value does exist, then the hash will faithfully return that value. What if the index has no value defined. In the previous example we saw the program returns nothing. In this program we hope to fix it. Look at this code mark = Hash.new 0. In it instead of just giving mark = Hash.new as in the previous one, we have given mark = Hash.new 0, here the zero is the default value. Now let’s run the program and see what happens.

Output

Look at the output, we haven’t defined a value for mark['Chemistry'], yet when the subject name is specified as Chemistry we get 0 as result. This is so because we have set zero as the default value. So by setting default value we will have a value for those indexes we haven’t defined yet.

Looping in arrays is quite easy, we normally use each function in array to iterate objects in array. In similar fashion we can loop in hashes. Type the following code hash_looping.rb into a text editor and execute it.

Output

In the program above we have calculated the total of all marks stored in the Hash mark. Note how we use the each loop. Note that we get the key value pair by using |key,value| in the loop body. The key holds the index of the hash and value holds the value stored at that particular index^[25]. Each time the loop is executed, we add value to total, so at the end the variable total has got the total of the values stored in the hash. At last, we print out the total.

Below is another program where we store student marks in a hash, we use the each loop to print the key and value corresponding to the key. Hope you have understood enough to explain the code below all by your self.

Output

There is another way to create hashes, lets look at it. See below, the explanation of the program is same like the of previous program hash_looping_1.rb, except for the highlighted line in the program below. I hope you can explain the programs working by yourself.

Output

Usually in a hash we use Symbols as keys instead of String. This is because Symbol occupies far less amount of space compared to String. The difference in speed and space requirement may not be evident to you now, but if you are writing a program that creates thousands of hashes it may take a toll. So try to use Symbols instead of String.

So what is symbol? Let’s fire up our irb by typing irb --simple-prompt in terminal. In it type the following

Notice that we have placed a colon before x thus making it :x. Symbols have a colon at their start. When we ask what class is :x, it says it’s a Symbol. A symbol is a thing or object that can be used as a key in a hash ^[26]. In similar way we declare another symbol called :name and see what class it belongs.

A variable can hold a symbol in it. Notice below that we have assigned a variable a with value :apple which is nothing but a symbol. When we ask what class it is a by using a.class , it says it’s a symbol.

Symbols can be converted to string using the to_s method. Look at the irb example below where we convert symbol to string.

To convert a String to Symbol use .to_sym method as shown

Let us write a program in which hashes don’t use String but Symbols as key. Type in the program (below) hash_symbol.rb into text editor and execute it.

Output

When the program is run, it prompts for subject name, when its entered it shows corresponding mark. Lets walk through the code and see how it works. Notice that we use Symbols and not Strings as keys in mark Hash as shown

Next we prompt the user to enter marks by using print "Enter subject name:" , the user enters the subject name. Now look at the next line, first we get the subject name into variable sub using gets.chop. The chop removes the enter character \n you typed while pressing the enter key in your keyboard. The to_sym converts what ever input you have entered to a symbol, all this is finally stored in sub.

All we do next is to access the hash value which has the key sub and print it using the following statement

So you have seen this program hash_creation_1.rb , we have now knowledge of symbols, so we can write it as follows in

Output

See the line marks = { :English ⇒ 50, :Math ⇒ 70, :Science ⇒ 75 } we here use symbols instead of strings as a key to hash. Hash has some advantages compared to string as they occupy less memory compared to string (during the runtime of a program).

In ruby 1.9 and beyond there is a better way to write hash_creation_1_a.rb, you can see it in hash_creation_2.rb mentioned below. Just look at this marks = { English: 50, Math: 70, Science: 75 } line in program below

This program works exactly as the previous one, but the line marks = { English: 50, Math: 70, Science: 75 } gets translated (assume that its been translated) to the following code marks = { :English ⇒ 50, :Math ⇒ 70, :Science ⇒ 75 } so it’s the new short form way to declare hash with symbols as key, newly introduced in ruby 1.9

Strings occupy a lot of memory lets see an example, fire up your irb and type the following code:

In the above example we see two variables c and d, both are assigned to the same string "able was i ere i saw elba", but if I see the object id’s by calling on c.object_id and d.object_id, both are different. This means that the two "able was i ere i saw elba" are stored in different location’s. They are duplicated and copied.

This means that lets say you have the same string declared many locations in your program, and all will occupy new memory, so that would cause lot of load on your computer RAM (for large programs).

Now let’s see what will happen if we use a new kind of thing called frozen string. Type the code below in irb:

Now in the above example we call a method called freeze upon the string. Now when I check a and `b’s object id, both are the same. That means they both point to the same string. They just occupy one space. This is like this. In the previous example new stuff was created every time, but when we assign a variable with a frozen string, it checks whether the string has already been (frozen) declared, if yes, it simply points to the same location.

Now let’s see about how symbols occupy space, whether they duplicate themselves again and again or not.

So in the example above we assign e and f to symbols :some_symbol and when we check for their object id they both are the same, or they both point to the same location. This means if we declare symbols again and again, they won’t occupy extra space. Frozen strings and symbols are good for memory. Ordinary strings are bad.

So why am I saying this in hash section? Let’s say you see this snippet of code:

Just imagine which will occupy the lowest amount of memory? Now think about large programs that uses the same structure of hash in tens of lines of code….

Just like Arrays can be compacted, this new feature is introduced to Hashes from Ruby 2.4.0 lets the programmer compact it. Let’s look at an example in irb or pry:

The explanation is very similar to that explained for Array compaction. Please refer it.

Let’s say that you have a Hash object and you want to transform its values. Say you have a hash who values are numbers, and you want to convert it into their squares, then use the transform_values function on that instance of Hash. Let’s take code and see how it works. Fire up your irb or pry

Let’s first define a hash as shown below

Now we went to transform the values, so we call the transform_values on the hash as shown:

If you notice, it functions very similar to collect in Array, but it applies to values in a Hash.

Now let’s see if hash has changed:

The answer is no as you can see from the code snippet above. If you want the Hash instance upon which the transform_values is called to be changed, then call it with a bang as shown below. It will change the Hash object that’s calling it.

It’s possible to create hash from a bunch of variables in Ruby as shown:

In the above example we are not doing something like this:

Instead we are specifying it as a short form like this:

In both cases we get an array were c is {:a⇒1, :b⇒2}. Reduction in typing means reduction in errors and increased productivity.

Once again, this book can’t explain everything that’s in hash. To know more refer rubydocs for hashes here https://ruby-doc.org/core-3.1.1/Hash.html

Look at the program below (ranges_case_when.rb), we are building a student grading system in which when a mark is entered the program puts out the grade of the student, study the code, type it and execute it, we will soon see how it works.

Output

At first the program prints that the software is student grading system and asks the user to enter the student mark. When the mark is entered it’s got using gets statement, the trailing newline character is chopped using the chop method, and it’s converted to integer using the to_i method and the mark is stored in the variable mark. All of it is done using this mark = gets.chop.to_i statement.

Once we have the mark, we need to compare it with a range of values to determine the grade which is done using the following statements:

Here we see that mark is passed to the case statement. In the when we don’t have a number or string to compare the mark, in fact we have ranges. When the mark lies from 80 to 100 (both inclusive) the grade is set to A, when its lies in 60 to 79 its set to B, C for 40 to 59 and D for 0 to 39. If the user enters something wrong, grade will be set to "Unable to determine grade. Try again.".

So as we can see ranges come very handy when they are used with case when statement. It makes programming relatively simple when compared to other languages.

Another use of Ranges is to check if anything is located in a particular interval. Consider the program (ranges_cap_or_small.rb) below

Output

Read it carefully and execute it. In the above case I have entered capital R and hence the program says I have entered a upper case letter. If I had entered a lower case letter, the program would have said I had entered a lower case letter. Lets see how the program works. The following lines:

prompts the user to enter a letter, when the user enters a letter the gets method gets it, chop chops off the new line character thats added due to the enter key we press. In the next line look at the if ('a'..'z') === letter , here we check if the value in variable letter lies with 'a' and 'z' (both inclusive) , if it does, we print that user has entered small letter. Note that we don’t use double equal to == `but we use triple equal to `===`[27] to check if its in range. In a similar way `('A'..'Z') === letter returns true if letter has capital letter in it and the program prints the user has entered a capital letter.

Another thing in Range I would like to add is using triple dots instead of using double dots. Just try these out on your irb.

See from above code snippet when I type (1..5).to_a we get an array output as [1, 2, 3, 4, 5] , but for (1…​5).to_a we get output as [1, 2, 3, 4] . The triple dots ignores the last value in range.

Ruby has endless ranges, that is you can write programs like this

Running the program produces the following output

In the above execution I have given my age as 32, and hence it comes to this part of the code

In it look at the (19..), here it means 19 and any value above it. Note that we aren’t specifying when 19.. as this would confuse the Ruby interpreter and would throw out an error.

Now let’s see about ranges that are beginless, for it fire your irb. Say if you want to check if a number is less than 10, you can do it as follows:

Just notice how we check a number that is 4 in the above case is in range ..10, where the range has no beginning.

Now let’s try it for 11 and we see 11 is not in ..10:

We can also see that 11 is in an endless range that starts with 10 as shown:

In the below example we are seeing if minus 5 is in begin less range that ends in 10, and it’s true.

Try out the program below so that you can understand about beginless and endless ranges:

Lets get more control on the functions in this section. Sometimes you don’t go to a hotel and order a single dish, you can order how much ever or how less you want. If you go with friends you can order more servings, if you are alone, you will order less. Why can’t we do the same thing with print_line function? Why can’t we vary its length, doing so will be a wonderful thing, we can print lines of length what ever we choose.

Take a look at code below, we have typed a thing called length after the function name, its called as argument. Like a function, an argument has a name, in this case we have named it length. We can pass any values to it to vary the length of the line printed. Type the code below and execute it

You will get a design pattern as shown below

Take a look at the following code

We have used step loop to increment or decrement the value which we capture it into a variable called x which is inside the loop, we pass x to the print_line function by placing it after its call as highlighted above. So each time a line of varying length (determined by x) gets printed. The program is constructed in a way so that a pattern is generated.

In function_1.rb you have seen how to pass an argument to a function. What if suppose you fail to pass an argument? If you do so, an error will be generated which a good programmer will not desire that to happen. To prevent this and to make programming a bit easy it’s better to provide a default argument to a function. Note the code given below in function_default_argument.rb

Execute the program and observe the result

You can see in the program, in function print_line by giving length = 20 we have indicated that if no argument is passed the function must assume that value of length is 20. If passed this value will be overridden with what ever value you pass. As you can see in the first function call, we simply call the function just by its name print_line, we don’t bother to pass value for length to it, yet we see a line of length 20 units gets printed in the output.

Usually when you pass a variable to a function, a copy of the variable is made. And if you make changes to the variable, the one that’s outside the function is unaffected. So lets see what happens when we pass array to function. Type in the program below and run it.

Output

If you are newcomer to programming, this might not be surprising, but when a variable is passed to a function, its value is not supposed to change. But in case of array, inside the function array_changer, we are adding an element to it, and it changes. Well this is a peculiar behavior of an array getting passed to a function.

To avoid such behavior try the program below

Output

Here the array does not get changed, look at the line array_changer Marshal.load(Marshal.dump(some_array)), this piece of code copies some_array to the function argument so that even when its changed inside the function, it does not get changed outside the function.

We have till now seen function taking in arguments, we will now see that the function can return values which can be used for some purpose. Let’s now see the program function_return.rb, study the code, type it and execute it.

Output

The output you get out after executing is 8. Note the method named addition in the above program. It accepts two arguments x and y, inside the method we declare a variable called sum which is assigned to the addition of x with y. The next statement is the hero here, see that we have used a keyword return, this returns the value out of the function. In the above program we return out the sum and hence when we get the answer out.

It’s not that we must use return statement to return a value. The last statement that gets executed in a Ruby function gets returned by default. Consider the program function_last_gets_returned.rb that’s shown below. In it, we have a method called square_it which accepts a single argument called x. It has a single statement x**2 which happens to be the last statement as well.

Type the program and execute it.

As you see we have called square_it 5 and we get 25 as the result. It’s possible because in Ruby the result of last executed statement gets returned by default.

To understand Keyword argument, type the program below and execute it:

Output

So, to see how this feature work, let’s analyze the code. Look at the function definition of say_hello, it’s as shown below

Look at the highlighted part def say_hello name: "Martin", age: 33. Here we don’t specify arguments as def say_hello name= "Martin", age= 33 rather we use special name: “Martin”, we have taken out the equal to sign and replaced with colon. So what’s the use? Now take at look at the part where the function is called

The first line is straight forward say_hello name: "Joseph", age: 7, here the first argument is name and second argument is age. But look at the code say_hello age: 21, name: "Vignesh", here the first argument is age and second one is name. But since the argument is hinted by the keyword, its position is irrelevant and the method prints a string as we expect.

The third line say_hello is just to show what happens if arguments are missed, since we have specified default values, it takes the default ones. Is it possible to use keyword arguments with default values? Absolutely yes. Try the program below and see for yourself

Let’s see another math thing. You might be wondering why am I doing all math? Certain programmers do write books that keeps out as much math as possible, I am not a professional mathematician, but I admire math. Computers are based on math. All computers use a thing called Boolean algebra to do all tasks. I wouldn’t say that you must be a mathematician to be a programmer, but knowing math does help.

OK what is a factorial? Take a number, let’s take 3, now what will be 3 X 2 X 1, that will be six! Simple, isn’t it? 6 is factorial of 3. Well we will take 4 now, so 4 X 3 X 2 X 1 will be 24, in similar way factorial of 2 will be 2 X 1 which is 2. Having equipped with this knowledge we will now construct a program that will give us factorial of a number.

Study the program given below. Concentrate on the function named factorial