Crystal for Rubyists

We at JetRockets use Crystal in production since September, 2019.

In these slides I show how Crystal differs from Ruby, how Ruby developers can start using Crystal fast and why we decided to include it in our development stack.

Transcript

1. Crystal for Rubists Rubyists February, 29 2020
2. Igor Alexandrov •JetRockets Co-Founder •CTO •SmallTalk => Ruby •Ruby => Crystal
3. Everything begins and ends in the mind
4. – favourite client “We need an ability to upload data about all real estate loans in US”
5. – JetRockets “Ok… But what do you mean by “All”?”
6. – favourite client “2.5 Gb CSV files that will be updated every day”
7. • ruby is slow (to be honest – not); • we will hit memory leaks again; • why not try something new?
8. We need new technology!
13. Crystal Language • Syntax inspired by Ruby • Compiled (based on LLVM) • With type inference and union types • With concurrency and parallelism • Does not support Windows
14. 2014 1995 19 years
15. Types
16. Type Inference (Ruby) if some_condition a = 1 a.abs else a = "hello" a.upcase end a.upcase
17. 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
18. 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
19. Type Inference (Crystal) if some_condition a = 1 a.abs else a = "hello" a.upcase end a.upcase
20. 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
21. 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
22. Type Composition struct Int32OrString { int type_id; union { int int_value; char[] string_value; } data; }
23. Type Composition if something_that_you_know_will_happen a = 1 end a.abs # here a is Int32 or Nil
24. 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
25. 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
26. 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
27. 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
28. Types in Crystal • Raise on compile-time if types mismatch • Type Inference • Type Composition • Type Filter
29. Concurrency and Parallelism
30. 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;
31. Is Ruby concurrent?
32. Indeed!
33. 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;
34. Does Ruby (cRuby) has parallelism?
35. Nope…
36. Parallelism Crystal 0.31
37. Metaprogramming
38. Metaprogramming • no code modifications at runtime • no #send, #method_missing, #instance_eval… • Crystal has macros
39. Simple Example (Ruby) class Point def initialize(x, y) @x, @y = x, y end def x @x end def y @y end end
40. Simple Example (Ruby) class Point def initialize(x, y) @x, @y = x, y end getter :x, :y end
41. 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
42. Simple Example (Ruby) class Point def initialize(x, y) @x, @y = x, y end attr_reader :x, :y end
43. Simple Example (Crystal) class Point def initialize(@x : Int32, @y : Int32) end def x @x end def y @y end end
44. 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
45. 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
46. 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
47. 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
48. Simple Example (Crystal) class Point def initialize(@x : Int32, @y : Int32) end def :x @:x end def :y @:y end end
49. 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
50. 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
51. Shrine Example (Ruby) class Uploader < Shrine plugin :determine_mime_type, analyzer: :file end
52. 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
53. – 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.”
54. 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
55. 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
56. Shrine Example (Crystal) class Uploader < Shrine load_plugin( Shrine::Plugins::DetermineMimeType, analyzer: Shrine::Plugins::DetermineMimeType::Tools::File ) finalize_plugins! end
57. 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
58. 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
59. Another Shrine Example (Crystal) class Shrine macro inherited # Reopen the class... class Attacher < Shrine::Attacher def self.shrine_class {{ @type }} end end end end
60. Another Shrine Example (Crystal) class Uploader < Shrine plugin :determine_mime_type, analyzer: :file end puts Uploader::Attacher.shrine_class # => Uploader
61. 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
62. 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 :)
63. 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"]"
64. Community?
65. What We Like in Ruby?
66. Of course – integrity
67. 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 :(
68. Crystal Community • Young • A lot of people came from Ruby • Even more “standardised”
72. Tooling • web frameworks (Kemal, Amber, Lucky); • background processing (sidekiq, it does not eat memory); • specs (Spec, Spectator); • ORMs (Clear, Jennifer.cr);
73. 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
75. Documentation
76. Documentation (Ruby)
77. 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
78. Documentation (Crystal) • included into compiler; • $ crystal docs • knows everything about params; • knows all return types; • generates HTML (even with sitemaps); • #exceptions
79. Documentation (Crystal)
80. Documentation (Crystal)
81. Code Style and Analysis • included into compiler; • $ crystal tool format • Ameba – static code analysis • like Rubocop for Ruby • with adequate configuration
82. 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
83. Ruby => Crystal?
84. 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 :)
85. Links • https://www.crystalforrubyists.com/ • https://github.com/crystal-lang/crystal/wiki/Crystal-Shards- for-Ruby-Gems • https://github.com/veelenga/awesome-crystal