Trolls of 2013 - zenspider.com

Transcription

Trolls of 2013
Ryan Davis, Seattle.rb
Trolls of 2013
MWRC 2013, Salt Lake City, UT
Trolls of 2013
Setting Expectations
• Followup of my talk, “Occupy Ruby: Why We
Need to Moderate the 1%”
• 130 Slides in 30 minutes. 4.3 spm
• I must go quickly, so please hold questions.
• Ummm... no.
Let’s Write an Interpreter!
Let’s Write an
Interpreter!
Setting Expectations
• TODO
• 160 Slides in 30 minutes. 5.3 spm.
• Boatloads of content. Almost all code.
• I was asked to “Hurt Brains”.
Expanded to 45
minutes?!?
Added
15 minutes of kittens
to the end
OMG WHY?!?
Because
I’m a pervert!
Wait… No!
Because we can!
The “Uby”
Interpreter
Branching Logic:
if/else/elsif
if condition then
true_code
else
false_code
end
Loops: while
while condition
code
end
Local Variables
meaning = 42
pi
= 3
Functions
def fib n
if n <= 2 then
1
else
fib(n-2) + fib(n-1)
end
end
Functions
local variables
“primitive” function calls
def fib n
if n <= 2 then
recursive function calls
1
else
fib(n-2) + fib(n-1)
end
end
Uby Roadmap
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
Parsing:
ruby_parser
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
RubyParser.new.parse "
def fib n
if n <= 2 then
1
else
fib(n-2) + fib(n-1)
end
end
"
:lvar
:fib
:defn
:args
:if
:n
:n
:<
:call
:lit
2
:fib
:lit
1
nil
:lvar
:call
:call
:-
:n
:call
:+
:call
:lit
nil
2
:fib
:lvar
:n
:call
:-
:lit
1
:lvar
:fib
:defn
:args
:if
:n
:n
:<
:call
:lit
2
:fib
:lit
1
nil
:lvar
:call
:call
:-
:n
:call
:+
:call
:lit
nil
2
:fib
:lvar
:n
:call
:-
:lit
1
:lvar
:fib
:n
:defn
:<
:args
:call
:if
:lit
:n
:lit
2
1
:fib
:call
nil
:lvar
:call
:-
:n
:call
:+
:call
:lit
nil
2
:fib
:lvar
:n
:call
:-
:lit
1
:lvar
:fib
:n
:defn
:<
:args
:call
:if
:lit
:n
:lit
2
1
:fib
:call
:call
nil
:lvar
:call
:-
:+
:lit
:call
nil
:n
2
:fib
:lvar
:n
:call
:-
:lit
1
condition
:defn
:fib
:lvar
:call
:if
:n
:<
:lit
:args
2
then
:n
:lit
1
else
:call
nil
:fib
:lvar
:call
:call
:n
:-
:+
:lit
:call
nil
2
:fib
:lvar
:n
:call
:-
:lit
1
s(:defn, :fib, s(:args, :n),
s(:if,
s(:call, s(:lvar, :n), :<=, s(:lit, 2)),
s(:lit, 1),
s(:call,
s(:call, nil, :fib,
s(:call, s(:lvar, :n), :-, s(:lit, 2))),
:+,
s(:call, nil, :fib,
s(:call, s(:lvar, :n), :-, s(:lit, 1))))))
S-Expression Vocabulary
Sexp
Sub-sexps
s(:call, s(:lit, 3), :+, s(:lit, 4))
Head/
Type
(car)
Rest
(cdr)
All for free using
ruby_parser
OK…
No more talk about
parsing.
Further study on parsers:
Michael Jackson’s
Parsing Expressions in Ruby
MWRC 2011
http://www.confreaks.com/videos/582
Interpreting via
sexp_processor
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
How to get 7 from 3+4?
3 + 4
???
???
7
Start with the source
3 + 4
Parse it
3 + 4
s(:call,
s(:lit, 3),
:+,
s(:lit, 4))
Then process by type
process_call
3 + 4
s(:call,
s(:lit, 3),
:+,
s(:lit, 4))
process_lit
First with the inner values
3 + 4
s(:call,
s(:lit, 3),
:+,
s(:lit, 4))
process_lit
3 + 4
s(:call,
3,
:+,
s(:lit, 4))
process_lit
3 + 4
s(:call,
3,
:+,
4)
then with the outer
process_call
3 + 4
s(:call,
3,
:+,
4)
then with the outer
3 + 4
proc { |a, b|
a + b }[3, 4]
resulting in a final value
3 + 4
proc { |a, b|
a + b }[3, 4]
7
SexpProcessor
class UbyInterpreter
def process_lit s
s.last
end
end
s(:lit, 3)
3
Test Driven
Interpreters
Test Driven
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
Unit Tests
def test_sanity
val = lang.eval("3 + 4")
assert_equal 7, val
end
Unit Tests
Input Source
def test_sanity
val = lang.eval("3 + 4")
assert_equal 7, val
end
Expected Value
Premature Refactoring
def assert_eval exp, src
assert_equal exp, lang.eval(src)
end
def test_sanity
assert_eval 7, "3 + 4"
end
Expected Value
Input Source
Sanity Test:
3+4
Test Driven
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
Test Infrastructure
class TestUbyInterpreter < MiniTest::Unit::TestCase
attr_accessor :int
def setup
self.int = UbyInterpreter.new
end
def assert_eval exp, src, msg = nil
assert_equal exp, int.eval(src), msg
end
end
Our First Test:
attr_accessor :int
def setup
end
Old Code
def assert_eval exp, src
assert_equal exp, ri.eval(src)
end
def test_sanity
assert_eval 3, "3"
end
end
New Code
Our First Test:
Old Code
# ...
def test_sanity
assert_eval 3, "3"
end
end
New Code
Our first error:
# Running tests:
E
Finished tests in 0.000364s, 2747.2527 tests/s, 0.0000
assertions/s.
1) Error:
TestUbyInterpreter#test_sanity:
NameError: uninitialized constant
TestUbyInterpreter::UbyInterpreter
./test/test_ruby_interpreter.rb:11:in `setup'
Define the constant
class UbyInterpreter < SexpInterpreter
VERSION = "1.0.0"
end
Wash, rinse…
# Running tests:
E
assertions/s.
1) Error:
NoMethodError: private method èval' called for
#<UbyInterpreter:0x105be17d8>
./test/test_ruby_interpreter.rb:15:in àssert_eval'
./test/test_ruby_interpreter.rb:19:in `test_sanity'
Implement eval & parse
# ...
attr_accessor :parser
def initialize
super
self.parser = Ruby19Parser.new
end
def eval src
process parse src
end
def parse src
self.parser.process src
end
end
Finally!
# Running tests:
E
assertions/s.
1) Error:
UnknownNodeError: Bug! Unknown node-type :lit to UbyInterpreter
./lib/ruby_interpreter.rb:17:in èval'
Implement process_lit
# ...
def process_lit s
s.last
end
end
Tada! Second Assertion!
1) Error:
UnknownNodeError: Bug! Unknown node-type :call to UbyInterpreter
Define :call generically
# ...
def process_call s
raise "Boom: #{s.inspect}"
end
end
See sub-sexps
1) Error:
RuntimeError: Boom: s(:call, s(:lit, 3), :+, s(:lit, 4))
./lib/ruby_interpreter.rb:35:in `process_call'
Unpack sub-sexps
# ...
def process_call s
_, recv, msg, *args = s
raise "Boom: #{recv}, #{msg}, #{args.inspect}"
end
end
Unpacked sub-sexps
1) Error:
RuntimeError: Boom: s(:lit, 3), +, [s(:lit, 4)]
Process sub-sexps
def process_call s
recv = process recv
args.map! { |sub| process sub }
raise "Boom: #{recv}, #{msg}, #{args.inspect}"
end
end
Processed Values
1) Error:
RuntimeError: Boom: 3, +, [4]
Cheat: Send to Ruby
def process_call s
recv = process recv
recv.send(msg, *args) # big ol' hack…
end
end
Sanity!
# Running tests:
.
assertions/s.
1 tests, 2 assertions, 0 failures, 0 errors, 0 skips
VERSION = "1.0.0"
def initialize
super
self.parser = Ruby19Parser.new
end
def eval src
process parse src
end
Yay!
n
w
o
l
b
Over or!
t
a
l
u
c
l
Ca
def parse src
end
def process_lit s
s.last
end
def process_call s
recv = process recv
end
end
Conditionals
&
Truthiness
Test Driven
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
Add :if tests
# ...
def test_if
assert_eval 42, "if true
end
then 42 else 24 end"
def test_if_falsey
assert_eval 24, "if nil
assert_eval 24, "if false then 42 else 24 end"
end
end
Unknown :if
1) Error:
TestUbyInterpreter#test_if:
UnknownNodeError: Bug! Unknown node-type :if to UbyInterpreter
./test/test_ruby_interpreter.rb:34:in `test_if'
2) Error:
TestUbyInterpreter#test_if_falsey:
UnknownNodeError: Bug! Unknown node-type :if to UbyInterpreter
./test/test_ruby_interpreter.rb:38:in `test_if_falsey'
Define :if generically
# ...
def process_if s
end
end
See sub-sexps
1) Error:
RuntimeError: Boom: s(:if, s(:true), s(:lit, 42), s(:lit, 24))
./lib/ruby_interpreter.rb:38:in `process_if'
...
2) Error:
RuntimeError: Boom: s(:if, s(:nil), s(:lit, 42), s(:lit, 24))
...
Process sub-sexps
# ...
def process_if s
_, c, t, f = s
c = process c
if c then
process t
else
process f
end
end
end
Why
evaluate c
before t &
f?
if true then
puts "happy"
else
system "rm -rf /"
end
Sub-sexps fail
1) Error:
UnknownNodeError: Bug! Unknown node-type :true to UbyInterpreter
2) Error:
UnknownNodeError: Bug! Unknown node-type :nil to UbyInterpreter
Define :nil and :true
# ...
def process_nil s
nil
end
def process_true s
true
end
end
Third failure
1) Error:
UnknownNodeError: Bug! Unknown node-type :false to UbyInterpreter
Define :false
# ...
def process_false s
false
end
end
Voilà!
# Running tests:
...
assertions/s.
Test Driven Process
Add a
failing test
Tests Pass
Process
sub-sexps
Error
node-type
Add generic
node-type
Failure sub-sexp
components
Yes, development
this fast…
with autotest.
Brain Hurt Yet?
Good
Wait till I
get going!
Where was
I?
Local Variables
Test Driven
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
Local Variables!
# ...
def test_lvar
assert_eval 42, "x = 42; x"
end
end
Block?!?
1) Error:
TestUbyInterpreter#test_lvar:
UnknownNodeError: Bug! Unknown node-type :block to UbyInterpreter
./test/test_ruby_interpreter.rb:24:in `test_lvar'
Define :block
# ...
def process_block s
end
end
Ohhh…
1) Error:
RuntimeError: Boom: s(:block, s(:lasgn, :x, s(:lit, 42)),
s(:lvar, :x))
./lib/ruby_interpreter.rb:25:in `process_block'
Process all sub-sexps
# ...
def process_block s
result = nil
s.rest.each do |sub|
result = process sub
end
result
end
end
:lasgn is undefined
1) Error:
UnknownNodeError: Bug! Unknown node-type :lasgn to UbyInterpreter
./lib/ruby_interpreter.rb:26:in èach'
Define :lasgn
# ...
def process_lasgn s
end
end
Looks like name/value
1) Error:
RuntimeError: Boom: s(:lasgn, :x, s(:lit, 42))
./lib/ruby_interpreter.rb:58:in `process_lasgn'
Add a stupid table
# ...
attr_accessor :env
def initialize
# ...
self.env = {} # omg this is horrible
end
def process_lasgn s
_, n, v = s
self.env[n] = process v
end
end
Environment
x
42
Now we need to read
1) Error:
UnknownNodeError: Bug! Unknown node-type :lvar to UbyInterpreter
Access the table
# ...
def process_lvar s
_, name = s
self.env[name]
end
end
Voilà
# Running tests:
....
assertions/s.
Just wait…
It gets “better”
Functions
Test Driven
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
Add :defn Test
# ...
def test_defn
assert_eval nil, <<-EOM
def double n
2 * n
end
EOM
assert_eval 42, "double(21)"
end
end
Unknown :defn
1) Error:
TestUbyInterpreter#test_defn:
UnknownNodeError: Bug! Unknown node-type :defn to UbyInterpreter
./test/test_ruby_interpreter.rb:45:in `test_defn'
Generic :defn
# ...
def process_defn s
end
end
Examine sub-sexps
1) Error:
RuntimeError: Boom: s(:defn,
:double,
s(:args, :n),
s(:call, s(:lit, 2), :*, s(:lvar, :n)))
./lib/ruby_interpreter.rb:44:in `process_defn'
Unpack & Store
# ...
def process_defn s
_, name, args, *body = s
self.env[name] = [args, body]
nil
end
end
Environment
n
8
life
42
pi
3
[
s(:args, :n),
[s(:call,
s(:lit, 2),
:*,
s(:lvar, :n))]
double
]
What’s up with :call?
1) Error:
NoMethodError: undefined method `double' for nil:NilClass
./lib/ruby_interpreter.rb:40:in `send'
No NilClass#double
# ...
def process_call s
recv = process recv
end
end
Isolate the Problem
# ...
def process_call s
recv = process recv
if recv then
recv.send(msg, *args) # less of a hack
else
raise "argh"
end
end
end
Error, Isolated
1) Error:
RuntimeError: argh
Set vars & run the code
# ...
def process_call s
recv = process recv
if recv then
else
decls, body = self.env[msg]
decls.rest.zip(args).each do |name, val|
self.env[name] = val
end
process_block s(:block, *body)
end
end
end
args... decls... zip
bwuh?
args
s(:call, nil, :double, s(:lit, 21))
Environment
n
21
8
life
42
pi
3
[
double
]
decls
decls.rest.zip(args).each do |k, v|
self.env[k] = v
end
s(:args, :n),
[:n].zip([21]).each do |k, v|
self.env[k] = v
end
s(:call,
s(:lit, 2),
:*,
s(:lvar, :n))
self.env[:n] = 21
Voilà!
# Running tests:
.....
assertions/s.
“Getting to green just means
you don’t have enough
tests.”
– Kent Beck
Fibonacci
Test Driven
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
Finally Freakin’ Fibonacci!
# ...
def test_fib
assert_eval nil, <<-END
def fib n
if n <= 2 then
1
else
fib(n-2) + fib(n-1)
end
end
END
assert_eval 8, "fib(6)"
end
end
Whoa… it ran… but failed
1) Failure:
TestUbyInterpreter#test_fib [./test/test_ruby_interpreter.rb:
71]:
Expected: 8
Actual: 3
That stupid Table?
Yeah...
Environment
n
4
6
8
life
42
pi
3
[
fib
]
def fib n
if n <= 2 then
1
else
fib(n-2) + fib(n-1)
end
end
s(:args, :n),
n = 8; fib(6)
s(:if, ...)
n = 6; fib(4) + fib(5)
n = 4; ... and so on...
Wanted: Stacked Hash
fib(1)
fib(3)
fib(5)
original
n
n
1
but acts like:
n
n
3
life
n
5
n
8
n
life
42
life
pi
3
pi
pi
42
5
fib
fib
fib
s(:if, ...)
]
42
3
[
3
s(:args,
:n),
[ 42 s(:if, ...)
8 s(:args,
] :n),
3
42 s(:if, ...)
[
]
s(:args,
:n),
3
fib
s(:if, ...)
]
3
s(:if, ...)
[
]
s(:args, :n),
[
s(:args, :n),
fib
pi
life
pi
life
n
1
Environment Class
env[:x] = 42
scope:
scope:
scope:
env[:x] == ?
x
42
a
1
b
2
c
3
x
4
y
5
z
6
all:
a
1
b
2
c
3
x
42
y
5
z
6
# ...
class Environment
def [] k
self.all[k]
end
def []= k, v
@env.last[k] = v
end
def all
@env.inject(&:merge)
end
def scope
@env.push({})
Reads from everything
Writes to top layer only
Flattened. Newest wins
Automatic layering
yield
ensure
@env.pop
end
def initialize
@env = [{}]
end
end
end
Replace stupid table
# ...
def initialize
# ...
self.env = Environment.new
end
# ...
end
Scope every call
# ...
def process_call s
recv = process recv
if recv then
else
self.env.scope do
decls.rest.zip(args).each do |name, val|
self.env[name] = val
end
end
end
end
end
Finally
# Running tests:
......
assertions/s.
While Loops
Test Driven
Functions
Loops
Variables
Conditionals
Environment
Runtime
Parser
Refactor Fibonnaci
# ...
def define_fib
def fib n
if n <= 2 then
1
else
fib(n-2) + fib(n-1)
end
end
END
end
end
Add :while tests
# ...
def test_while_sum_of_fibs
define_fib
assert_eval 1+1+2+3+5+8+13+21+34+55, <<-EOM
n = 1
sum = 0
while n <= 10
sum += fib(n)
n += 1
end
sum
EOM
end
end
Unknown :while
1) Error:
TestUbyInterpreter#test_while_fib:
UnknownNodeError: Bug! Unknown node-type :while to
UbyInterpreter
./test/test_ruby_interpreter.rb:86:in `test_while_fib'
Define :while generically
# ...
def process_while s
raise "Boom: #{s.inspect}
end
end
See sub-sexps
1) Error:
TestUbyInterpreter#test_while:
RuntimeError: Boom: s(:while,
s(:call, s(:lvar, :n), :<, s(:lit, 41)),
s(:lasgn, :n, s(:call, s(:lvar, :n),
:+, s(:lit, 1))),
true)
./lib/ruby_interpreter.rb:104:in `process_while'
./test/test_ruby_interpreter.rb:62:in `test_while'
Define :while
# ...
def process_while s
_, cond, *body = s
body.pop # pre vs post condition -- ignore for now
while process cond
end
end
end
Voilà
# Running tests:
.......
assertions/s.
What Have
We Done?
require "ruby_parser"
require "sexp_processor"
class UbyInterpreter <
SexpInterpreter
VERSION = "1.0.0"
attr_accessor :env
def initialize
super
self.parser = Ruby19Parser.
new
self.env = Environment.new
end
def eval src
process parse src
end
def parse src
end
def process_block s
result = nil
s.rest.each do |sub|
result = process sub
end
result
end
def process_call s
recv = process recv
args.map! { |sub|
process sub }
if recv then
recv.send(msg, *args)
else
d, body = self.env[msg]
self.env.scope do
d.rest.zip(args).
each do |k, v|
self.env[k] = v
end
process_block s(:block,
*body)
end
end
end
def process_defn s
_, name, args, *body = s
self.env[name] = [args,
body]
nil
end
def process_false s
false
end
def process_if s
_, c, t, f = s
c = process c
if c then
process t
else
process f
end
end
def process_lasgn s
_, name, val = s
self.env[name] = process val
end
def process_lit s
s.last
end
def process_lvar s
_, name = s
self.env[name]
end
def process_nil s
nil
end
def process_true s
true
end
def process_while s
_, cond, *body = s
body.pop
while process cond
process_block s(:block,
*body)
end
end
class Environment
def [] k
self.all[k]
end
def []= k, v
@env.last[k] = v
end
def all
@env.inject(&:merge)
end
def scope
@env.push({})
yield
ensure
@env.pop
end
def initialize
@env = [{}]
end
end
end
attr_accessor :int
def test_fib
define_fib
def setup
end
assert_eval 8, "fib(6)"
end
def assert_eval exp, src, msg = nil
assert_equal exp, int.eval(src), msg
end
def test_if
assert_eval 42,
"if true then 42 else 24 end"
end
def define_fib
def fib n
if n <= 2 then
1
else
fib(n-2) + fib(n-1)
end
end
END
end
def test_sanity
assert_eval 3, "3"
end
def test_defn
assert_eval nil, <<-EOM
n = 24
def double n
2 * n
end
EOM
assert_eval 42, "double(21)"
end
def test_if_falsey
assert_eval 24,
"if nil
assert_eval 24,
"if false then 42 else 24 end"
end
def test_lvar
assert_eval 42, "x = 42; x"
end
def test_while_fib
define_fib
assert_eval 1+1+2+3+5+8+13+21+34+55, <<-EOM
n = 1
sum = 0
while n <= 10
sum += fib(n)
n += 1
end
sum
EOM
end
end
“Uby” Language
•
•
•
•
•
•
•
Basic numeric types, true, false, nil.
Conditional branching and looping.
Primitive & user defined functions.
Local variables & variable scoping.
Test-driven, extensible, patterns-based design.
~2 hours, ~130 LOC impl, ~70 LOC test.
Fits in one head.
What Else Can We Do?
• Add richer types: strings, arrays, hashes, etc.
• Enforce different scoping rules (eg. ruby's
opaque def).
• Implement recursive tail-calls.
• Add an object system.
• Change the way functions are called.
Further Study
s
a
t
n
a
F
o
B
c
i
t
s
k
o
No time for
questions?
Please grab me in
the hallway.
Thank You…
Bonus:
Life Tip
Typeface:
Livory
Ruby
bgkpq
Th Qu ∂
Scoring Ligatured Words
ligatures = /NN|OO|TT|Qu|fff|tt|www|[HMN]E|[HN]K|(?:ff|[Tcfs])h|
(?:ff|[cfs])k|(?:ff|[cfi])t|(?:ff|it|tt|[frt])y|[is]p|tt?i|O[CG]|
i[vw]|ff?[bj]/
dict = File.readlines("/usr/share/dict/words").map(&:chomp)
words = Hash.new 0
dict.each do |word|
start = 0
hits = word.scan(ligatures)
words[word] = hits.size unless hits.empty?
end
words.sort_by { |w,v| [-v, w] }.each do |word, score|
puts "%2d: %s" % [score, word]
end
Architectonica
penitentiaryship
antiproductivity
Thank You

Trolls of 2013 - zenspider.com

Transcription

Similar documents

Eine kurze Einführung