Una efectiva introducción al lenguaje para entender sus fundamentos y virtudes. Revisar algunos de los desafíos que aplican al diseño de un lenguaje eficiente. Conoceremos también parte del ecosistema actual para hacer distintos tipos de aplicaciones y en qué situaciones se puede tener ventajas al usar Crystal.

1. Brian J. Cardiff
bcardiff@manas.tech
@CACIC2019@CrystalLanguage
Juan Wajnerman
waj@manas.tech
https://man.as/cacic2019
Fundamentos, objetivos y desafíos

2. Queremos un lenguaje
● Expresivo y seguro para el programador
● Cómodo para la máquina
Crystal

3. Syntaxis amena
# file: beetle.cr
3.times do
puts "Beetlejuice!"
end
$ crystal beetle.cr
Beetlejuice!
Beetlejuice!
Beetlejuice!
● Preludio implícito
● Reapertura de clases: Int.times
● Bloques
● Métodos top-level: puts

4. $ crystal build beetle.cr -o beetle
$ ./beetle
Beetlejuice!
Beetlejuice!
Beetlejuice!
$ otool -L ./beetle
./bettle:
/usr/lib/libpcre.0.dylib (compatibility version 1.0.0, current version
1.1.0)
/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current
version 1252.250.1)
Compilado

5. $ crystal build --emit llvm-ir --no-debug beetle.cr
$ cat beetle.ll
@"'Beetlejuice!'" = private constant { i32, i32, i32, [13 x i8] } { i32 1, i32 12, i32 12,
[13 x i8] c"Beetlejuice!00" }
define void @__crystal_main(i32 %argc, i8** %argv) {
alloca:
%i = alloca i32
; ...
while:
%68 = load i32, i32* %i
%69 = icmp slt i32 %68, 3
br i1 %69, label %body, label %exit
body:
Compilado (via LLVM)

6. $ crystal build --emit asm --no-debug beetle.cr
$ cat beetle.s
LBB0_60:
cmpl $3, 52(%rsp)
jge LBB0_62
leaq "l_'Beetlejuice!'"(%rip), %rax
movq %rax, %rdi
callq "_*puts<String>:Nil"
movl 52(%rsp), %ecx
addl $1, %ecx
movl %ecx, 52(%rsp)
jmp LBB0_60
LBB0_62:
Compilado (via LLVM)

7. Evitar errores en runtime
puts "Hello Beetlejuice !".upper_case
$ crystal build beetle.cr
In beetle.cr:2:27
2 | puts "Hello Beetlejuice !".upper_case
^---------
Error: undefined method 'upper_case' for String

8. puts "Hello Beetlejuice !".upcase
$ crystal build beetle.cr
$ ./beetle
Hello Beetlejuice !
Evitar errores en runtime

9. # file: input.cr
name = gets
puts "Hello #{name.upcase} !"
$ crystal build input.cr
Evitar errores en runtime

10. # file: input.cr
name = gets
puts "Hello #{name.upcase} !"
$ crystal build input.cr
In input.cr:3:20
3 | puts "Hello #{name.upcase} !"
^-----
Error: undefined method 'upcase' for Nil (compile-time type is (String | Nil))
Evitar errores en runtime

11. def sum(a, b)
a + b
end
sum "foo", "bar" # => "foobar"
sum 40, 2 # => 42
sum "foo", 0 # => Compile time error
Pero sin ser tan tercos
● Instanciación lazy de métodos
● Restricciones de tipos opcionales

12. class Object
macro property(name)
@{{name.var}} : {{name.type}}
def {{name.var}} : {{name.type}}
@{{name.var}}
end
def {{name.var}}=(@{{name.var}} : {{name.type}})
end
end
end
Metaprogramación
class Human
property name : String
def initialize(@name)
end
end

13. class Dragon
def meet(h : Human)
puts "Bite"
end
def meet(d : Dragon)
puts "Play"
end
end
class Human
def meet(h : Human)
puts "Hi #{h.name}, I'm #{name}"
end
def meet(d : Dragon)
puts "Watch & train #{d.name}"
end
end
Multi-dispatch & “duck-typing”
creatures = [Human.new("Hiccup"), Human.new("Astrid"),
Dragon.new("Toothless"), Dragon.new("Fireworm")]
a, b = creatures.sample(2) # => a, b : Human | Dragon
print "#{a.name} meeting #{b.name}: "
a.meet(b)

14. Concurrencia
Múltiples trazas de ejecución compartiendo recursos:
● CPU
● I/O
● Memoria

15. channel = Channel(Int32).new
total_lines = 0
files = Dir.glob("*.cr")
files.each do |f|
spawn do
lines = File.read(f).lines.size
channel.send lines
end
end
files.size.times do
total_lines += channel.receive
end
puts total_lines
Concurrencia
● Fibers (coroutines)
● Managed thread(s) worker(s)
● Blocking API (no callbacks)
“Do not communicate by sharing memory;
instead, share memory by communicating.”
Effective Go
https://golang.org/doc/effective_go.html#sharing

16. Fibers
Scheduler
Fibers
Event Loop
● de usuario
● de sistema
● IO
● timers

17. d1 = HTTP::Client.get("http://...")
d2 = HTTP::Client.get("http://...")
d3 = HTTP::Client.get("http://...")
Fibers vs. Callbacks
fetch("http://...", (d1) => {
fetch("http://...", (d2) => {
fetch("http://...", (d3) => {
})
})
})

18. Canales
chSend Receivech.send(123) ch.receive
ch = Channel(Int32).new

19. Canales
Recolectar
Resultados
ch1
Calcular
Celda
Calcular
Celda
Calcular
Celda
Calcular
Celda
ch2
Repartir
Celdas
Multiplicar matrices:

20. Elecciones en Crystal
● Syntaxis amena
● Compilado
● Evitar errores en runtime cuando se pueda
● Inferencia de tipos, Multi-dispatch y “duck-typing”
● Modelo de programación concurrente
● Metaprogramación
● Promover buenas prácticas de uso de recursos
● Integración con C

21. ● from a DB to JSON with Crystal
○ https://manas.tech/blog/2017/01/16/from-a-db-to-json-with-crystal/
○ https://github.com/crystal-lang/crystal-db
● https://kemalcr.com/
● https://amberframework.org/
● https://luckyframework.org
● samples/2048.cr https://github.com/crystal-lang/crystal/tree/master/samples
● sdl raytracer https://github.com/asterite/crystal_sdl2_examples
● nes https://github.com/asterite/nes.cr
Apps & Frameworks

22. crystal-lang.org
¿Dónde?

23. Brian J. Cardiff
bcardiff@manas.tech
¡gracias!
Juan Wajnerman
waj@manas.tech