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

# *An object's own knowledge*

Now that you understand how the string that we pass to the method `new`
ends up being passed to the new object's `initialize` method, we can start
improving `initialize`, so it does something with the string, and actually
*initializes* our new object:





class Person
  def initialize(name)
    @name = name
  end
end



This introduces another new concept: `@name` is a new type of variable, called
an **"instance variable"**.

# Assigning Local Variable to an Instance Variable
The body of the `initialize` method now does nothing else but assign the value
of the local variable `name` to an instance variable `@name`.

## Local Scope
You remember how we said that each method has its own local scope, which is
created when the method is called, and populated with local variables from the
arguments list. You have also learned that this scope is erased, and thrown
away when Ruby exits the method body and returns from the method. And that:
> Local variables that are visible in one method are not visible in other
methods: that's why they are called local.

## Discovering an Object's Scope
Now, the thing is: Every *object* also has its own scope.

An object's scope is populated with instance variables, in the moment we assign
something to them. And they are visible *everywhere* in the object, that is, in
every method that the object has.


><span>💡</span>
> 
>Instance variables live in, and are visible everywhere in the object's scope.

You can think of the object's scope as your own knowledge, or memories.

## Example
For example, you know your name, your email address, and your email password.
You keep this knowledge around, and you can use it when you do things (such as
responding to another person). Likewise, an object keeps its instance variables
around, as long as the object exists.

Ok, let's see how that works in practice.

If you create and output an instance of our class `Person`, you'll see that
Ruby now prints out the instance variable, too:





A detailed description of instance variables and how they work in Ruby.

Instance Variables

An object’s own knowledge