What?
Crystal is a new, elegant, multi-paradigm programming language that is productive and fast. It has Ruby's a Ruby-inspired syntax and compiles to native code. It is actually unreal how similar to Ruby this language looks like.
This language combines efficient code with developer productivity, adds full OOP, a great concurrency model and a compiler that holds your hand.
This article is meant to give you a short overview, a direct performance comparison to Ruby and show some things that set it apart. It is advised you know at least some Ruby before continuing on reading.
Starting with the fun stuff - a performant example
Let's actually get a feel as to how performant Crystal is.
I wrote an AA Tree in both Crystal and Ruby.
Note: Code quality might not be top-notch. Some lines of Crystal code are intentionally written more explicitly
We are going to be running this code to benchmark each implementation:
elements_count = ARGV[0].to_i # first command line argument
root = AANode.new(value: elements_count, level: 1)
tree = AATree.new(root)
start = Time.now
elements_count.times do |num|
raise Exception.new("Tree should not contain #{num}") if tree.contains?(num)
tree.add(num)
raise Exception.new("Tree should contain #{num}") unless tree.contains?(num)
end
elements_count.times do |num|
raise Exception.new("Tree should contain #{num}") unless tree.contains?(num)
tree.remove(num)
raise Exception.new("Tree should not contain #{num}") if tree.contains?(num)
end
puts "Time it took: #{Time.now - start} seconds."
What this essentially does is it adds numbers to our tree (which sorts them internally) and then removes each one, one by one. We also check if the tree contains the given number twice per addition/deletion.
The code snippet above is actually Crystal code.
Like I said, these languages are identical at first glance. Rewriting the code from Crystal to Ruby took me a total of 50 line changes for a 360 line file. 27 if you were greedy
It is worth noting that those changes are simply removing .as() method calls and type annotations.
Okay, they look identical but how much faster is Crystal?
Let's build the executable and start testing
> enether$ crystal build AA_Tree.cr -o crystal_tree --release
# 100 elements
> enether$ ./crystal_tree 100
Time it took: 0.0006560 seconds.
> enether$ ruby AA_Tree.rb 100
Time it took: 0.00172 seconds.
# 10K elements
> enether$ ./crystal_tree 10000
Time it took: 0.0044000 seconds.
> enether$ ruby AA_Tree.rb 10000
Time it took: 0.288619 seconds.
# 100K elements
> enether$ ./crystal_tree 100000
Time it took: 0.0498230 seconds.
> enether$ ruby AA_Tree.rb 100000
Time it took: 3.414404 seconds.
# 1 million elements
> enether$ ./crystal_tree 1000000
Time it took: 0.5007820 seconds.
> enether$ ruby AA_Tree.rb 1000000
Time it took: 39.370083 seconds.
# 10 million elements
> enether$ ./crystal_tree 100000000
Time it took: 5.6283920 seconds.
> enether$ ruby AA_Tree.rb 100000000
# Still running
As you can see, it runs laps around Ruby and proves to be ~80 times faster if we were to judge by our 1 million elements example.
Quirks and differences to Ruby
Despite the similarities, there are substantial differences to Ruby, here we will highlight the most obvious and interesting ones.
Types, type checking and type unions
The most apparent difference is that Crystal uses and mostly enforces types for variables. It has great type inference - if you do not explicitly define the type of a variable the compiler figures it out itself.
The way this language does typing is a sort of mix between static and dynamic typing. It allows you to change a variable's type
a = "Hello"
puts typeof(a) # => String
a = 42
puts typeof(a) # => Int32
but it also allows you to enforce a variable's type
a : String = "Hello" # a should be a string and only a string!
a = 42 # error: type must be String, not (Int32 | String)
Type Unions
Were you wondering what the (Int32 | String) type was in the error message above?
This is a so-called type union, which is a set of multiple types.
If we were to enforce a to be a union of Int32 and String, the compiler would allow us to assign either type to that variable as it knows to expect both.
a : (Int32 | String) = 42
a = "Hello"
# Completely okay
# But if we were to try to assign another type to it
a = true # => type must be (Int32 | String), not (Bool | Int32 | String)
Type Inference and Type Checking
The compiler can figure out the type of a variable himself in most cases. The type inference algorithm is specifically built to work when the type of the variable is obvious to a human reader and does not dig too deep into figuring out the specific type.
In the cases where multiple conditions are plausible, the compiler puts a union type on the variable. Crystal code won't compile if the possible types do not support a given method invoked on them.
if rand() > 0.5
a = "String"
puts typeof(a) # => String
else
a = 42
puts typeof(a) # => Int32
end
puts typeof(a) # => (String | Int32)
puts a.camelcase # => undefined method 'camelcase' for Int32 (compile-time type is (Int32 | String))
This is the way the compiler protects you from silly mistakes with mismatched types, something that is really common in dynamic languages. Its like having your very own programming assistant!
The compiler is smart enough to figure out when a variable is obviously from a given type
if rand() > 0.5
a = "String"
elsif rand() > 0.75
a = 42
else
a = nil
end
puts typeof(a) # => (String | Int32 | Nil)
unless a.nil?
# a is not nil for sure
puts typeof(a) # => (String | Int32)
end
if a.is_a?(String)
puts typeof(a) # => String
end
There are ways to ensure the compiler that the appropriate type is set.
puts a.as(String).camelcase
This checks that the a variable is a string and if it is not, it throws an error.
Enforcing types
As we said, we have the option to enforce a variable's type or let it be whatever.
This holds true for a method's parameters as well. Let's define two methods:
def generic_receiver(item)
puts "Received #{item}!"
end
def string_receiver(item : String)
puts "Received string #{item}!"
end
I assume you can already imagine what'll happen with the following code:
generic_receiver(1)
generic_receiver("Hello")
generic_receiver(1.5)
generic_receiver(true)
string_receiver("Hello")
string_receiver(1) # error!
It is usually good practice to not enforce a variable, as it leads to more generic code.
Concurrency
Its concurrent model is inspired by that of Go, namely CSP (Communication Sequential Processing).
It uses lightweight threads (called fibers) whose execution is managed by the runtime scheduler, not the operating system. Communication between said threads is done through channels, which can either be unbuffered or buffered.
Pictured: A lot of fibers who communicate between each other through channels
Crystal currently runs in a single thread but their roadmap intends to implement multithreading. This means that it currently has no support for parallelism (except for process forking), but that is subject to change.
Because at this moment there's only a single thread executing your code, accessing and modifying a variable in different fibers will work just fine. However, once multiple threads is introduced in the language, it might break. That's why the recommended mechanism to communicate data is through channels.
Metaprogramming
Crystal has good support for metaprogramming through macros. A macro is something that pastes code into the file during compilation.
Let's define our own version of Ruby's attr_writer
macro attr_writer(name, type)
def {{name}}=({{name.id}} : {{type}})
@{{name}} = {{name.id}}
end
end
Calling attr_writer foo, Int32 will evaluate to
def foo(foo : Int32)
@foo = foo
end
class Greeter
attr_writer hello_msg, String
def hello_msg
@hello_msg
end
end
gr = Greeter.new
gr.hello_msg = "Hello World"
puts gr.hello_msg # => Hello World
gr.hello_msg = 11 # => no overload matches 'Greeter#hello_msg=' with type Int32
Crystal macros support iteration and conditionals and can access constants.
MAX_LENGTH = 3
macro define_short_methods(names)
{% for name, index in names %}
{% if name.id.size <= MAX_LENGTH %}
def {{name.id}}
{{index}}
end
{% end %}
{% end %}
end
define_short_methods [foo, bar, hello]
puts foo # => 0
puts bar # => 1
# puts hello => undefined local variable or method 'hello'
Miscellaneous
Crystal has taken a lot of cool features from other languages and provides various syntax sugar that is oh so sweet!
Initializing class instance variables directly in a method
def initialize(@name, @age, @gender, @nationality)
is equal to
def initialize(name, age, gender, nationality)
@name = name
@age = age
@gender = gender
@nationality = nationality
end
Implicit object notation
Switch statements support invoking methods on the giving object without repeatedly specifying its name.
case string_of_the_gods
when .size > 10
puts "Long string"
when .size == 5
puts "Normal String"
when .size < 5
puts "Short String"
end
case {1, 1}
when {.even?, .odd?}
# Matches if value1.even? && value2.odd?
end
External keyword arguments
My personal favorite - Crystal allows you to name a function's parameters one way for the outside world and one way for the method's body
def increment(number, by value)
number + value
end
increment(10, by: 10)
Compiler
As you saw earlier, this language is compiled to an executable. Regardless, it still has something like a REPL which proves to be similar to our beloved irb - https://github.com/crystal-community/icr
You can also directly run a file without having to compile it and then run it, via the crystal command.
> enether$ crystal AA_Tree.cr 200000
Time it took: 0.536102 seconds.
This runs a little bit slower because we do not make use of the optimizations that the --release build flag brings with itself.
C Bindings
There is a way to write a performant library in Crystal which you can run in your Ruby code. The way you do this is to bind Crystal to C, which allows you to use it from Ruby.
I did not delve too deep into this but apparently it is easy and you can do it without writing a single line of C. That is awesome!
Conclusion
If you write Ruby, picking up Crystal is natural and can quickly find yourself writing performance-critical software in it. I believe it has a lot of potential and can yield a lot of benefits to our community but also to non-ruby programmers, as the syntax is just too easy to pass up. It is a joy to write and it runs blazingly fast, that is an unique combination which very few languages can boast with.
I hope I've sparked your interest by these short examples! I strongly encourage you to take a look at the language for yourself and notify me if I've missed something.
Here are some resources to read further up on:
Google Group
Gitter Chat
IRC
Subreddit
Newsletter
Latest comments (0)