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

Now is a good time to talk about the concepts of nothingness and truth in Ruby.

## Nil

We have briefly mentioned that in Ruby there is an object that represents
"nothing": the object `nil`.

That's right. "Nothing" is a thing in Ruby (as well as in many other
languages), albeit a very special one. We could ramble on the philosophical
implications of this, but instead we'll just look at how this is used in
practice:

Remember how we can receive a value associated with a key from a hash?


dictionary = { :one => "eins", :two => "zwei", :three => "drei" }
p dictionary[:one]



This will print out `"eins"`. However, what happens if we try to receive
the value for a key that has not been defined on the hash?


dictionary = { :one => "eins", :two => "zwei", :three => "drei" }
p dictionary[:four]

This will print out `nil`. Remember that every method call always will return
*some* value? In cases where there's nothing to return, it will return `nil`,
which represents nothing :)

In Ruby, `nil`, nothing, is something else than, for example, `0`, which
represents *something*. An empty string `""`, an empty array `[]`, or empty
Hash `{}` also all represent *something*. So they're not `nil`.


## True and False

We have also discussed that in order to represent truth, and the opposite of
it, Ruby also knows the values `true` and `false`.

You have seen them when we tried some of the methods on numbers, strings and
arrays, like `3.odd?`, `"a string".start_with?("a")`, or `[1, 2, 3].include?(2)`.

These so-called predicate methods always return either `true` or `false`. 


>💡
>
>Predicate methods end with a question mark, and return <code>true</code> or
<code>false</code>.

### They are Classes!
The objects `nil`, `true`, and `false` also have classes, and you can check
that in IRB yourself: `nil.class`, `true.class` and `false.class`.

For a reason that we don't know **Matz** (the creator of Ruby) has decided to call
these classes `NilClass`, `TrueClass` and `FalseClass`, instead of just `Nil`,
`True` and `False`. If you ever meet him at a conference you can ask him :)

$$$$
## Truthiness and Falsiness

Now, when we talked about `if` statements we used methods that actually return
`true` and `false` values, like the `odd?` method on numbers does. Comparison
operators like `==`, `<` and `>` also return `true` and `false`, as in:

Now is a good time to talk about the concepts of nothingness and truth in Ruby.

# Nil

We have briefly mentioned that in Ruby there is an object that represents
"nothing": the object `nil`.

That's right. "Nothing" is a thing in Ruby (as well as in many other
languages), albeit a very special one. We could ramble on the philosophical
implications of this, but instead we'll just look at how this is used in
practice:

Remember how we can receive a value associated with a key from a hash?


This will print out `nil`. Remember that every method call always will return
*some* value? In cases where there's nothing to return, it will return `nil`,
which represents nothing :)

In Ruby, `nil`, nothing, is something else than, for example, `0`, which
represents *something*. An empty string `""`, an empty array `[]`, or empty
Hash `{}` also all represent *something*. So they're not `nil`.


# True and False

We have also discussed that in order to represent truth, and the opposite of
it, Ruby also knows the values `true` and `false`.

You have seen them when we tried some of the methods on numbers, strings and
arrays, like `3.odd?`, `"a string".start_with?("a")`, or `[1, 2, 3].include?(2)`.

These so-called predicate methods always return either `true` or `false`. 


>💡
>
>Predicate methods end with a question mark, and return <code>true</code> or
<code>false</code>.

## They are Classes!
The objects `nil`, `true`, and `false` also have classes, and you can check
that in IRB yourself: `nil.class`, `true.class` and `false.class`.

For a reason that we don't know **Matz** (the creator of Ruby) has decided to call
these classes `NilClass`, `TrueClass` and `FalseClass`, instead of just `Nil`,
`True` and `False`. If you ever meet him at a conference you can ask him :)

$$$$
# Truthiness and Falsiness

Now, when we talked about `if` statements we used methods that actually return
`true` and `false` values, like the `odd?` method on numbers does. Comparison
operators like `==`, `<` and `>` also return `true` and `false`, as in:

This will print out `nil`. Remember that every method call always will return
*some* value? In cases where there's nothing to return, it will return `nil`,
which represents nothing :)

In Ruby, `nil`, nothing, is something else than, for example, `0`, which
represents *something*. An empty string `""`, an empty array `[]`, or empty
Hash `{}` also all represent *something*. So they're not `nil`.


# True and False

We have also discussed that in order to represent truth, and the opposite of
it, Ruby also knows the values `true` and `false`.

You have seen them when we tried some of the methods on numbers, strings and
arrays, like `3.odd?`, `"a string".start_with?("a")`, or `[1, 2, 3].include?(2)`.

These so-called predicate methods always return either `true` or `false`. 


>💡
>
>Predicate methods end with a question mark, and return <code>true</code> or
<code>false</code>.

## They are Classes!
The objects `nil`, `true`, and `false` also have classes, and you can check
that in IRB yourself: `nil.class`, `true.class` and `false.class`.

For a reason that we don't know **Matz** (the creator of Ruby) has decided to call
these classes `NilClass`, `TrueClass` and `FalseClass`, instead of just `Nil`,
`True` and `False`. If you ever meet him at a conference you can ask him :)

$$$$
# Truthiness and Falsiness

Now, when we talked about `if` statements we used methods that actually return
`true` and `false` values, like the `odd?` method on numbers does. Comparison
operators like `==`, `<` and `>` also return `true` and `false`, as in:

An introduction to Nil, True and False objects.

Nothingness and the Truth

Nil

True and