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

# *Asking for information*

Remember how we initially said that people have the ability to remember their
name, and tell it, when asked?

We've already implemented the first part of this. Our person instance now
knows her name "Ada".

Let's look at the second part. You also remember that ***methods are either
questions or commands***. We want to add a method that implements answering
the question "What's your name?".

And it is as simple as this:





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

  def name
    @name
  end
end

Before we discuss what this does, let's look at how we can use our new method.
We can now call the method on the person object, like this:





person = Person.new("Ada")
puts person.name

So this prints the name `Ada`, and that's what we want: we can create a new
person object, passing a name to it. Once that person has been created we are
able to ask for its name, and we'll get the name back.

How does this work, exactly, under the microscope?

# Explanation
Let's walk through it, step by step:

* On the first line, the object that ends up being assigned to the variable
  `person` is an initialized, new instance of the class `Person`. By
  "intialized" we mean that the method `initialize` has already been called,
  and it already has assigned the string `"Ada"` to the instance variable
  `@name`.

* Now this person object has the method `name`, as defined in the class
  definition of `Person` above, and in the second line we call this method:
  `person.name`.

* When the method `name` is called, it does nothing else but evaluate the
  instance variable `@name` from the object scope. Because this has previously
  been set to `"Ada"` it will return this string. And because this is the last
  line in the method `name` the method also will return this string.

* For that reason the method call `person.name` returns the string `"Ada"`,
  which is then passed to `puts`, which prints it out.

# So, what are attribute readers?
Methods that do nothing else but return a value assigned to an instance
variable with the same name are very common.

In fact they are so common that there's a word for them: they are called
"attribute readers". **By "attribute"** the Ruby community means an instance
variable, so an attribute reader is a method that reads an instance variable.


><span>💡</span>
> 
>An attribute reader returns the value of an instance variable.


Another way of looking at this is that an attribute reader is a method that
"exposes" an instance variable. It makes it accessible for others. I.e. it
allows you to ask for the value of an instance variable with the same name, and
does nothing but return its value. Once defined others can ask this object for
knowledge that otherwise would be private, and inaccessible.

In our case the attribute reader `name` exposes the instance variable `@name`,
so others can ask for it.

><span>💡</span>
> 
>An attribute reader exposes an instance variable.

We don't know why the community has chosen to use the term "attribute" here:
It would be much less confusing to use the term _"instance variable reader"_
instead. Maybe the simple reason is that programmers don't like to type more
than necessary, and this saves 8 characters. Who knows :)


This lesson explains the attribute readers and how they are related to instance variables.

Attribute Readers

Asking for information