José Valim describes what he learned when working on Elixir and how you can understand Ruby better by writing your own programming language.

1. Writing your own Programming
Language to Understand Ruby better
José Valim blog.plataformatec.com @josevalim

2. Writing your own Programming
Language to Understand Ruby better
ID blog twitter
José Valim blog.plataformatec.com @josevalim

3. I am José Valim
@josevalim

4. I work at
blog.plataformatec.com.br

5. Core Team Member

6. Elixir
Simple Object Orientation and
charming syntax on top of Erlang VM

7. Erlang VM
+Concurrent Processes
+Message Based
+Hot Code Swapping

8. Erlang Language
+Small and quick to learn
+Functional programming
- Syntax gets too much in your way
- No object orientation

9. Elixir
Simple Object Orientation and
charming syntax on top of Erlang VM

10. <3 Ruby <3

11. 1.Things I learned about Ruby
2.What if?
3.Wrapping up

12. Things I learned about
Ruby

13. The Syntax

14. puts “hi”

15. puts “hi” Lexer

16. puts “hi” Lexer
[:identi er, “puts”],
[:string, “hi”]

17. puts “hi” Lexer
[:identi er, “puts”],
[:string, “hi”]
Parser

18. puts “hi” Lexer
[:identi er, “puts”],
[:string, “hi”]
Parser
[:call, “puts”,[
[:string, “hi”]
]]

19. puts “hi” Lexer
[:identi er, “puts”],
[:string, “hi”]
Parser
[:call, “puts”,[
[:string, “hi”]
]]
Extra steps

20. puts “hi” Lexer
[:identi er, “puts”],
[:string, “hi”]
Parser
[:call, “puts”,[
[:string, “hi”]
]]
Extra steps
[:call, “puts”,[
[:string, “hi”]
]]

21. puts “hi” Lexer
[:identi er, “puts”],
[:string, “hi”]
Parser
[:call, “puts”,[
[:string, “hi”]
]]
Extra steps
[:call, “puts”,[
[:string, “hi”]
]]
Interpreter/Compiler

22. puts “hi” Lexer
[:identi er, “puts”],
[:string, “hi”]
Parser
[:call, “puts”,[
[:string, “hi”]
]]
Extra steps
[:call, “puts”,[
[:string, “hi”]
]]
Interpreter/Compiler

23. Flexible Grammar

24. def foo
1
end
foo #=> 1
self.foo #=> 1

25. def foo
1
end
foo #=> 1
self.foo #=> 1
foo = 2
foo #=> 2
self.foo #=> 1

26. foo

27. foo Lexer

28. foo Lexer
[:identi er, “foo”]

29. foo Lexer
[:identi er, “foo”]
Parser

30. foo Lexer
[:identi er, “foo”]
Parser
[:identi er, “foo”]

31. foo Lexer
[:identi er, “foo”]
Parser
[:identi er, “foo”]
Extra steps

32. foo Lexer
[:identi er, “foo”]
Parser
[:identi er, “foo”]
Extra steps
?

33. foo Lexer
[:identi er, “foo”]
Parser
[:identi er, “foo”]
Extra steps
?
Interpreter/Compiler

34. def bar
foo = 1
foo
end

35. def bar
foo = 1
lexer + parser
foo
end
[:method,:bar,[
[:assign, "foo", [:integer,1]],
[:identifier,"foo"]
]]

36. def bar
foo = 1
lexer + parser
foo
end
[:method,:bar,[
[:assign, "foo", [:integer,1]],
[:identifier,"foo"]
]]
extra steps
[:method,:bar,[
[:assign, "foo", [:integer,1]],
[:var,"foo"]
]]

38. def bar(arg)
arg.class
end
bar /foo/m

39. def bar(arg)
arg.class
end
bar /foo/m
bar, foo, m = 0, 1, 2
bar /foo/m

43. def show
@user = User.find(self.params[:id])
if @user.name =~ %r/^Ph.D/i
self.render :action => "show"
else
self.flash[:notice] = "Ph.D required"
self.redirect_to "/"
end
end

44. def show
@user = User.find(params[:id])
if @user.name =~ /^Ph.D/i
render :action => "show"
else
flash[:notice] = "Ph.D required"
redirect_to "/"
end
end

45. The Object Model

46. object = Object.new
def object.greet(name)
puts "Hello #{name}"
end
object.greet("Matz")

47. Ruby methods are stored in
modules

48. module Greeter
def greet(name)
"Hello #{name}"
end
end
class Person
include Greeter
end
Person.new.greet "Matz"

49. class Person
def greet(name)
"Hello #{name}"
end
end
Person.new.greet "Matz"

50. Person.is_a?(Module) #=> true
Class.superclass #=> Module

51. object = Object.new
def object.greet(name)
puts "Hello #{name}"
end
object.greet("Matz")

52. object.class.ancestors
#=> [Object, Kernel, BasicObject]

53. object.class.ancestors
#=> [Object, Kernel, BasicObject]
object.class.ancestors.any? do |r|
r.method_defined?(:greet)
end
#=> false

54. object.class.ancestors
#=> [Object, Kernel, BasicObject]
object.class.ancestors.any? do |r|
r.method_defined?(:greet)
end
#=> false
object.singleton_class.
method_defined?(:greet)
#=> true

55. object.class.ancestors
#=> [Object, Kernel, BasicObject]
object.class.ancestors.any? do |r|
r.method_defined?(:greet)
end
#=> false
object.singleton_class.
method_defined?(:greet)
#=> true
object.singleton_class.is_a?(Module)
#=> true

56. What if?

57. ... we did not have
blocks?

58. <3 Blocks <3

59. File.open("euruko.txt") do |f|
f.write "doing it live"
end

60. File.open "euruko.txt", do |f|
f.write "doing it live"
end

61. File.open "euruko.txt", do |f|
f.write "doing it live"
end

62. File.open("euruko.txt", do |f|
f.write "doing it live"
end)

63. do_it = do |f|
f.write "doing it live"
end
File.open "euruko.txt", do_it

64. No blocks
+No need for yield, &block
+Passing more than one block around is more
natural

65. ... we had Array and Hash
comprehensions?

66. n = [1,2,3,4]
[x * 2 for x in n]
# => [2,4,6,8]

67. n = [1,2,3]
[x * 2 for x in n, x.odd?]
# => [2,6]

68. n = [1,2,3,4]
[[x,y] for x in n, y in n, x * x == y]
# => [[1,1],[2,4]]

69. n = [1,2,3,4]
{x => y for x in n, y in n, x * x == y}
# => { 1 => 1, 2 => 4 }

70. ... our hashes were more
like JSON?

71. { a: 1 }

72. { "a": 1 }

73. ... we had pattern
matching?

74. x, y, *z = [1,2,3,4,5]
x #=> 1
y #=> 2
z #=> [3,4,5]

75. x, [y1,*y2], *z = [1,[2,3,4],5]
x #=> 1
y1 #=> 2
y2 #=> [3,4]
z #=> [5]

76. x, x, *z = [1,2,3,4,5]
#=> Raises an error

77. x, x, *z = [1,1,3,4,5]
#=> Works!

78. x = 1
~x, *y = [3, 2, 1]
#=> Raises an error!
~x, *y = [1, 2, 3]
# => Works!

79. ... we de ned a syntax
tree?

80. [:method,:bar,[
[:assign, "foo", [:integer,1]],
[:var,"foo"]
]]

81. class Foo
memoize def bar
# Something
end
end

82. class Foo
memoize(def bar
# Something
end)
end

83. def memoize(method)
tree = method.tree
# Do something
method.redefine! new_tree
end

84. Wrapping up

85. <3 Matz <3

87. <3 Elixir <3
github.com/josevalim/elixir

88. createyourproglang.com

89. ?
José Valim blog.plataformatec.com @josevalim

90. ?
ID blog twitter
José Valim blog.plataformatec.com @josevalim