Ruby — An introduction

Ruby
An introduction to the Ruby programming language

LPOO — MIEIC — FEUP

May 2011

Ruby
Created by Yukihiru “Matz” Matsumoto, in Japan
Perl + SmallTalk + Eiﬀel + Ada + Lisp = Ruby

“I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python.” — matz

Ruby
Interpreted language, with many implementations: YARV , Rubinius , JRuby , etc

Functional, object-oriented, imperative and reﬂective

Dynamically typed, with automatic garbage collection, exception handling and
built-in unit testing

Optimized for programmer productivity and happiness

Methods

def hello_world()
return "Hello world!"
end

hello_world()

Methods

def hello_world # no need for ()
"Hello world!" # implicit return
end

hello_world # no need for ()

Classes

class HelloWorld
def say
"Hello world done right!"
end
end

hello_world_object = HelloWorld.new
hello_world_object.say

It's object-oriented

class Lecture
def initialize(name = "TBA", duration_in_minutes = 60)
@name = name
@duration = duration_in_minutes/60.0;
end

def description
"Name: #{@name}nDuration: #{@duration} hours"
end
end

lecture = Lecture.new("Ruby", 45)
lecture.description

It's really object-oriented

// Java
maximum = Math.max(1, 3)

# Ruby
maximum = [1, 3].max


# Python
positive = abs(num)

# Ruby
positive = num.abs


// C
length = strlen(name)

# Ruby
length = name.length

In Ruby, all functions and most operators are methods of an object

In Python, for instance, some functions are procedural
Classes themselves are instances of Class

Ruby has a permanent notion of the current object : self

self controls how Ruby accesses instance variables

All method calls are made on some object, called the receiver

If no receiver is speciﬁed, self is used — it is implicit!


# self is "main", an instance of Object
class MyClass
# self is MyClass

def my_method
# self will depend on the receiver for this method
end
end

# self is "main" again, so my_object exists in the main scope
my_object = MyClass.new

# explicit receiver, so self will be my_object inside my_method
my_object.my_method

Arrays
Store indexed collections of objects accessible through an integer key

Can contain objects with diﬀerent classes simultaneously

# array
a = [1, "second", 3.14]
a[2]

Hashes
Store indexed collections of objects accessible through a key which can be any
object

Slightly less eﬃcient but much more ﬂexible

# hash
h = {
"string" => [3,4,5],
2 => "everything can be a value!",
[1,2] => "everything can be a key!"
}
h[[1,2]]

Symbols
A signiﬁcant name, generally a static variable

// java
static final int NORTH = 1;
// ... more code
move(NORTH);

# ruby
move(:north)

No need to predeclare these constants, they are unique

return true if direction == :north

Control Structures

# if
if score.between?(100, 199)
puts "You rock!"
elsif score < 50
puts "You suck!"
else
puts "Meh"
end

# while
while score < 100
puts "You're almost there! Try again..."
# ...
end

# more goodness with unless, until, case, for, etc

# and awesome shortcuts like statement modifiers
puts "You cheated!" if score >= 200

Blocks
A chuck of code enclosed between { } or do/end keywords
Similar to the concept of anonymous methods

Can take parameters

Can be passed to methods as arguments (at the end, like an extra parameter)

sum = 0
(1..5).each do |n| # same as [1,2,3,4,5]
sum += n
end
sum

# same thing with { }
sum = 0
(1..5).each { |n| sum += n }
sum

Blocks as Objects
Can be converted into objects
Can be stored in variables, pass them around, invoke them whenever you want

Great for implementing callbacks, dispatch tables, etc

class BlockAsObject
def store_block(&my_block)
@stored_block = my_block # converted to Proc
end

def use_block(parameter)
@stored_block.call(parameter)
end
end

foo = BlockAsObject.new
foo.store_block { |param| "The block was called with " + param }
foo.use_block("delay")

Blocks as Closures
They can use local variables from the surrounding scope

def powers_of_2_proc
value = 1
lambda { value += value }
end

powers_of_2 = powers_of_2_proc

powers_of_2.call # 2
powers_of_2.call # 4
powers_of_2.call # will return 8!

So, powers_of_2_proc returns a Proc that references value
When the block is called, value is out of scope

The block is still able to access it (and will be for the remaining life of this block)

Iterators
In many languages, collections implement methods to generate external iterator
objects

// C++
for (std::vector<int>::iterator i=list.begin(); i!=list.end(); i++) {
// code
}

Iterators
objects

// C#
IEnumerator<int> i = list.GetEnumerator();
while (i.MoveNext()) {
// code
}

Iterators
objects

// Java
Iterator i = list.iterator();
while (i.hasNext()) {
// code
}

Iterators
When coming from other languages, many people iterate collections like this:

# familiar?
for i in 0..2
number = array[i][0]
word = array[i][1]

puts "#{word}: #{number}"
end

Iterators
However, there's another approach:

# the "ruby way", with a lot less coupling
array.each do |word, number|
puts "#{word}: #{number}"
end

The “Ruby way” is diﬀerent: an iterator is internal to the collection... it's just a
method that calls yield every time it generates a new value

Iterators
Ruby provides a lot of useful iterators: each, map , inject , etc

But you can build your own

def fib(max)
i1, i2 = 1, 1 # parallel assignment
while i1 <= max
yield i1
i1, i2 = i2, i1+i2
end
end

result = ""
fib(1337) { |n| result += "#{n} " }
result

Iterators
Ruby's internal iterators aren't necessarily the best solution
What if you need the iterator to be an object?

What if you want to iterate multiple collections simultaneously?

Enumerators
When iterators aren't suitable, you can resort to enumerators
To put it simply, an enumerator is an external iterator

array = ["my", 1337, "array"]
enumerator = array.to_enum # same as "enumerator = array.each"

enumerator.next # returns "my" and moves to the next element
enumerator.next

Enumerators
Most internal iterators are can be used as enumerators

string = "le fu"
enumerator = string.each_char

enumerator.next # returns "l" and moves to the next char
enumerator.next # returns "e" and moves to the next char

Containers, containers, containers!
Blocks and iterators are core concepts of Ruby

With practice, you'll start building classes that iterate over their contents instead
of using the conventional looping constructs

It might seem complicated at ﬁrst, but you'll start using these features naturally

Easy to read and maintain

Inheritance

class SuperClass
def hello_world
"Hello world!"
end
end

class SubClass < SuperClass
end

superclass = SuperClass.new
subclass = SubClass.new

"Hello world from the superclass: #{superclass.hello_world}n" +
"Hello world from the subclass : #{subclass.hello_world}"

Inheritance
Single inheritance, unlike C++
Top-level classes are subclasses of Object , which is a subclass of BasicObject

Classes have built-in functionality because they inherited it!

Modules
Modules provide a namespace, avoiding name collisions

module MyModule # a module has it all
MY_CONSTANT = "my constant" # constants

def my_method # methods
end

class MyClass # and classes
end
end

namespaced = MyModule::MyClass.new

Modules have another wonderful use: mixins

Mixins and Inheritance
Some OO languages support multiple inheritance (C++, Lisp, Python, etc)

This is very powerful, but can be troublesome because of inheritance ambiguity

Ruby oﬀers a great compromise: the simplicity of single inheritance and the
power of multiple inheritance

Mixins
include is used to mix modules into classes or other modules

module ToBeIncluded
def foo
"bar"
end
end

class MyClass
include ToBeIncluded
end

object = MyClass.new
object.foo

Mixins
extend is used to add instance methods to a given object

module ToBeIncluded
def foo
"bar"
end
end

class MyClass
end

object = MyClass.new
object.extend ToBeIncluded
object.foo

Mixins
extend is also used to mix instance methods into a class

module ToBeIncluded
def foo
"bar"
end
end

class MyClass
extend ToBeIncluded
end

MyClass.foo

Mixins

module StringHelpers class Over9000Number < Number
def stringify include StringHelpers
if self.value > 9000
"Over 9000!" def initialize(value)
else super(value + 9000)
"Meh" end
end
end def status
end "Current status: "+stringify
end
class Number end
attr_reader :value
number = Over9000Number.new(42)
def initialize(value) number.status
@value = value # => "Current status: Over 9000!"
end
end

Inherit from one class, include functionality from multiple modules — mixins !

Inheritance, Mixins and Design
Ruby allows you to right code once and inject it into multiple places

When to use each?
Inheritance

You should be able to replace a parent object with a child object, honoring
its contract

A child object is a kind of the parent (an apple is a fruit)

In the real world, strict hierarchies are restrictive... we need composition!

Mixins

For composition: A has a B, or A uses a B

Exclusively using mixins can be messy — both should be combined

Inheritance, Mixis and Design
Each of them serves its purpose, our job is to use the appropriately

None of these make any sense:

class Person < DataWrapper
end

class Banana
include FruitProperties
end

Think before you type

Reﬂection
Ruby is very powerful when it comes to examining the aspects of a program
within itself
It can discover information about:
What objects exist

All class hierarchies

Attributes and methods of all objects

Information about methods

“When you introspect, you think about your thoughts and feelings. This is interesting because you're using thought to
analyze thought.” — Dave Thomas

Reﬂection and Objects
You can transverse all living objects:

ObjectSpace.each_object(Float) { |x| puts x }

You can look inside objects:

[1,2,3].methods[0..4]

[1,2,3].respond_to?(:to_s)

[1,2,3].kind_of?(Hash)

You can invoke any method by name using send :

a = [1,2,3]
a.send(a.private_methods.first.to_sym) # "initialize"
a # now it's empty!

Another way is to use the Method class:

a = [1,2,3]
constructor = a.method(:initialize)
constructor.call
a

You get a Method object which you can store, pass around and call anytime!

Reﬂection and Classes
It's also possible to look inside classes:

String.ancestors # all superclasses and mixed-in modules


klass = String
result = klass.to_s
begin
klass = klass.superclass
result += " < " + klass.to_s
end while klass.superclass
result


Fixnum.constants

Fixnum.class_variables

Fixnum.singleton_methods(false)

Fixnum.instance_methods(false) # private/protected/public prefix

Reﬂection and the Program's
Execution
Ruby let's you look at the interpreter while it executes your code

set_trace_func lambda { |event, file, line, id, binding, classname|
printf "%8s %s:%s-2d %-15sn", event, file, line, classname, id
}

# all code is traced from now on

And you can also get the current call stack by using calling caller on your
methods

Reﬂection and the Program's
Execution
You can even get the current source ﬁle being executed with the __FILE__ special
variable, leading to an interesting Quine :

print File.read(__FILE__)

A program that outputs itself!

Metaprogramming
Ruby code can modify aspects of its own structure at runtime and it makes it all
easy

You've seen it before on this presentation: remember include and extend? Ruby is
eﬀectively injecting their code into their receiver

Singleton Methods
Ruby lets you deﬁne methods speciﬁc to a particular object

person = "person" # String object
def person.say_hi
"Hi!"
end
person.say_hi

Magic? No. Ruby created an anonymous class (often called singleton class) based
on String and added the method say_hi to it

Singleton Class
There are other ways of creating methods in an object's singleton class

person = "person"
class << person
def say_hi
"Hi there!"
end
end
person.say_hi

Inherited Visibility
The visibility of an inherited method can be changed

class SuperClass
private
def my_private_method
"U can't touch this"
end
end

public :my_private_method
end

object = SubClass.new
object.my_private_method # not so private anymore

Inherited Visibility
What's really happening is that Ruby is inserting a hidden proxy method in the
subclass that invokes the original method with super

def my_private_method
super
end

public :my_private_method
end

super calls can access the parent's method regardless of its visibility

Deﬁning Methods
Ruby allows you to deﬁne methods at runtime using define_method

class BabyInfo
["cry", "eat", "poop"].each do |baby_action|
define_method(baby_action) do
"Of course, babies #{baby_action}"
end
end
end

baby_info = BabyInfo.new
baby_info.cry

Methods can also be blocked/removed by calling undef_method and remove_method,
respectively

Class-level Macros
Ruby has a few class-level macros that generate code behind the scenes

class Laptop
attr_accessor :memory # injects a getter/setter for "memory"
end

If you've used Ruby on Rails, you've probably dealt with associations

class Post < ActiveRecord::Base
has_many :comments
end

Eval
Similarly to other languages, eval evaluates the passed Ruby expression(s)

course = "LPOO"
eval "'Hello ' + course + '!'"

Instance eval
instance_eval allows you to evaluate Ruby expression(s) in the context of an
instance

string = "cool man cool"
string.instance_eval "def shout; self.upcase; end"
string.shout

Remember: classes are instances of Class, so you can also use instance_eval with
them:

Fixnum.instance_eval "def ten; 10; end"
Fixnum.ten

Class eval
As the name implies, class_eval can only be used with classes

It evaluates the code as if you were in the context of the class deﬁnition

String.class_eval do
def shout
self.upcase
end
end
string = "cool man cool"
string.shout

Note: eval, instance_eval and class_eval can take blocks as arguments as shown
above

Eval evilness
eval is slow

eval is dangerous

eval doesn't generally make sense, given all other metaprogramming facilities

Callbacks
Ruby provides hook methods , called by the interpreter when a speciﬁc event
occurs
Among all available hook methods —also known as callbacks —are:
Method-related hooks: method_added, method_missing, method_removed, etc

Class/Module-related hooks: const_missing, extended, included, inherited, etc

Object marshaling and coercion hooks

Callbacks: method_missing
Ruby allows you to act upon calls to undeﬁned methods by using method missing

class BabyInfo
["cry", "eat", "poop"].each do |baby_action|
define_method(baby_action) do
"Of course, babies #{baby_action}"
end
end

def method_missing(name, *args, &block)
"Nope, babies don't #{name}"
end
end

baby_info = BabyInfo.new
baby_info.surf

Callbacks: inherited
Ruby allows your classes to act when they're subclassed

class SuperClass
@children = [] # class variable

def self.inherited(child)
@children << child
end

def self.children
@children
end
end

Callback: method calls
Ruby allows you to intercept calls to speciﬁc methods:

class Object
alias_method :old_to_s, :to_s
def to_s
result = self.old_to_s
"Your modified to_s returned this (should be '"+result+"')"
end
end

object = Object.new
object.to_s

This isn't a direct hook: you're copying the original method and inserting a hook
by yourself

Ruby
Ruby is an incredibly powerful language

Many successful projects/products use it at their core: Ruby on Rails, God,
Redmine, etc

You can add and remove code in a running process, redefine methods on the fly,
change their scope

You can even modify basic types like String, Float or even Class and Object

After using it for a while, you'll notice the lack of flexibility on static languages
like C++ or half-static languages like Java

Ruby
This presentation, for instance, is running on a Sinatra application
And most of the shown code was executed in real time

No? Then check this out:

class Lecture
def initialize(name = "TBA")
@name = name
end

def finish
"Finished at #{(Time.now.utc+3600).strftime('%H:%M:%S')}!"
end
end

lecture = Lecture.new("Ruby")
lecture.finish

More
Books:
Programming Ruby 1.9 by Dave Thomas

Metaprogramming Ruby by Paolo Perrotta

Mailing lists:
Ruby-Talk (subscribe through Ruby's website)

Ruby-pt (Google Groups)

IRC:
#ruby and #ruby-pt on Freenode

Ruby — An introduction

More Related Content

What's hot

Viewers also liked

Similar to Ruby — An introduction

Recently uploaded

Ruby — An introduction