Crystal is a compiled language that aims to provide Ruby-like syntax with static typing. It compiles to native code, allowing for performance comparable to C/C++. Crystal uses LLVM as a backend, providing type inference, concurrency support, bindings to native libraries, and metaprogramming capabilities. The language is still in active development but has growing adoption, with over 1500 libraries and 80 sponsors supporting continued development.

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