Keep It Simple - Make It Simpler

I like Google philosophy a lot, especially Thing Number 9 :

9. You can be serious without a suit.

, but that's not the subject of this sermon; today I'd like to tell you about Thing Number Two (TNT) :

2. It's best to do one thing really, really well.

- Amen -, and its IT translation : the "Separation Of Concerns". At the humble coder's level, separated concerns make for a more readable code. Counter example:

def fetch_stuff(*args)
  benchmark = Benchmark.measure{
    Stuff.fetch_all
  }
  puts "time spent: #{benchmark} "
end

It's ugly, but it works. It works, but it's ugly: this code does TWO completely unrelated things:

fetch some stuff, and
benchmark an action, any action

We MUST find a way to separate those 2 concerns: The first and main concern is obvious :

123	def fetch_stuff Stuff.fetch_all # <<--- CONCERN 1 end

The second concern is easy to code

def generic_benchmarking_method
  benchmark = Benchmark.measure
    action_to_measure   # <<--- (concern 1)       
  }
  puts "time spent : #{benchmark}}" # <<--- CONCERN 2
end

but it's difficult to connect to the first method, because :

users of concern 1 should not have to know about concern 2 => they will just call the first method
as the benchmarking action is completely independent from the action it measures, this action should be passed as a parameter in some way

The solution: piggy-back the benchmarking method on the fetching method, transparently. Q: how do you piggy back ? A: with Rails' alias_method_chain , and some "convention over configuration magic"** (** hint: it's all in the methods naming) Take a deep breath and watch the mystery unveil :

Before

def fetch_stuff(*args)
  benchmark = Benchmark.measure{
    Stuff.fetch_all
  }
  puts "time spent: #{benchmark} "
end

After

# concern 1: just do it.
def fetch_stuff
  Stuff.fetch_all
end

# concern 2: just benchmark it.
def fetch_stuff_with_benchmarking(*args)
  benchmark = Benchmark.measure{
  fetch_stuff_without_benchmarking(*args)
  }
  puts "time spent: #{benchmark} "
end

alias_method_chain :fetch_stuff, :benchmarking

That's it : alias_method_chain wrapped benchmarking around fetch_stuff. After line 14 has been parsed, calls to the original fetch_stuff are redirected to fetch_stuff_with_benchmarking, and fetch_stuff_without_benchmarking points to the original fetch_stuff. It's transparent and automatic. All you have to do is respect the naming convention : with and without. That's it. This method was introduced in Rails a year ago to DRY up the internals. There is no reason your code should not benefit shamelessly from it too. Strive for it. You'll thank me later.