Watch @bcardiff presentation in New York

2. ➔ Ruby is practical to write code
➔ Compiled languages are more efficient
➔ Type checking reduces errors
➔ We want the best of each world
Motivation

3. Ruby inspired syntax
# The Greeter class
class Greeter
def initialize(name : String)
@name = name
end
def salute
puts "Hello #{@name}!"
end
end
# Create a new object
g = Greeter.new("world")
# Output "Hello World!"
g.salute

4. Static type checking
# sample.cr
"Hello" + 1
$ crystal build sample.cr
Error in line 1: no overload matches 'String#+' with types Int32
Overloads are:
- String#+(other : self)
- String#+(char : Char)

5. Native code generation
# hello.cr
puts "Hello"
$ crystal build hello.cr
$ otool -Vt hello
...
leaq 0x1e216(%rip), %rdi
callq "_*puts<String>:Nil"
...

6. Some benchmarks
brainfuck
https://github.com/kostya/benchmarks/tree/master/brainfuck
Time (s) Memory (MB)
C++ 5.08 1.1
Crystal 6.78 1.2
Go 7.11 1.0
Ruby 226.86 8.0

7. Some benchmarks
matmul
https://github.com/kostya/benchmarks/tree/master/matmul
Time (s) Memory (MB)
C 3.64 69.2
Go 3.83 73.5
Crystal 3.84 72.2
Ruby 338.40 82.8

8. Some benchmarks
havlak
https://github.com/kostya/benchmarks/tree/master/havlak
Time (s) Memory (MB)
Crystal 15.80 416.9
C++ 17.72 174.5
Go 31.26 349.9
Python 396.54 724.0

9. Current Status

10. Crystal 101

11. Data types
➔ Object
◆ Value
● Bool, Nil, Char
● Number
○ Int32, Int64, Float32, Float64, …
● Struct, Tuple, Pointer, …
◆ Reference (Class)
● String, Array, Hash, …

12. Unions
arr = [1, 2, "a", "b"] # Array(Int32 | String)
arr[0] # Int32 | String
"Hello".index('z') # Int32 | Nil

13. Bool
Type ID Value
Int32
Bool | Int32
Unions

14. Unions
String | Nil
String “Hi!”0x1234
0x0000

15. Blocks
def times(n)
while n > 0
yield
n -= 1
end
end
times(10) do
puts "Hello"
end

16. Procs
f = ->(x : Int32) { x + 1 } # Int32 -> Int32
f.call(5) # => 6

17. Closures
y = 42
f = ->(x : Int32) { x + y }
f.call(5) #=> 47
y = 20
f.call(5) #=> 25

18. Method overloading
def sum(x : String, y : String)
sum x.to_i, y.to_i
end
def sum(x : Int32)
x
end
def sum(x, y)
x + y
end
sum "12", "13" #=> 25
sum 10 #=> 10
sum 20, 30 #=> 50
def sum(*args) # Ruby
case args.length
when 2
if args[0].is_a?(String) &&
args[1].is_a?(String)
sum(x.to_i, y.to_i)
else
args[0] + args[1]
end
when 1
args[0]
else
raise "Error"
end
end

19. Type inference

20. Type inference
nil # Nil
false # Bool
1 # Int32
1.5 # Float64
'a' # Char
"hi" # String
:hi # Symbol

21. Type inference
a = 1 # a : Int32
b = a # b : Int32

22. Type inference
if 1 == 2
a = 42
else
a = "Hello"
end
# a : Int32 | String

23. Type inference
def add(a, b)
a + b
end
x = add(4, 5)
def add(a : Int32, b : Int32)
a + b
end
# x : Int32
x = add("foo", "bar")
def add(a : String, b : String)
a + b
end# x : String

24. Type inference
def fact(n)
if n > 0
fact(n - 1) * n
else
1
end
end
fact(5)
def fact(n : Int32)
…
end
fact(Int32)
Union
* 1
fact(Int32) n
# Int32

25. Type inference
str = "Hello"
idx = str.index('z') # Int32 | Nil
str[idx]
Error: no overload matches 'String#[]' with types (Int32 | Nil)
Overloads are:
- String#[](start : Int, count : Int)
- String#[](regex : Regex, group)
- String#[](index : Int)
- ...

26. str = "Hello"
idx = str.index('z') # Int32 | Nil
if idx
str[idx] # idx : Int32
end
Type inference

27. str = "Hello"
idx = str.index('z') # Int32 | Nil
if idx.is_a?(Int32)
str[idx] # idx : Int32
end
Type inference

28. Type inference
class Person
def initialize(name : String)
@name = name # Person.@name : String
end
end
john = Person.new("John")

29. Type inference
class Person
@name : String # Person.@name : String
def initialize(name)
@name = name
end
end
john = Person.new("John")

30. Type inference
class Stack(T)
def initialize
@values = Array(T).new
end
end
stack1 = Stack(Int32).new
stack2 = Stack(String).new

31. Concurrency

32. Concurrency
spawn do
HTTP::Client.get "http://example.org/"
end

33. Concurrency
ch = Channel(Int32).new
spawn do
puts ch.receive
end
ch.send 42

34. Metaprogramming

35. Metaprogramming
class Person
def address
@address
end
def age
@age
end
end
class Person
getter address
getter age
end
macro getter(name)
def {{name}}
@{{name}}
end
end

36. Metaprogramming
macro define_method(name, &block)
def {{name.id}}
{{block.body}}
end
end
define_method :greet do
puts "hello"
end
greet

37. struct Struct
def ==(other : self) : Bool
{% for ivar in @type.instance_vars %}
return false unless @{{ivar.id}} == other.@{{ivar.id}}
{% end %}
true
end
end
struct Point
def initialize(@x : Int32, @y : Int32)
end
end
Metaprogramming

38. Metaprogramming
macro compile_time_date
{{ `date`.stringify }}
end
Tip: Don’t miss how ECR module works.

39. Standard Library
● Uri, Regex
● ECR, Markdown
● JSON, YAML, XML, CSV
● Crypto
● HTTP
● OAuth
● IO
○ Stream oriented apis
● Zip

40. Bindings to native libraries

41. Functions
// C
double cos(double x);
double y = cos(1.5);
# Crystal
lib LibC
fun cos(x : Float64) : Float64
end
y = LibC.cos(1.5)

42. Structs
// C
struct Point {
int x, y;
};
struct Point point;
point.x = 1;
point.y = 2;
# Crystal
lib LibC
struct Point
x, y : Int32
end
end
point = LibC::Point.new
point.x = 1
point.y = 2

43. // C
typedef void (*sig_t) (int);
sig_t signal(int sig, sig_t func);
# Crystal
lib LibC
alias SigT = Int32 ->
fun signal(sig : Int32, func : SigT) : SigT
end
LibC.signal 2, ->(value) { puts "Interrupted" }
Callbacks

44. Wrapping up
● Ruby inspired syntax.
● LLVM under the hood.
● Learn from Go, Erlang, Rust, Swift.
● Let the compiler do as much work as
possible.

45. The present
➔ Charming community, Meetups.
➔ +100 contributors compiler, docs.
➔ 1500 shards.
➔ +80 sponsors, from 1usd/mo.

46. The future ‘17
➔ Multithreaded Concurrency
➔ Windows
➔ Polish language features to reach 1.0

47. Thank you

48. Homepage: http://crystal-lang.org/
GitHub: https://github.com/crystal-lang/crystal
IRC: #crystal-lang (freenode)
@CrystalLanguage
Brian J. Cardiff
https://manas.tech
bcardiff@manas.tech
@bcardiff