Mi charla sobre uso de múltiples lenguajes bajo la JVM, dictada en el Día del Software Libre en Curicó.

1. Programación Políglota
en la JVM
Jano González
Desarrollador
http://janogonzalez.com

2. Sobre mi
@janogonzalez
● Desarrollando en Java desde
2000, enamorado de Ruby en
2010
● Co-organizador del Meetup de
Lenguajes Dinámicos:
http://www.meetup.com/dynla
ngchile/
● Publica el blog
http://gemaroja.com
● Músico frustrado

3. polígloto, ta o poligloto, ta.
(Del gr. πολύγλωττος).
1. adj. Escrito en varias lenguas.
2. adj. Dicho de una persona: Versada en varias
lenguas.
(rae.es)

4. El problema

5. Proyectos atrasados

6. Baja calidad del producto

7. Causado por

8. Requerimientos cambiantes

9. Exceso de complejidad en la
arquitectura

10. Vendor lock-in

11. Lenguajes “verbosos”

12. Abstracciones inadecuadas

13. <queja>
Demasiado XML
</queja>

15. Programación Políglota al
rescate

16. Nivel de abstracción adecuado
:Dc
para cada problema

17. Estático v/s dinámico
:Dc

18. Estructurado v/s
orientado :Dc
a objetos v/s
funcional

19. La JVM

20. Fuentes <<se compila en>> Bytecode
<<ejecuta>>
JVM JVM
Plataforma 1 Plataforma N

22. Multi-threading
:Dc

23. Garbage collector
:Dc

24. JIT
:Dc

25. Multiplataforma
:Dc

26. Gran porcentaje de penetración
:Dc
en entornos “enterprise”

27. Lenguajes para la JVM

28. JRuby Jython Groovy Scala
Clojure Rhino Mirah Fantom
Gosu Kotlin Seph BeanShell
etc...

30. Ruby para la JVM
:Dc

31. Orientado a Objetos
:Dc

32. Dinámico
:Dc

33. Con algunas características
funcionales

34. Gran soporte para meta-
programación

35. Todo es un objeto
# El clásico string
“Hola Mundo”.upcase
# No hay "tipos primitivos"!
5.zero?
# Hasta el nulo es un objeto
nil.nil?

36. Hay muchos tipos de objetos
# Rangos
(1..10)
# Arreglos
[1, 2, 3, 4, 5]
# Hashes
{:jano => "Alejandro", :cote => "José"}
# Expresiones regulares
/^[a-z]+$/
# Lambdas
lambda { |n| n * 2 }

37. Con métodos muy cool
# En realidad + es un método, no un operador
1.+(9)
# Con un poco de azucar sintáctico
1 + 9
# En otros objetos
"Hola " + "Mundo"
# Incluso con arreglos
[1, 2, 3] + [4, 5]

38. Bloques
# Un método puede recibir un bloque de código
5.times do
|n| puts n
end
# Para casos cortos como el anterior...
5.times { |n| puts n }

39. Bloques
# El clásico map
(1..100).map { |n| n * 2 }
# El clásico select
(1..100).select { |n| n % 3 == 0 }
# El clásico reduce
(1..100).reduce { |sum, n| sum + n }
# Incluso más corto
(1..100).reduce(:+)

40. Creando tus propias clases
# Problem Java?
class Persona
attr_reader :nombre, :apellido
def initialize(nombre, apellido)
@nombre = nombre
@apellido = apellido
end
end
jano = Persona.new("Jano", "González")
jano.nombre

41. Modificando clases ya existentes
# Monkey patching
class Range
def even
self.select { |n| n % 2 == 0 }
end
end
(1..100).even

42. Accediendo a clases Java
# Importando clases Java
require 'java'
java_import 'java.util.date'
d = Date.new
d.to_gmt_string

43. Accediendo a clases Java
Date d = new Date(); => d = Date.new
d.toGMTString() => d.to_gmt_string

44. Comandos
Intérprete
$ jruby
REPL
$ jirb
Administrador de paquetes
$ jgem

45. Gemas
Precaución: No todas funcionan en Jruby

46. Encontrando la gema adecuada

47. ¡A programar!

48. Ejemplos de uso
● Aplicaciones Web con Ruby on Rails
● Servicios REST con Sinatra
● Rspec/Capybara para probar aplicaciones
● DSLs para facilitar uso de bibliotecas Java

49. Clojure

50. Dialecto de Lisp para la JVM
:Dc

51. Dinámico
:Dc

52. Funcional
:Dc

53. Concurrencia con STM
:Dc

54. Es un Lisp
;; No sería un Lisp sin listas
(list 1 2 3 4 5)
;; Un poco de azucar sintáctico
'(1 2 3 4 5)

55. No sólo con listas
;; Vector
(vector 1 2 3 4 5)
;; Con azúcar sintáctico
[1 2 3 4 5]
;; Mapa
(hash-map :jano "Alejandro" :cote "José")
;; Con azúcar sintáctico
{:jano "Alejandro", :cote "José"}
;; Conjunto
(hash-set :hugo :paco :luis)
;; Con azúcar sintáctico
#{:hugo :paco :luis}

56. Funciones
;; Creando funciones
(def duplicar
(fn [n] (* 2 n)))
;; También existe una macro
(defn duplicar [n] (* 2 n))

57. Recursividad
;; Nadie se aburre de este ejemplo
(defn factorial [n]
(if (<= n 1)
n
(* (factorial (dec n)) n)))

58. Clásicos funcionales de ayer y hoy
;; Map
(map (fn [n] (* n 2)) '(1 2 3 4 5))
;; Con azucar sintáctico
(map #(* % 2) '(1 2 3 4 5))
;; Filter
(filter #(= 0 (mod % 2)) '(1 2 3 4 5))
;; Reduce
(reduce #(+ %1 %2) '(1 2 3 4 5))

59. Accediendo a clases Java
;; Usando un método
(.toUpperCase "Hola Mundo")
;; Usando un método estático
(Math/pow 2 10)

60. ¡A programar!

62. Estático

63. Orientado a Objetos

64. Funcional

65. Sintáxis parecida a Java, pero
menos “verbosa”

66. Concurrencia con actores

67. Conclusiones

68. Es posible atacar cada problema
:Dc
con el lenguaje más adecuado

69. La JVM es una gran plataforma
:Dc
para la programación políglota

70. La programación políglota en la
JVM es factible en entornos
“enterprise”

71. Precaución: El exceso de
lenguajes puede aumentar al
caos

72. El resto...

73. Nos vemos en

74. Nos vemos en

75. Imágenes
●
http://commons.wikimedia.org/wiki/File:Espagueti_de_Pasta_Fre
sca_al_Huevo.jpg
● http://www.startechconf.com/media/images/main-logo.png
● http://2011.encuentrolinux.cl/wp/wp-
content/uploads/2011/07/encuentro_linux.png
● http://openjdk.java.net/projects/mlvm/images/leonardo_vm.png
● http://upload.wikimedia.org/wikipedia/en/thumb/1/1a/Clojure-
glyph.svg/500px-Clojure-glyph.svg.png
● http://jruby.org/images/jruby-logo.png
● http://upload.wikimedia.org/wikipedia/en/8/85/Scala_logo.png

76. Jano González
Desarrollador
http://janogonzalez.com
@janogonzalez