Crystal for Rubists Rubyists February, 29 2020 

Igor Alexandrov •JetRockets Co-Founder •CTO •SmallTalk => Ruby •Ruby => Crystal 

Everything begins and ends in the mind 

– favourite client “We need an ability to upload data about all real estate loans in US” 

– JetRockets “Ok… But what do you mean by “All”?” 

– favourite client “2.5 Gb CSV files that will be updated every day” 

• ruby is slow (to be honest – not); • we will hit memory leaks again; • why not try something new? 

We need new technology! 

No content

No content

No content

No content

Crystal Language • Syntax inspired by Ruby • Compiled (based on LLVM) • With type inference and union types • With concurrency and parallelism • Does not support Windows 

2014 1995 19 years 

Types 

Type Inference (Ruby) if some_condition a = 1 a.abs else a = "hello" a.upcase end a.upcase 

Type Inference (Ruby) if some_condition a = 1 a.abs # will never fail else a = "hello" a.upcase # will never fail too end a.upcase # can fail at runtime 

Type Inference (Ruby) if some_condition a = 1 a.abs # will never fail else a = "hello" a.upcase # will never fail too end a.upcase # can fail at runtime 

Type Inference (Crystal) if some_condition a = 1 a.abs else a = "hello" a.upcase end a.upcase 

Type Inference (Crystal) if some_condition a = 1 # a is Int32 a.abs else a = "hello" # a is String a.upcase end a.upcase # a is Int32 or String 

Type Inference (Crystal) if some_condition a = 1 # a is Int32 a.abs else a = "hello" # a is String a.upcase end a.upcase # a is Int32 or String 

Type Composition struct Int32OrString { int type_id; union { int int_value; char[] string_value; } data; } 

Type Composition if something_that_you_know_will_happen a = 1 end a.abs # here a is Int32 or Nil 

Type Composition if something_that_you_know_will_happen a = 1 end # You can guarantee that a is not a nil a.not_nil!.abs 

Type Composition class Object def not_nil! self end end class Nil def not_nil! raise NilAssertionError.new end end a = some_condition ? 1 : nil a.not_nil!.abs 

Type Composition a = 1 while some_condition a # here a is actually Int32 or String a = false # here a is Bool a = "hello" # here a is String a.size # ok, a is String end a # here a is Int32 or String 

Type Filter a = some_condition ? 1 : nil # a is Int32 or Nil if a a.abs # a is Int32 end # compiler assumes the variable is not nil # inside the if branch 

Types in Crystal • Raise on compile-time if types mismatch • Type Inference • Type Composition • Type Filter 

Concurrency and Parallelism 

Concurrency Sandwich example • you’re chopping an onion, putting it to fry.; • while it’s being fried, you’re chopping a tomato; • you’re not doing all of those things at the same time; 

Is Ruby concurrent? 

Indeed! 

Parallelism Sandwich example • you have at least four arms (2 pairs); • you’re chopping an onion, putting it to fry; • while you’re cutting an onion, you’re also chopping a tomato; • you are doing at least two things at the same time; 

Does Ruby (cRuby) has parallelism? 

Nope… 

Parallelism Crystal 0.31 

Metaprogramming 

Metaprogramming • no code modifications at runtime • no #send, #method_missing, #instance_eval… • Crystal has macros 

Simple Example (Ruby) class Point def initialize(x, y) @x, @y = x, y end def x @x end def y @y end end 

Simple Example (Ruby) class Point def initialize(x, y) @x, @y = x, y end getter :x, :y end 

Simple Example (Ruby) def getter(*names) names.each do |name| class_eval "def #{name}; @#{name}; end" end end class Point def initialize(x, y) @x, @y = x, y end getter :x, :y end 

Simple Example (Ruby) class Point def initialize(x, y) @x, @y = x, y end attr_reader :x, :y end 

Simple Example (Crystal) class Point def initialize(@x : Int32, @y : Int32) end def x @x end def y @y end end 

Simple Example (Crystal) macro attr_reader def x @x end end class Point def initialize(@x : Int32, @y : Int32) end attr_reader def y @y end end 

Simple Example (Crystal) macro attr_reader(*names) {% for name in names %} def {{name}} @{{name}} end {% end %} end class Point def initialize(@x : Int32, @y : Int32) end attr_reader x, y end 

Simple Example (Crystal) macro attr_reader(*names) {% for name in names %} def {{name}} @{{name}} end {% end %} end class Point def initialize(@x : Int32, @y : Int32) end attr_reader x, y # this is not an error end 

Simple Example (Crystal) macro attr_reader(*names) {% for name in names %} def {{name}} @{{name}} end {% end %} end class Point def initialize(@x : Int32, @y : Int32) end attr_reader :x, :y end 

Simple Example (Crystal) class Point def initialize(@x : Int32, @y : Int32) end def :x @:x end def :y @:y end end 

Simple Example (Crystal) macro attr_reader(*names) {% for name in names %} def {{name.id}} @{{name.id}} end {% end %} end class Point def initialize(@x : Int32, @y : Int32) end attr_reader :x, :y end 

How Macros Works? • AST nodes are passed as arguments • These are processed to produce a string • The string is parsed to a valid expression • The expression is “pasted” into the program 

Shrine Example (Ruby) class Uploader < Shrine plugin :determine_mime_type, analyzer: :file end 

Shrine Example (Ruby) def plugin(plugin, *args, **kwargs, &block) plugin = Plugins.load_plugin(plugin) if plugin.is_a?(Symbol) Plugins.load_dependencies(plugin, self, *args, **kwargs, &block) self.include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods) self.extend(plugin::ClassMethods) if defined?(plugin::ClassMethods) self::UploadedFile.include(plugin::FileMethods) if defined?(plugin::FileMethods) self::UploadedFile.extend(plugin::FileClassMethods) if defined?(plugin::FileClassMethods) self::Attachment.include(plugin::AttachmentMethods) if defined?(plugin::AttachmentMethods) self::Attachment.extend(plugin::AttachmentClassMethods) if defined?(plugin::AttachmentClassMethods) self::Attacher.include(plugin::AttacherMethods) if defined?(plugin::AttacherMethods) self::Attacher.extend(plugin::AttacherClassMethods) if defined?(plugin::AttacherClassMethods) Plugins.configure(plugin, self, *args, **kwargs, &block) plugin end 

– From documentation “Crystal does not support #include and #extend for adding modules to other modules or to create new class or instance methods at runtime.” 

Shrine Example (Crystal) macro load_plugin(plugin, **options) {% plugin = plugin.resolve %} {% PLUGINS << {decl: plugin, options: options} %} {% if plugin.constant(:InstanceMethods) %} include {{plugin.constant(:InstanceMethods)}} {% end %} {% if plugin.constant(:ClassMethods) %} extend {{plugin.constant(:ClassMethods)}} {% end %} end 

Shrine Example (Crystal) macro load_plugin(plugin, **options) # ... {% if plugin.constant(:FileClassMethods) %} class UploadedFile < Shrine::UploadedFile extend {{plugin.constant(:FileClassMethods)}} end {% end %} {% if plugin.constant(:FileMethods) %} class UploadedFile < Shrine::UploadedFile include {{plugin.constant(:FileMethods)}} end {% end %} end 

Shrine Example (Crystal) class Uploader < Shrine load_plugin( Shrine::Plugins::DetermineMimeType, analyzer: Shrine::Plugins::DetermineMimeType::Tools::File ) finalize_plugins! end 

Another Shrine Example (Ruby) class Shrine module ClassMethods def inherited(subclass) # ... file_class = Class.new(self::Attacher) file_class.shrine_class = subclass subclass.const_set(:Attacher, file_class) # ... end end end 

Another Shrine Example (Ruby) class Shrine module ClassMethods def inherited(subclass) # ... file_class = Class.new(self::Attacher) file_class.shrine_class = subclass subclass.const_set(:Attacher, file_class) # ... end end end 

Another Shrine Example (Crystal) class Shrine macro inherited # Reopen the class... class Attacher < Shrine::Attacher def self.shrine_class {{ @type }} end end end end 

Another Shrine Example (Crystal) class Uploader < Shrine plugin :determine_mime_type, analyzer: :file end puts Uploader::Attacher.shrine_class # => Uploader 

Macros Benefits • Macros gets evaluated at compile time (not a runtime) • Less chances to get a runtime error • No performance downgrades • Compiler can even perform an optimizations 

Macros Сons • Extremely hard to debug • Extremely hard to debug! • Only YOU can understand your macros • If you can do it without macros – do it :) 

Nice Macro Trick a = 1 pp! a # => "a # => 1" pp! [1, 2, 3].map(&.to_s) # => "[1, 2, 3].map(&.to_s) # => ["1", "2", "3"]" 

Community? 

What We Like in Ruby? 

Of course – integrity 

Ruby Community • Everything is on GitHub • One spec library (yes, I’ve never used minitest) • One code formatting rules (I recently discovered Rufo) • One deployment tool (who ever used Mina?) • One web framework :( 

Crystal Community • Young • A lot of people came from Ruby • Even more “standardised” 

No content

No content

No content

Tooling • web frameworks (Kemal, Amber, Lucky); • background processing (sidekiq, it does not eat memory); • specs (Spec, Spectator); • ORMs (Clear, Jennifer.cr); 

Tooling • a lot is still to be done; • ability to make your OpenSource commitment; • we maintain Shrine.cr; • https://github.com/jetrockets/shrine.cr • https://jetrockets.github.io/shrine.cr 

No content

Documentation 

Documentation (Ruby) 

YARD??? # Converts the object into textual markup given a specific `format` # (defaults to `:html`) # # == Parameters: # format:: # A Symbol declaring the format to convert the object to. This # can be `:text` or `:html`. # # == Returns: # A string representing the object in a specified # format. # def to_format(format = :html) # format the object end 

Documentation (Crystal) • included into compiler; • $ crystal docs • knows everything about params; • knows all return types; • generates HTML (even with sitemaps); • #exceptions 

Documentation (Crystal) 

Documentation (Crystal) 

Code Style and Analysis • included into compiler; • $ crystal tool format • Ameba – static code analysis • like Rubocop for Ruby • with adequate configuration 

Ameba # This configuration file was generated by # `ameba --gen-config`on 2020-02-23 13:02:10 UTC using # Ameba version 0.11.0. # The point is for the user to remove these configuration # records one by one as the reported problems are removed # from the code base. # Problems found: 1 # Run `ameba --only Lint/ShadowingOuterLocalVar` for details Lint/ShadowingOuterLocalVar: Description: Disallows the usage of the same name as outer local variables for block or proc arguments. Enabled: true Severity: Warning Excluded: - spec/lib/uploaded_file_spec.cr 

Ruby => Crystal? 

Convert Ruby code to Crystal? • https://github.com/DocSpring/ruby_crystal_codemod; • ruby gem; • fork of Rufo (an alternative code formatter for Ruby); • produces semi-valid Crystal code; • https://github.com/jetrockets/content_disposition.cr; • 70 lines of code :) 

Links • https://www.crystalforrubyists.com/ • https://github.com/crystal-lang/crystal/wiki/Crystal-Shards- for-Ruby-Gems • https://github.com/veelenga/awesome-crystal