[ “Love”, :Ruby ]

.each { |i| p i }

Herval Freire, march 2007

 What is Ruby?
 The Pearl is the June’s month gem
 Ruby was first released on July 95 by
a japanese nut (Matz).
 Ruby == Perl++!

(but without the ++ operator…)

 What is Ruby?
 An 100% OO language (well, 99.9%)
 One of a few languages not
designed by a committee!
 Strongly, Implicitly, Dynamically
typed language
 Open Source (GPL) with
implementations on Java VM (JRuby),
Windows, several Linux distributions,
BeOS,.Net…
 Concise. Simple. Fun!
 Hello, World!
public class HelloWorld {
public static void main(String[] args)
{
for(int i = 0; i < 10; i++) {
System.out.println(i + “
times…”);
}
}
}
 Hello, World!

10.times do |word|
puts “#{word} times…”
end
 Conventions
 CamelCaseClassNames
 @instance_variables
 @@class_variables
 $globals
 CONSTANTS
 ConstantsToo (yes, classes are constants)
 :symbols

Not mandatory, but recommended…

 dasherized_class_files.rb
 dasherized_methods_and_variables
 boolean_methods?
 destructive_methods!
 Wacky Syntax…
 You don’t need ; to end lines, but you
can.
 Parenthesis are optional. But not
always.
 There’s no begin without an end. But
things can end without a begin
 { } or begin/end. Whatever.
 If something then… well, not
necessarily then.
 Control Expressions
if a == true then puts “yes” end
if a == true { puts “yes” }
puts “yes” if a == true
if a == true
puts “ok, you got the point…”
end
 And more control
expressions…
 if...elsif...else...end
 unless (same as “if not”)
 while (while expr do … end)
 loop (loop do … end)
 for (for x in y do … end)
 case (case x when y … else … end)
 Boolean operations
 !,||, && - same as Java. Evaluation
from left to right
 not, and, or – evaluation from right to
left
 Implicit typing
a = “some string”
a.class
⇒ “String”

1.class
⇒ Fixnum
 No Interfaces!
 “Duck Typing” philosophy:

If it walks like a duck,

And talks like a duck,
Then we can treat it like a duck.
(who cares what it really is)
 No Interfaces!
class Carro
def faz_barulho
puts “vrummm”
end
end

class Aviao
def faz_barulho
puts “vloshhhhhhhh”
end
end

mazda = Carro.new
mazda.respond_to?(:faz_barulho)
⇒ True
 And no NullPointers, too
 Nilis an object
puts nil.class
⇒ NilClass

a = nil
a.nil?
⇒ True
 Classes, Structs and
Modules
 A Class is an extensible definition of
something (final classes will only be
available on ruby 1.9).
 A Module is the definition of a class. It
cannot be instantiated, nor extended. But
classes can include it, or extend it
(mixins).
 A Struct is a (generally) temporary class
made of something. Or a bunch of some
things.
 Classes: those promiscuous
bastards…
class Carro << SomethingElse
def faz_barulho
puts “vruumm”
end
end
palio = Carro.new
puts palio.faz_barulho
⇒ “vruumm”

class Carro
def faz_barulho
puts “cof cof cof…”
end
End
puts palio.faz_barulho
⇒ “cof cof cof…”
 But wait, there’s more!
module CarThingie
def faz_barulho
“vrum vrum”
end
end
palio.extend(CarThingie)
puts palio.faz_barulho
⇒ “vrum vrum”

Or in other words:
class Carro
include CarThingie
end

puts palio.is_a?(CarThingie)
⇒ true
 Yes, we have reflection!
puts palio.methods
⇒ [“methods”, …, “faz_barulho”]

palio.send(“faz_barulho”)
⇒ “vrum vrum”
 Attributes and Constructors
class Motocicleta
attr_accessor :owner

def initialize(owner_name, purchase_date = Time::now)

@owner = owner_name
@purchase_date = purchase_date
end
end

yamaha = Motocicleta.new( “John Doe”)

puts yamaha.owner
⇒ “John Doe”

puts yamaha.instance_variables
⇒ [@owner, @purchase_date]

puts Yahama.purchase_date
⇒ NoMethodError
 Getters and Setters, be
gone!
 Everyattribute is automatically
encapsulated, but overriding is easy:
class Motocicleta
def owner=new_owner
# you can do something else if you want…
@owner = new_owner

end
end
 The tale of the missing
method
class Carro
def method_missing(method, *args,
&block)
puts “Ops! Something wrong was
called…”
end
end

mazda.some_unexisting_crap
⇒ “Ops! Something wrong was called…”
 /regexp/
 Same syntax as Perl
 Matching operator: =~

 /joao/.match(“joao”)
== “joao” =~
/joao/ == “joao”.match(/joao/)
 Catch that!
begin
…
rescue [error_type [=> variable]]
ensure
end
 Useful classes, strange
syntaxes
 Hashes
– Hash.new… or { }

hash = Hash.new
hash.store “key”, “value”
puts hash.get(“key”)

Or…

hash = {}
hash[“key”] = “value”
puts hash[“key”]
 Useful classes, strange
syntaxes
 Arrays
– Array.new… or []

a = Array.new
a[4] = “a”
⇒ [nil, nil, nil, “a”]

Or…

a = []
a << “a”
[“a”]
 Useful classes, strange
syntaxes
 Strings
– String.new or “”

a = “some string”
puts a[3]
⇒ “e”
puts a[0..3]
⇒ “some”
puts a[0…3]
⇒ “som”
puts a[-10..-7]
⇒ “some”
a[“string”] = “ruby lovin’”
⇒ “some ruby lovin’”
 :symbols
A symbol is something that is not yet
anything, but it is already there. Like
a string, without the string part.
 Constants, keys on maps, string
representations.
john = { :name => “John Doe”, :car
=> “Palio” }
puts john[:name]
⇒ “John Doe”
 Ah… Blocks.
something = 10, something_else = 20
my_price = {
if something == 20
1
elsif something_else = 10
2
else
3
end
}
puts my_price
⇒ 3
Did I say block assignment?
nome, endereco, telefone = “John Doe”,
“Gotham City”, “+1 123 456 789”
puts nome
⇒ “John Doe”

car, parts = “Peugeot”, [:engine, :wheels,

:seats]
puts parts.size
⇒2
put parts.class
⇒ Array
 Yield that block, will ya’?
def delegate_something(&block)
block.call(1, 2, 3)
end
delegate_something { |a, b, c| puts a, b, c }
⇒ 123

def delegate_with_yield(a, b, c)
puts “doing something…”
yield (a, b, c)
End

delegate_with_yield(1, 2, 3) do | a, b, c |
puts “#{a} #{b} #{c}”
end
⇒ “doing something…”
⇒ “1 2 3”!
 JRuby!
A ruby 1.8 implementation on the
Java VM
– Currently on v0.92

“JRuby is tightly integrated with Java to

allow the embedding of the interpreter
into any Java application with full two-
way access between the Java and the
Ruby code. (Compare Jython for the
Python language.) “
 Conclusion
A very flexible and natural language
 Based on few, but powerful concepts:
closures, blocks, messages
 Not a tyranical language: bad
programmers can produce really
nasty code with little or no
restrictions...