Design patterns are the enemy of agility. They introduce repetition and accidental variation to your codebase. Design patterns encourage you to create "point solutions" throughout your application, instead of cleanly isolating concerns. And they will make your code refactor-proof, no matter how cool your IDE is. But there is hope: Catch your design patterns while they are young, and teach them to be library calls instead. Here's one example:

In Ruby, we often re-open existing classes and add instance methods. One approach is simply to open the class:

  class NilClass
    def blank? 
      true
    end
  end

Or, you could create a new module and mix it in:

  module MyNilExtensions
    def blank?
      true
    end
  end
  class NilClass
    include MyNilExtensions
  end

There are other approaches that are similar but not quite the same. In other words, this is a design pattern. From the Wikipedia entry:

A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations.

The problem with design patterns is the "not a finished design" part of the definition. Rather that a DRY solution, design patterns give you repetition throughout the code. Worse yet, the repetition is not exact. It is repetition with variation, and there is often no evidence whether the variation is intentional or accidental.

I like Ruby because I can eliminate design patterns when they start to annoy me. This "Open Class Add Method" pattern annoyed me for the last time earlier today, when two different libraries defined incompatible versions of Object#metaclass. Enough is enough. Let's make a library call for reopening classes.

Here are my design goals:

1. The syntax should be terse. I hate defining a module and including it in two separate steps, I just want to open a block and go.
2. I should have an audit trail for where new methods came from. (This is one reason to define a named model, because I can then reflect against it.)
3. I should be protected from method collisions. This protection should be configurable. Collisions can be explicitly approved, or they can generate a warning, or an error.

These three goals are in conflict (and we could easily come up with more). This illustrates another problem with design patterns. Each time a design pattern is used, a programmer favors some design goals over others. Over time, this leads to a codebase at odds with itself. If the same pattern were captured in a reusable module, then changing design priorities could be handled from that module alone.

Here's a strawman proposal for cleanly adding methods to existing Ruby classes. The following code adds #jump to Object:

  embrace{Object}.and_extend do
    def jump
      puts "jumping"
    end
  end

The syntax is simple and involves just one block, meeting goal one. Behind the scenes, I use __FILE__ and __LINE__ to define a module, which gives us auditability (goal two):

  > puts Object.ancestors
  Object
  Anonymous module from /Users/stuart/Desktop/temp.rb 56
  Kernel  

Finally, the code that mixes in the module walks the inheritance hierarchy first, printing a warning whenever a name collision is encountered (goal three).

  Warning: /Users/stuart/Desktop/temp.rb 64 is attempting to redefine jump
           Originally defined in /Users/stuart/Desktop/temp.rb 56  

The complete implementation is included at the bottom of this post. I am sure it can be improved in several ways, but even in its primitive state it beats a design pattern. As long as the API is decent, we can always make the implementation suck less later.

Should I make a gem out of this? What changes would you like to see in the API? How should the handling of method collisions be specified?

  require 'set'
  module Embrace
    class <<self
      def check_for_collisions(clazz, module_to_include)
        new_methods = Set.new(module_to_include.instance_methods(false))
        clazz.ancestors.each do |anc|
          anc.instance_methods(false).each do |meth|
            collision(anc, module_to_include, meth) if new_methods.member?(meth)
          end
        end
      end

      def collision(clazz, module_to_include, method)
        puts "Warning: #{module_to_include} is attempting to redefine #{method}"
        puts "         Originally defined in #{clazz}"
      end
    end
  end

  def embrace(&clazz_block)
    m = Module.new
    file = eval("__FILE__", clazz_block.binding)
    line = eval("__LINE__", clazz_block.binding)
    clazz = clazz_block.call
    meta = class << m; self; end
    meta.class_eval do
      def and_extend(&blk)
        self.class_eval(&blk)
        mixin_to_class
        self
      end
      define_method("mixin_to_class") do
        Embrace.check_for_collisions(clazz, m)
        clazz.class_eval do
          include m
        end
      end
      define_method("to_s") do
        "Anonymous module from #{file} #{line}"
      end
    end   
    m 
  end

  o = Object.new

  embrace{Object}.and_extend do
    def jump
      puts "jumping"
    end
  end

  o.jump

  embrace{Object}.and_extend do
    def jump
      puts "jumping higher"
    end
  end

  o.jump