“We’ll aim to release Ruby 3 for the Olympic Games in Tokyo in 2020.” –Matz

2. Hello!

3. Божидар

6. Ruby 4.0:
To INFINITY
and Beyound
by Bozhidar Batsov

8. Not on Ruby’s Core
Team

9. –Matz
“We’ll aim to release Ruby 3 for the Olympic
Games in Tokyo in 2020.”

10. Ruby is now mature

11. Build the things your
users need, instead of
the things they want.

13. The track record
of
recent Ruby innovation

14. Ruby != MRI

15. 3.times do
puts "Ruby Rocks!"
end

16. Ruby 2.0

17. • keyword arguments
• %i
• UTF-8 is now the default source file encoding
• Refinements (experimental feature)

18. Ruby 2.1

19. • Rational/Complex Literal
• defs return value
• Refinements are no longer experimental
feature

20. Ruby 2.2

21. Nada

22. Ruby 2.3

23. • frozen string literals pragma
• safe navigation operator (&.)
• squiggly heredocs (<<~)

24. Ruby 2.4

25. • Unify Fixnum and Bignum into Integer
• Support Unicode case mappings

26. Ruby 2.5?

27. Java innovates
more!

28. Ruby 2.2 includes many new features and
improvements for the increasingly diverse and
expanding demands for Ruby.
For example, Ruby’s Garbage Collector is now able to
collect Symbol type objects. This reduces memory
usage of Symbols; because GC was previously unable
to collect them before 2.2. Since Rails 5.0 will require
Symbol GC, it will support only Ruby 2.2 or later.
(See Rails 4.2 release post for details.)
Also, a reduced pause time thanks to the new
Incremental Garbage Collector will be helpful for
running Rails applications. Recent developments
mentioned on the Rails blog suggest that Rails 5.0
will take advantage of Incremental GC as well as
Symbol GC.

29. Ruby 2.2 includes many new features and
improvements for the increasingly diverse and
expanding demands for Ruby.
For example, Ruby’s Garbage Collector is now able to
collect Symbol type objects. This reduces memory
usage of Symbols; because GC was previously unable
to collect them before 2.2. Since Rails 5.0 will require
Symbol GC, it will support only Ruby 2.2 or later.
(See Rails 4.2 release post for details.)
Also, a reduced pause time thanks to the new
Incremental Garbage Collector will be helpful for
running Rails applications. Recent developments
mentioned on the Rails blog suggest that Rails 5.0
will take advantage of Incremental GC as well as
Symbol GC.

30. Ruby 2.2 includes many new features and
improvements for the increasingly diverse and
expanding demands for Ruby.
For example, Ruby’s Garbage Collector is now able to
collect Symbol type objects. This reduces memory
usage of Symbols; because GC was previously unable
to collect them before 2.2. Since Rails 5.0 will require
Symbol GC, it will support only Ruby 2.2 or later.
(See Rails 4.2 release post for details.)
Also, a reduced pause time thanks to the new
Incremental Garbage Collector will be helpful for
running Rails applications. Recent developments
mentioned on the Rails blog suggest that Rails 5.0
will take advantage of Incremental GC as well as
Symbol GC.

31. Ruby 2.2 includes many new features and
improvements for the increasingly diverse and
expanding demands for Ruby.
For example, Ruby’s Garbage Collector is now able to
collect Symbol type objects. This reduces memory
usage of Symbols; because GC was previously unable
to collect them before 2.2. Since Rails 5.0 will require
Symbol GC, it will support only Ruby 2.2 or later.
(See Rails 4.2 release post for details.)
Also, a reduced pause time thanks to the new
Incremental Garbage Collector will be helpful for
running Rails applications. Recent developments
mentioned on the Rails blog suggest that Rails 5.0
will take advantage of Incremental GC as well as
Symbol GC.

32. Ruby 2.2 includes many new features and
improvements for the increasingly diverse and
expanding demands for Ruby.
For example, Ruby’s Garbage Collector is now able to
collect Symbol type objects. This reduces memory
usage of Symbols; because GC was previously unable
to collect them before 2.2. Since Rails 5.0 will require
Symbol GC, it will support only Ruby 2.2 or later.
(See Rails 4.2 release post for details.)
Also, a reduced pause time thanks to the new
Incremental Garbage Collector will be helpful for
running Rails applications. Recent developments
mentioned on the Rails blog suggest that Rails 5.0
will take advantage of Incremental GC as well as
Symbol GC.

33. Ruby 2.2 includes many new features and
improvements for the increasingly diverse and
expanding demands for Ruby.
For example, Ruby’s Garbage Collector is now able to
collect Symbol type objects. This reduces memory
usage of Symbols; because GC was previously unable
to collect them before 2.2. Since Rails 5.0 will require
Symbol GC, it will support only Ruby 2.2 or later.
(See Rails 4.2 release post for details.)
Also, a reduced pause time thanks to the new
Incremental Garbage Collector will be helpful for
running Rails applications. Recent developments
mentioned on the Rails blog suggest that Rails 5.0
will take advantage of Incremental GC as well as
Symbol GC.

35. What about Ruby 3.0?

36. Little is known about
it…

37. Optional static
typing?
rejected

38. Duck inference?

39. Better support for
concurrent & parallel
programming

41. 3 times faster
performance?

42. Getting rid of some
quirky features?

43. We’re not going to
repeat the Python 3
mistakes!
— Matz

44. And what about the
Perl 6 mistakes?
— Bozhidar

46. Ruby 4.0

47. Codename Buzz

48. Ruby 4x4

49. Ruby 4 is going to be 4
times faster than Ruby
3

50. Ruby 4 is going to be
12 times faster than
Ruby 2

51. Ruby 4 is finally going
to be fast enough!

52. Ruby 4.0,
the language

53. Ruby 4.0,
the language
(and maybe the Standard Library)

54. Design principle #1

55. Continue to optimize
for happiness

56. Add some useful new
features

57. Immutable data
structures

58. vector

59. v = @[1, 2, 3]

60. immutable hash

61. m = @{one: 1, two: 2}

62. immutable set

63. s = @${1, 2, 3}

64. s = ${1, 2, 3}

65. Static typing and
runtime contracts

66. Inspired by RDL

67. type '(Fixnum, Fixnum) -> String'
def m(x, y) ... end

68. pre { |x| x > 0 }
post { |r,x| r > 0 }
def sqrt(x)
# return the square root of x
end

69. type '(Float x {{ x>=0 }}) -> Float y
{{ y>=0 }}'
def sqrt(x)
# return the square root of x
end

70. Better concurrency
APIs

71. Inspired by
concurrent-ruby

72. CSP

73. messages = Concurrent::Channel.new
Concurrent::Channel.go do
messages.put 'ping'
end
msg = messages.take
puts msg

74. def sum(a, c)
sum = a.reduce(0, &:+)
c << sum # `<<` is an alias for `put` or `send`
end
a = [7, 2, 8, -9, 4, 0]
l = a.length / 2
c = Concurrent::Channel.new
Concurrent::Channel.go { sum(a[-l, l], c) }
Concurrent::Channel.go { sum(a[0, l], c) }
x, y = ~c, ~c # `~` is an alias for `take` or `receive`
puts [x, y, x+y].join(' ')

75. Design principle #2

76. Simplicity

77. Simplicity is the
ultimate
sophistication.

78. Less is more

79. Simplicity
leads to
happiness.

80. Let’s drop some stuff

81. Let’s drop some
useless
stuff

82. for loops

83. for name in names
puts name
end

84. names.each do |name|
puts name
end

85. BEGIN & END

86. END {
puts 'Bye!'
}
puts 'Processing...'
BEGIN {
puts 'Starting...'
}

87. puts 'Bye!'
puts 'Starting...'
puts 'Processing...'

88. Kernel#at_exit,
anyone?

89. flip-flops

90. DATA.each_line do |line|
print(line) if (line =~ /begin/)..(line =~ /end/)
end

91. block comments

92. =begin
comment line
another comment line
=end

93. Must be placed at the
very beginning of a line

94. class SomeClass
=begin
This is a top comment.
Or is it?
=end
def some_method
end
end

95. class SomeClass
=begin
This is a top comment.
Or is it?
=end
def some_method
end
end

96. Character literals

97. pry(main)> ?a
=> "a"

98. $SAFE

99. Let’s drop some
redundant
stuff

100. There’s more than
one way to do it

101. (There are way too
many ways to do it)

102. core library method
aliases

103. collect => map
inject => reduce
detect => find
select => find_all
sprintf => format
length => size
raise => fail

104. Where is filter?

105. map
reduce
find
filter
format
length
raise

106. procs

107. No arity check

108. Non-local return

109. Do we really need
them?

110. So many languages are
getting by just fine
with only lambdas…

112. Single-quoted string
literals

114. A ton of obscure %-
something literals

115. %s, %x, %w, %W, %,
%i

116. %r, %q, %Q

117. So excited to be here!

118. puts "Hello, Nairobi!"
puts "Hello, Nairobi!"
puts "Hello, Nairobi!"

119. for i in 1..3
puts "Hello, Nairobi!"
end

120. 3.times do
puts "Hello, Nairobi!"
end

121. 3.times do
puts %(Hello, Nairobi!)
end

122. 3.times do
puts %Q(Hello, Nairobi!)
end

123. 3.times do
puts 'Hello, Nairobi!'
end

124. 3.times do
puts %q(Hello, Nairobi!)
end

127. Are all those options
worth our while?

129. Let’s fix some stuff!

130. and & or have the
same precedence

131. So many nils floating
around

132. pry(main)> "TOP".upcase
=> "TOP"
pry(main)> "TOP".upcase!
=> nil

133. Mutable strings

134. Even JavaScript got
this right…

135. Reassignable
constants

136. pry(main)> A = 5
=> 5
pry(main)> A = 6
(pry):39: warning: already initialized constant A
(pry):38: warning: previous definition of A was here
=> 6
pry(main)> Class = 3
(pry):40: warning: already initialized constant Class
=> 3
pry(main)> Class
=> 3

138. Class variables

139. class Parent
@@class_var = 'parent'
def self.print_class_var
puts @@class_var
end
end
class Child < Parent
@@class_var = 'child'
end
Parent.print_class_var # => will print "child"

140. Poorly named
methods

141. Kernel#puts

142. Kernel#println,
anyone?

143. Kernel#print

144. defined?

145. [1] pry(main)> defined? 10
=> "expression"
[2] pry(main)> defined? Test
=> nil
[3] pry(main)> defined? TrueClass
=> "constant"

147. Enumerable#include?

148. Enumerable#includes?

149. Kernel#%

150. '%d %d' % [20, 10]

151. sprintf('%d %d', 20, 10)

152. sprintf(
'%{first} %{second}',
first: 20, second: 10
)

153. format('%{first} %{second}',
first: 20, second: 10)

154. In what universe would
you prefer Kernel#%
over Kernel#format???

155. Perl-style global
variables

156. $:

157. $LOAD_PATH

158. $;

159. $FIELD_SEPARATOR

160. $*

161. $ARGV

162. JRuby defines the
English aliases by
default

163. Ruby 4.0 will do this
as well!

164. WTF? Global
variables?

166. Even Java doesn’t
have globals…

167. The future of the
standard library

168. The Ruby Stdlib is a
Ghetto
http://www.mikeperham.com/2010/11/22/the-ruby-stdlib-
is-a-ghetto/

169. A ton of legacy code
(often last updated
2000-2003)

170. Horrible APIs

171. net/http anyone?

172. The Kill List
• Net::*
• DRb
• REXML
• RSS
• Rinda
• WEBrick
• XML

173. What are the parts of the
standard library you
dislike the most? Why so?

178. 1. Move the important
bits to the Core Library

179. 2. Remove everything
outdated/obscure

180. 3. Leverage modern
Ruby features in the
Standard Library

181. Wait, there’s more!

182. Formal language
specification and
compatibility test suite

183. Roadmaps for future
Ruby releases

184. We’ll adopt the Rubinius
VM and make it 100%
compatible with MRI

185. Epilogue

186. When will Ruby 4 be
released?

187. Ruby 4.0 will likely
never happen

189. Ruby 4.0 is already
here!

190. Crystal

191. Clojure

192. Elixir

193. Scala

194. –William Gibson
“Тhe future is already here it's just not
evenly distributed.”

195. Felina

196. One more thing…

197. Stewardship:
The Sobering Parts
https://www.youtube.com/watch?v=2y5Pv4yN0b0

198. –Zach Tellman
There has been a consistent migratory
pattern from Ruby to node.js to Go, Rust,
and Elixir. At first, each community is
defined by its potential. But as that potential
is realized, the community begins to be
defined by its compromises. That change is
felt most keenly by the people who were
there first, who remember what it was like
when anything seemed possible. They feel
fenced in and so they move on, in search of
their golden city..”

199. File tickets

200. Send patches

201. Blog about the issues

202. Speak about the
issues

203. Let’s make Ruby
better together!

204. Ruby
Ruby

205. Epilogue
twitter: @bbatsov
github: @bbatsov
http//batsov.com
http://emacsredux.com
RubyConf Kenya
Nairobi,
Kenya
09.06.2017