Presentación introductoria a Ruby, enfocado a developers Java. Autor: Damian Garcia

1. Ruby para
Programadores
Java
Damian Garcia
1

2. NO es un Java vs Ruby
VS
2

3. Tienen en común:
- Leguaje Orientado a Objetos
- Fuertemente Tipados
Los Leguajes Fuertemente tipados no te dejan entremezclar objetos de distinto "TIPO".
Al conocer el “tipo” del objeto, esperan que tenga sentido lo que querés hacer.
Java:
String algo = 6;
//va a lanzar un error: Type mismatch: cannot convert from int to String
Ruby:
2 + "a"
#va a lanzar: TypeError: String can't be coerced into Fixnum
- Garbage collector
- Herramientas de documentación similares. RDoc y javaDoc
3

4. Diferencias
4

5. Lenguaje compilado:
El codigo java primero tiene que ser traducido al lenguaje de la
virtual machine de java para poder ser ejecutado.
Un lenguaje compilado se ejecuta mucho mas rápido.
Lenguaje interpretado:
En Ruby se ejecuta directamente el codigo y este es interpretado
en RunTime.
Un lenguaje interpretado tiene un mayor costo de tiempo.
Ventaja en la etapa del desarrollo, Build and Deploy.
5

6. Dinámico
Dinamicamente Tipado:
La variable pueda cambiar de "tipo" en runtime.
Estático = se fija con anterioridad por el compilador.
Java:
int x=2;
x=x^100;
System.out.println(x); => -831846303 (!)
Ruby:
x=2
x.class => Fixnum
x=x**100 => 1267650600228229401496703205376
x.class => Bignum
Estos son posibles errores que el compilador no puede llegar a
enterarse nunca..
La falta de declaraciones es el primer shock que sufre un
programador java cuando hace algo en ruby. 6

7. No te preocupes por las Interfaces.
Duck typing : "Si camina como un pato, nada como un pato y hace
"quack", podemos tratarlo como un pato"
class Pato
def talk
puts "Cuack"
end
end
class Ganzo
def talk()
puts "Kwok"
end
end
bandada = [ Pato.new, Ganzo.new ]
bandada.each do |d|
d.talk
end
=> “Cuack”
=> “Kwok”
7

8. Easy Reflection
Java
public static Object create(Class c, String value)
throws Exception
{
Constructor ctor = c.getConstructor(
new Class[] { String.class } );
return ctor.newInstance(
new Object[] { "Hello" } );
}
public static void main (String args[])
throws Exception
{
Greeting g =
(Greeting) create(Greeting.class, "Hello");
g.show();
}
Ruby
def create(klass, value)
klass.new(value)
end
g = create(Greeting, "Hello")
g.show 8

9. Clases abiertas
class Fixnum
def +(numero_a_sumar)
self - numero_a_sumar
#ideal para el dia del inocente
end
end
4+1 => 3
9

10. En Ruby Todo es
un objeto
10

11. nil inclusive es un objeto
Java:
null => Referencia erronea a un objeto
Ruby:
x=nil
x.nil? => true
x.class => NilClass
x.methods => ["eql?", "object_id", "id", "to_f",
"singleton_methods", "send", "taint", "frozen?",
"instance_variable_get", "^", "__send__", "instance_of?", "to_a",
"type", "protected_methods", "instance_eval", "==", "display",
"===", "instance_variable_set", "kind_of?", "extend", "to_s",
"hash", "class", "tainted?", "=~", "private_methods", "nil?",
"untaint", "is_a?"]
11

12. no hay primitivos
Java:
String.valueOf(33);
Integer.parseInt(“33”);
Ruby:
33.to_s
“33”.to_i
11.zero?
7.class => Fixnum
12

13. No hay metodos, ni llamadas a
funciones, son mensajes a objetos
string.index("x")
#Se envia :index (con "x" como argumento)
string.length
#Se envia :length (sin ningún argumento)
run_status_reports
#Se envia :run_status_reports (a self)
6 + 2
#Se envia :+ (con 2 como argumento) al objeto 6
6.+ 2 6.+(2)
13

14. Metodos dinámicos
class Talker
[:hello, :good_bye].each do |arg|
method_name = ("say_" + arg.to_s).to_sym
send :define_method, method_name do
puts arg
end
end
end
t = Talker.new
t.say_hello => hello
t.say_good_bye => good_bye
14

15. Contenedores:
Java:
Arrays
Collections Framework:
ArrayList
Stack
List
HashSet
HashMap
....
....
Ruby
Array a[1] = x
Hash h[a] = b
Set (collection of unordered values with no duplicates)
15

16. Iteradores
Java
char[] data = { 'a', 'b', 'c', 'd', 'e', 'f' };
for (int i = 0; i < data.length; i++) {
System.out.println( data[i] );
}
Ruby
data = 'a'..'f'
data.each { |c| print c, "n" }
Closures
bloque de código que puede ser pasado como argumento a la llamada de
un método
Java public static ArrayList double(ArrayList x)
{
ArrayList y = new ArrayList();
for (Iterator i = x.iterator(); i.hasNext(); )
y.add(i.next() * 2);
return y;
}
Ruby Otros ej. en Ruby
def double(a) people.select{|p| p.age > 18}.each{|p| puts p.name}
a.map {|e| e*2} # o sin generar un segundo Array
end people.each{|p| puts p.name if p.age > 18} 16

17. Mixins y Modulos en Ruby
Un modulo....
* Puede tener metodos definidos
* No pueden ser instanciadas
* Pueden ser convinadas (incluidas) en una clase
- El metodo del modulo pasa a ser un metodo de instancia de la
clase
module LessComparable
def >(other)
other < self
end
# Other methods defined in terms of less than:
# <=, >=, ==
end
class Pair
include LessComparable
attr_accessor :first, :second
# ...
def <(other)
(first < other.first) ||
(first == other.first && second < other.second)
end 17
end

18. Enfocado en la
simplicidad y la
productividad
Syntaxis clara, codigo mas legible, elegante.
Muy facil de aprender.
Principio de Menor sorpresa (POLS).
Menor cantidad de lineas de codigo
Simple but powerful.
18

19. JRuby
-Interprete open source de ruby para la JVM
-El mismo codigo Ruby corre en la JVM y en el interprete standard de
Ruby.
-Simplifica la integración Ruby-Java
Para acceder a java desde ruby:
require "java"
Para especificar las clases a usar:
include_class “nombre.de.la.Clase”
Para incluir un paquete
include_package
19

20. Por donde empezar?
OneClick Ruby installer:
http://www.ruby-lang.org/en/downloads/
En linux:
% sudo apt-get install ruby irb rdoc
IRB (Console based interactive Ruby interpreter. )
Api: http://apidock.com/ruby
Ruby Documentacion:
http://www.ruby-doc.org/ 20
(buen manual http://www.ruby-doc.org/docs/ProgrammingRuby/)