In a previous article I took an example of bad metaprogramming and I pushed people to think twice before using metaprogramming.
My main points were that:
- you might make your code way slower if you don’t know what you are doing
- readability might drop considerably
- maintainability can become an issue
People left some very good comments about how to write the same module using metaprogramming and keep things fast.
Today Wycats pinged me about this post and told me that the issue was definemethod and that classeval is effectively the same as regular code, it gets evaluated in eval.c, just like regular Ruby code. On the other hand, defined_method has to marshall the proc.
I cleaned up my benchmarks using rbench, added some of the solutions provided to me and obtained the following results:
Here is the original/bad metaprogramming example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
module MetaTimeDSL
{:second => 1,
:minute => 60,
:hour => 3600,
:day => [24,:hours],
:week => [7,:days],
:month => [30,:days],
:year => [364.25, :days]}.each do |meth, amount|
define_method "#{meth}" do
amount = amount.is_a?(Array) ? amount[0].send(amount[1]) : amount
self * amount
end
alias_method "#{meth}s".intern, "#{meth}"
end
end
Numeric.send :include, MetaTimeDSL
|
The no metaprogramming module is available there
Refactored:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
module RefaMetaTimeDSL
{:second => 1,
:minute => 60,
:hour => 3600,
:day => [24,:hours],
:week => [7,:days],
:month => [30,:days],
:year => [364.25, :days]}.each do |meth, amount|
self.class_eval <<-RUBY
def r_#{meth}
#{amount.is_a?(Array) ? "#{amount[0]}.#{amount[1]}" : "#{amount}"}
end
alias_method :r_#{meth}s, :r_#{meth}
RUBY
end
end
Numeric.send :include, RefaMetaTimeDSL
|
the refactor 2 or eval based solution provided by Matt Jones which uses class_eval like the previous refactor.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
module EvalMetaTimeDSL
def self.included(base)
base.class_eval do
[ [:e_second, 1],
[:e_minute, 60],
[:e_hour, 3600],
[:e_day, [24,:e_hours]],
[:e_week, [7,:e_days]],
[:e_month, [30,:e_days]],
[:e_year, [365.25, :e_days]]].each do |meth, amount|
amount = amount.is_a?(Array) ? amount[0].send(amount[1]) : amount
eval "def #{meth}; self*#{amount}; end"
alias_method "#{meth}s", meth
end
end
end
end
Numeric.send :include, EvalMetaTimeDSL
|
and finally, the “better metaprogramming” version:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
module GoodMetaTimeDSL
SECOND = 1
MINUTE = SECOND * 60
HOUR = MINUTE * 60
DAY = HOUR * 24
WEEK = DAY * 7
MONTH = DAY * 30
YEAR = DAY * 364.25
%w[SECOND MINUTE HOUR DAY WEEK MONTH YEAR].each do |const_name|
meth = const_name.downcase
class_eval <<-RUBY
def g_#{meth}
self * #{const_name}
end
alias g_#{meth}s g_#{meth}
RUBY
end
end
Numeric.send :include, GoodMetaTimeDSL
|
Looking at the refactored version by Wycats, you can see he’s right and the major issue with the original version was definemethod. Using classeval does make things almost as fast and even faster than the no metaprogramming version.
Interesting enough, the benchmarks show that some methods from the meta modules are faster than the ones from the no meta module. Overall, an optimized metaprogramming can be more or else as fast as a non meta code. Of course, with the new VMs coming up, things might change a little bit depending on the language implementation.
In conclusion, metaprogramming can be as fast as no metaprogramming but that won’t help your code readability and maintainability, so make sure to only use this great trick when needed!
p.s: here is the benchmark file if you don’t believe me 
