I’ve often felt like the sour faced developer for not loving Patterns. It’s not that I can’t see their use, labeling a mechanism or concept so everyone talks the same language is a good thing. However, I’ve always felt uncomfortable about the proliferation of patterns, seems like there is someone wanting to gain fame by naming some blindingly obvious concept. But this has always seemed such a feeble argument against patterns (and it probably is). Today I finally discovered a rather obvious reason why the majority of patterns may well be a waste of time. One of the basic idea of a designing using patterns is to locate a pattern and use it as a template to writing some code. Indeed you can find ‘pattern explorers’ in many development tools encouraging the developer to select patterns to solve problems and indeed for one pattern to lead to another. The major problem for this use of patterns is that it encourages developers to develop many components using the same pattern, just the sort of maintenance headache we strive to avoid. Whereas what should really happen is that we should consider the pattern as an abstraction of the problem. When you get into that mindset then you’ll see that the abstraction itself is a potential object and therefore should be implemented. That way you’ll end up with the one object containing implementing the ‘pattern’ and others using or deriving from it.
To read more sober arguments for and against, see good old wikipedia