Are Class Methods Evil?

{{{
Two things I like in programming: *Object instances and abandoning global things.*

I especially “appreciate any DCI effort”:http://andrzejonsoftware.blogspot.com/2011/02/dci-and-rails.html in the community helping us getting away from classes back to thinking about objects and clean responsibilities.

In order to explain my thoughts about DCI, here’s a first post about class methods, which seem to be a crucial problem in this newer approach.

A “tweet from my good friend Michał Łomnicki”:https://twitter.com/#!/mlomnicki/status/91880084784414721 recently made me *think about class methods* in Ruby. What he was basically saying is that class methods suck.

I’m more and more against using class methods. It often leads to procedural-like programming.

From a rant perspective I’ll second that and agree. However, class methods have a certain purpose, so let’s discuss it in this post.

h3. What Is a Class Method?

*Class methods are global methods.* You may access and call them from anywhere since you *don’t need an object instance*.

class User
  def self.find(id)
    # ...
  end
end

In order to find a certain @User@ instance you call the class method @#find@ on the @User@ class. I personally find *this a handy thing.*

michal = User.find(1)

As we’re creating a fresh instance we *command the class to do so*. And since there is no _user_ instance around, yet, we have to use a class method rather than an instance method.

h3. What’s the Problem With Class Methods?

Now, class methods come in handy – you don’t have to think about the context *as they’re available everywhere*. Consider the following misuse of a class method.

class User
  def self.email_to(id, email)
    user = User.find(id)
    Emailer.send(email, "Hello, #{user.name}")
  end

It’s obvious that @#email_to@ has to be *refactored to an instance method*. Nevertheless, I see code like that quite often. Just for completeness, here’s a better version.

class User
  def email_to(email)
    Emailer.send(email, "Hello, #{name}")
  end

h3. Object-oriented vs. Procedural

What makes the *class method example being _bad style_* is that we’re in an object-oriented environment. Maybe we can break that down to the advise *_”Use object instances wherever possible.”_*

In the example, the programmer didn’t see that *the email behaviour (aka method) is tied to an instance* rather than to a class. His user code will look like the following.

User.email_to(1, "michal@snatch.pl")

If subsequent method calls like this would follow, *this could be considered _procedural_ code as we’re not working on object instances* but on globally available methods. And, yeah, I personally don’t like global things when it comes to programming.

h3. Avoiding Class Methods

Right now, I can come up with two reasons for having class methods.

* The programmer didn’t analyze his problem sufficiently, *does _not_ see the coupling to an instance* and simply pushes the behaviour into a class method. That happened in the last example.
* There simply is *_no_ object instance available* at this system state and we’re urged to use a class method.

On first sight, there seems to be no way out for the latter.

h3. Abandoning Class Methods?!

There are strong opinions on the net that *class methods shouldn’t be used at all* (except for the constructor, of course). I’m still unsure here.

Anyway, in a lot of cases class methods can be *replaced with instance methods on _factory_ or _builder_ objects*.

michal = user_factory.find(1)

This implies a @user_factory@ instance is around. So my question is: Where would this come from? *There must be some kind of initial class method call* somewhere in the chain of actions. I’d love to see some reactions and comments on that.

h3. Class Methods and DCI

The reason I’m writing this here is that I like the DCI approach where you *dynamically extend objects at runtime according to _system state_*.

Object instances include required behaviour and then, they die. No pollution on class layer.

This works great with instance methods but there are big problems when it comes to class method usage (see the next post). *So – are class methods evil?*
}}}