rubytarball.tar.gz

Do you want to be an interpreted language geek? Are you tired of getting entangled in the dense syntaxes? Does it irritate you to compile your code to machine language first? Are you looking for an easy-to-use scripting language? Well, Ruby is the best pick for you then!

Ruby is a smart, easy-to-use, functional, Object-Oriented programming language, which comes as a wondrous mix of Perl's scripting power, Pythonic capabilities and much more! As Matsumoto, creator of Ruby, implies: "I hope to see Ruby help every programmer in the world to be productive, and to enjoy programming, and to be happy. That is the primary purpose of Ruby language."

This introductory course will be providing you with hands-on practice with the support of a bunch of interactive illustrations, exercises and the integral topics of variables, built-in classes, objects, conditionals, blocks and much more!

Cool, right? Ready to dive into one of the most influential and demanding third generation programming language? Let's tune in!

Ruby: An Amateur's Pitch


# *Once defined we can use our method*
As programmers we usually say that we "call" a method. This means we ask Ruby
to execute the code that the method body has, with some given arguments
(input), if any.

Here's how that looks:



def add_two(number)
  number + 2
end

puts add_two(3)

# Explanation
Let's inspect what's happening here under the microscope. If you don't
understand each part of this just yet, don't worry, we'll get back to all of
this.

On the first three lines Ruby defines the method `add_two` as discussed above.

* On the next line Ruby will look at the bit `add_two(3)` first. She recognizes
  that we are referring to a method defined earlier, and this will tell her we
  want to call (execute, use) this method.
* In order to do so she first needs to look at what's inside the parantheses
  `()` so she can pass it on. She finds the `3` and creates a new object
  (number) for it.
* Now Ruby is ready to actually call (execute, use) the method, passing the
  number `3`.

So Ruby now deviates from the normal flow, which just goes from top to bottom
in our file. Instead she now jumps into the method body.

At this moment she now *assigns* the number `3` to a local variable `number`
before she starts executing the method body. 

That's right. This is how method *arguments* work:

>When a method is called and objects are passed as arguments, then Ruby
implicitly defines local variables with the argument names. She assigns the
passed objects to the variable names that are in the argument list. These local
variables are then available in the method body.

In our case, we have just one argument `number`. So we get one local variable
`number` with the object `3` assigned (because that's the object passed when we
called the method).

You can imagine the method body now reads like this:



This lesson will brief you on how to use methods in Ruby after defining them.

Usage

Once defined we can use our method

Explanation