A Dangerous Game: Safety in Ruby

This talk explores the advantages of static typing and asks the question: "Do we want this in Ruby?".

Transcript

1. A Dangerous Game ! Safety in Ruby
2. Ryan Levick @itchyankles
7. Readability Expressivity Flexibility
9. I thought Ruby was perfect
10. But: no one is
14. What else does Ruby lack?
15. def add1(x) x + 1 end
16. def add1(x) x = 0 if x.nil? x + 1 end
17. def add1(x) unless x.respond_to?(:+) raise ArgumentError end ! x + 1 end
20. So how do we fix this ?!
21. If only there was an automated way to find these errors…
22. Static Typing
25. int add1(int x) { int answer = x + 1; return answer; }
26. Type Inference
27. add1 x = x + 1
28. So what does it get us?
29. def decorate_user(user) UserDecorator.new(user).decorate end ! user = User.find_by(email: "ryan@ex.com") ! decorated_user = decorate_user(user) ! respond_with user
30. undefined method `name' for nil:NilClass from user_decorator.rb:30:in `decorate_user'
31. Option Type
32. Option[Int] : Some(5) None
33. def decorate_user(user) UserDecorator.new(user).decorate end ! user = User.find_by(email: "ryan@ex.com") ! decorated_user = decorate_user(user) ! respond_with user
34. def decorateUser(user: User) = { UserDecorator(user).decorate } ! val user = User.findBy(email = "ryan@ex.com") ! val decoratedUser = decorateUser(user) ! respondWith user
35. [error]User.scala:24: type mismatch; [error] found Option[User]: [error] required: User [error] val decoratedUser = decorateUser(user)
36. “undefined method `foo' for nil:NilClass” No more!
37. Wait
38. Isn’t this also more intention revealing?
39. find(id: int) : User * may return nil
40. find(id: int) : Option[User]
41. Redis.fetch(key: String): String * may throw exception
42. Redis.fetch(key: String): Either[Error, String]
43. Wait Wait
44. Isn’t this what tests are for?
45. What is the best testing library ever invented?
49. Math
51. For all inputs a valid and correct output is given
52. Always present and cannot be forgotten
53. Cannot be erased
54. The compiler is far less likely to be buggy than your tests
55. Test Business Logic
57. def head(list) list.first end
58. def head(list) if list.empty? raise ArgumentError end ! list.first end
59. def head(list) head = list.first MyRubyOptionType.new(head) end
60. Idris
61. head : Vect (S n) a -> a head (h::tail) = h
62. head : Vect (S n) a -> a head (h::tail) = h
63. head : Vect (S n) a -> a head (h::tail) = h
64. head : Vect (S n) a -> a head (h::tail) = h
65. head : Vect (S n) a -> a head (h::tail) = h
66. head : Vect (S n) a -> a head (h::tail) = h
67. head : Vect (S n) a -> a head (h::tail) = h
68. x,y = [1,2]
69. head : Vect (S n) a -> a head (h::tail) = h
70. Idris> head [] Can’t unify Vect 0 a with Vect (S n) iType
71. No more runtime errors!
73. class Foo typesig("self.build: (Hash) -> Post") def self.build(attrs) # ... method definition end end
75. But is that what we want?
76. Ruby is Dynamic and that’s great!
77. Ruby is Dynamic and that’s great!
78. But…
81. Zen and the Art of Motorcycle Maintenance
82. Value Rigidity
83. We should know what we’re giving up.
84. Thank you! @itchyankles