Metaprogramming? Not good enough!

Metaprogramming?
Not good enough!
Justin Weiss
@justinweiss | #tinyobj

View Slide


View Slide

→ 2005: Ruby

View Slide

→ 2005: Ruby
→ 2006: JavaScript Ruby

View Slide

→ 2005: Ruby
→ 2007: Erlang Ruby

View Slide

→ 2005: Ruby
→ 2007: Erlang Ruby
→ ...
→ 2015: Swift Ruby

View Slide

What makes Ruby, Ruby?

View Slide


View Slide

Erlang = Actors

View Slide

Erlang = Actors
Haskell = Monads

View Slide

Erlang = Actors
Haskell = Monads
Lisp = Parentheses

View Slide

Erlang = Actors
Haskell = Monads
Lisp = Parentheses Macros

View Slide

Erlang = Actors
Haskell = Monads
Lisp = Parentheses Macros
Ruby = Metaprogramming?

View Slide


View Slide

Metaprogramming → !?

View Slide


View Slide

A brand new
object model
(on top of Ruby)

View Slide

Object model
The concepts, data structures, and methods
you use to build things in your language

View Slide


View Slide

I. Piumarta and A. Warth
Open, Extensible Object Models
http://piumarta.com/software/cola/
objmodel2.pdf

View Slide

When you have a method
name and arguments,
which code do you use?

View Slide

def lookup(object, method_name)
# Look up a method by name in object's methods list
# If it exists, return it
# Otherwise, if you have a parent class, recurse
end

View Slide


View Slide

What is behavior?

View Slide


View Slide

Object = a thing
Class = a thing that builds objects, holds
methods, has a parent
Behavior = a thing that holds methods like
lookup and add_method

View Slide

Object
add_method
lookup

View Slide

How do we get an object
from a class?

View Slide

Object
add_method
lookup
build_object

View Slide

What about new classes,
sub-classes, or sub-
behaviors?

View Slide

Object
add_method
lookup
build_object
delegate

View Slide

How do you call a
method?

View Slide

Object
add_method
lookup
build_object
delegate
send

View Slide

Let's build it in Ruby!

View Slide

class TinyObject < BasicObject
attr_accessor :state
attr_accessor :behavior
end

View Slide

Create the core methods

View Slide

behavior_add_method = lambda do |behavior, method_name, method|
behavior.state[:methods][method_name] = method
end

View Slide

behavior_add_method = lambda do |behavior, method_name, method|
# -------^
behavior.state[:methods][method_name] = method
end

View Slide

behavior_lookup = lambda do |behavior, method_name|
# ...
end

View Slide

# Look up a method by name in the object's methods list
method = behavior.state[:methods][method_name]
# ...
method
end

View Slide

# ...
# If you can't find it, but have a parent class...
if !method && behavior.state[:parent]
# call this method recursively, using the parent instead
method = behavior_lookup.call(behavior.state[:parent], method_name)
end
method
end

View Slide

# Look up a method by name in the object's methods list
# If you can't find it, but have a parent class...
if !method && behavior.state[:parent]
# call this method recursively, using the parent instead
method = behavior_lookup.call(behavior.state[:parent], method_name)
end
method
end

View Slide

behavior_build_object = lambda do |behavior|
# Allocate an object
obj = TinyObject.new
obj.state = {}
# set the object's class / behavior
# to yourself (the class that called this method)
obj.behavior = behavior
# return the object
obj
end

View Slide

behavior_delegate = lambda do |parent_class|
# ...
end

View Slide


View Slide

subclass = behavior_build_object.call(parent_class.behavior)

View Slide

# set the object's parent (in its state) to ourselves
subclass.state[:parent] = parent_class
# initialize the object's state with an empty set of methods
subclass.state[:methods] ||= {}
subclass

View Slide

behavior_delegate = lambda do |parent_class|
parent_class_behavior = parent_class && parent_class.behavior
subclass = behavior_build_object.call(parent_class_behavior)
# set the object's parent (in its state) to ourselves
subclass.state[:parent] = parent_class
# initialize the object's state with an empty set of methods
subclass.state[:methods] ||= {}
subclass
end

View Slide

TinyObject: Our object structure, containing behavior and state
behavior_add_method: Add a method to a class
behavior_lookup: Find an implementation, from a method name
behavior_build_object: Like .new, build an object from a class /
behavior
behavior_delegate: Inherit from a class / behavior

View Slide


View Slide

default_behavior = behavior_delegate.call(nil)
# ...

View Slide

default_behavior.behavior = default_behavior

View Slide

root_object_class = behavior_delegate.call(nil)
root_object_class.behavior = default_behavior

View Slide

# ...
default_behavior.state[:parent] = root_object_class

View Slide

default_behavior.behavior = default_behavior
root_object_class = behavior_delegate.call(nil)
root_object_class.behavior = default_behavior
default_behavior.state[:parent] = root_object_class

View Slide

behavior_add_method.call(default_behavior,
"lookup",
behavior_lookup)
"add_method",
behavior_add_method)
"build_object",
behavior_build_object)
"delegate",
behavior_delegate)

View Slide


View Slide

object_send = lambda do |object, method_name, *args|
method = find_method.call(object, method_name)
if method
method.call(object, *args)
else
raise "No method #{method_name} found on object"
end
end

View Slide

find_method = lambda do |object, method_name|
object_send.call(object.behavior, "lookup", method_name)
end

View Slide

find_method = lambda do |object, method_name|
if (object == default_behavior && method_name == "lookup")
behavior_lookup.call(default_behavior, "lookup")
else
object_send.call(object.behavior, "lookup", method_name)
end
end

View Slide

behavior_add_method: Add a method to a class
behavior_lookup: Find an implementation, from a method name
behavior_build_object: Like .new, build an object from a class /
behavior
behavior_delegate: Inherit from a class / behavior
object_send: Call a method, by name, on an object

View Slide

greeter_class = object_send.call(root_object_class, "delegate")

View Slide

greeter_class = object_send.call(root_object_class, "delegate")
object_send.call(greeter_class, "add_method", "hello",
lambda { |object| puts "Hello, world!" })

View Slide

greeter = object_send.call(greeter_class, "build_object")
object_send.call(greeter, "hello") # =>

View Slide

object_send.call(greeter, "hello") # => "Hello, world!"

View Slide


View Slide

object_send.call(greeter, "hello") # => "Hello, world!"

View Slide


View Slide

class TinyObject < BasicObject
attr_accessor :state
attr_accessor :behavior
def method_missing(name, *args)
object_send = nil
behavior = self.behavior
# Crawl our ancestors for an "object_send" implementation
while !object_send && behavior
object_send = behavior.state[:methods]["object_send"]
behavior = behavior.state[:parent]
end
# Call object_send on ourselves
object_send.call(self, name.to_s, *args)
end
end

View Slide

object_send.call(greeter, "hello")

View Slide

object_send.call(greeter, "hello")
⬇
greeter.hello

View Slide

behavior_add_method.call(root_object_class, "object_send",
object_send)

View Slide

greeter_class.add_method("hello_name",
lambda { |object| puts "Hello, #{object.state[:name]}!" })
# ----^

View Slide

alice = greeter_class.build_object
bob = greeter_class.build_object
alice.state[:name] = "Alice"
bob.state[:name] = "Bob"
alice.hello_name # =>
bob.hello_name # =>

View Slide

alice = greeter_class.build_object
bob = greeter_class.build_object
alice.state[:name] = "Alice"
bob.state[:name] = "Bob"
alice.hello_name # => "Hello, Alice!"
bob.hello_name # => "Hello, Bob!"

View Slide

Now what?

View Slide

Log method calls!

View Slide

def lookup
# Get the old lookup method from the parent of our behavior
# Call it to find the real method implementation
# Wrap the method and return it
end

View Slide

method_logger = lambda do |method_name, method, *args|
puts "> Calling #{method_name}... "
method.call(*args)
puts "> Done!"
end

View Slide


View Slide

intercepting_behavior = default_behavior.delegate

View Slide

intercepting_behavior.add_method(
"lookup",
lambda do |sender, method_name|
# Get the old lookup method from the parent of our class's behavior
lookup = object_send.call(sender.behavior.state[:parent], "lookup", "lookup")
# Call it to find the real method implementation
method = lookup.call(sender, method_name)
if method
original_method = method
interceptor = sender.state[:interceptor_method]
method = lambda { |*args| interceptor.call(method_name, original_method, *args) }
end
method
end
)

View Slide

# Get the old lookup method
# from the parent of our class's behavior
super_behavior = ?
lookup = super_behavior.lookup("lookup")

View Slide

super_behavior = sender.behavior.state[:parent]

View Slide

# Get the old lookup method
# from the parent of our class's behavior
super_behavior = sender.behavior.state[:parent]
# Call lookup to find the real method implementation
method = lookup.call(sender, method_name)

View Slide

if method
original_method = method
interceptor = sender.state[:interceptor_method]
method = lambda do |*args|
interceptor.call(method_name, original_method, *args)
end
end
method

View Slide


View Slide

person_class = root_object_class.delegate
# ...

View Slide

person_class.behavior = intercepting_behavior

View Slide

# ...

View Slide

person_class.behavior = intercepting_behavior

View Slide

method_logger = lambda do |method_name, method, *args|
puts "> Calling #{method_name}... "
method.call(*args)
puts "> Done!"
end
person_class.state[:interceptor_method] = method_logger

View Slide

person_class.add_method "name", lambda { |_| puts "Justin" }
person_class.add_method "location", lambda { |_| puts "Cincinnati, OH" }

View Slide

person = person_class.build_object
person.name
#
#
#
person.location
#
#
#

View Slide

person = person_class.build_object
person.name
# > Calling name...
# Justin
# > Done!
person.location
# > Calling location...
# Cincinnati, OH
# > Done!

View Slide


View Slide

person_class.behavior = default_behavior
person.name
#

View Slide

person_class.behavior = default_behavior
person.name
# Justin

View Slide

Retry method calls!

View Slide

person_class.add_method("flaky_method", lambda do |_|
if rand(3) == 0
puts "Success!"
true
else
false
end
end)

View Slide

retry_interceptor = lambda do |method_name, method, *args|
until method.call(*args)
puts "Method #{method_name} failed, retrying..."
sleep 0.5
end
end

View Slide

person_class.state[:interceptor_method] = retry_interceptor
person.flaky_method

View Slide

person.flaky_method
# Method flaky_method failed, retrying...

View Slide

person.flaky_method

View Slide

person.flaky_method
# Success!

View Slide


View Slide

Multiple Inheritance

View Slide


View Slide

multiple_parents_behavior = default_behavior.delegate

View Slide

multiple_parents_behavior.add_method("add_parent",
lambda do |behavior, new_parent|
# Initialize `parents` with the original parent
unless behavior.state[:parents]
behavior.state[:parents] = []
parent = behavior.state[:parent]
behavior.state[:parents] << parent if parent
end
# Append the new parent to `parents`
behavior.state[:parents] << new_parent
end
)

View Slide

multiple_parents_behavior.add_method(
"lookup",
lambda do |behavior, method_name|
parents = behavior.state[:parents] ||
[behavior.state[:parent]]
if !method && parents
parents.each do |parent|
break if method = parent.lookup(method_name)
end
end
method
end
)

View Slide

multiple_parents_behavior.add_method(
"lookup",
lambda do |behavior, method_name|
parents = behavior.state[:parents] ||
[behavior.state[:parent]]
if !method && parents
parents.each do |parent|
# v---- -----^
break if method = parent.lookup(method_name)
end
end
method
end
)

View Slide

person_class.add_method "name", lambda { |_| puts "Justin" }
greeter_class = root_object_class.delegate
greeter_class.add_method "greeting", lambda { |_| puts "Hello! Hello! Hello!" }

View Slide

social_person_class = person_class.delegate
social_person_class.behavior = multiple_parents_behavior
social_person_class.add_parent(greeter_class)

View Slide

justin = social_person_class.build_object
justin.name # =>
justin.greeting # =>

View Slide

justin = social_person_class.build_object
justin.name # => "Justin"
justin.greeting # => "Hello! Hello! Hello!"

View Slide

→ Single inheritance
→ Interception
→ Multiple Inheritance

View Slide

→ Object
→ add_method
→ lookup
→ build_object
→ delegate
→ send

View Slide

Modules?
method_missing?
BasicObject?
delegation?

View Slide

Intent

View Slide

What's normal?

View Slide


View Slide

What? Why!?

View Slide


View Slide

The best way to
understand a system is to
break it.

View Slide

symbols.each do |symbol|
klass = Class.new(ActiveRecord::Base) do
def method_missing(name, *args)
# ...
end
end
Object.const_set(symbol.to_s.capitalize, klass)
end

View Slide


View Slide

Try it out

View Slide

Thank you!
Justin Weiss
@justinweiss
https://www.avvo.com
[email protected]
https://www.justinweiss.com/
rubyconf-2016

View Slide

The Ruby logo is Copyright © 2006, Yukihiro Matsumoto. It is
licensed under the terms of the Creative Commons Attribution-
ShareAlike 2.5 License agreement.
"Happy Programmers" by Jesper Rønn-Jensen, used under CC BY-
SA 2.0 / Resized from original
"Laptop Stickers" by Nate Angell, used under CC BY 2.0 / Resized
from original
"No Brain" by Pierre-Olivier Carles, used under CC BY 2.0

View Slide

Metaprogramming? Not good enough!

Metaprogramming? Not good enough!

Justin Weiss

More Decks by Justin Weiss

Other Decks in Programming

Featured

Transcript