I wrote this one early on in 2006…
Having spent more years than I'd care to count in the company of developers, I can tell you that we are all different. As a class, we developers tend to be relaxed about our personal appearance. But then there was the guy I worked with who could discuss shoes. For hours. We coders seem to more musical than average, but I remember one coworker who had all the musical sense of Ulysses S. Grant: He could only recognize two songs. One was Yankee Doodle. The other wasn't. Politically we are more liberal than average except when we are more conservative.
The only thing we all seem to have in common is that we like to overdo things. Software things. Computer things. Technical things. Some of us control the urge better than others, but you give a developer some new technology or methodology or language and we will use it and use it, over and over until it breaks or catches fire or the neighbors call the police.
The most obvious example of this is probably the silver hammer of object oriented programming, inheritance. If your intro to OO programming was like mine, you spent 10 minutes on information hiding, 22 minutes on scope and visibility issues, and the rest of the week talking about the big I.
We learned that
Car could inherit a fuel tank and a max speed from
InterestBearingAccount could get its balance from plain old
Account and that the only reason
Sparrow could fly was because it was a specialization of
Bird. And we poured forth from that classroom to inherit everything from anything: who are we to turn down some free implementation?
At first we went deep.
PerspectiveBuyers who were
BaseTaxPayers who were
AbstractHumans who happened to be
HairlessPrimates or maybe
ProtoplasmicBlobs. When that didn't work we went wide, first with C++'s multiple inheritance and later with Java's multiple interfaces. Doesn't matter, multiple was where it was at:
Customers were not just
People they were also
PreferenceContainer'ed, not to mention
Then we saw that all our programs, well, they lacked a certain pattern. Soon all of our singletons were composite, we could use the factory method on our abstract factory to get the prototype of the builder which would make a proxy for the decorated adapter that acted as a facade for the visitor which took us to see all of our singletons. And still it was not right.
But maybe the fault lies not with our stars…er..classes but in our methodologies. So we went in for extreme RUP'ing. We UML'ed until we were too sore to have a good agile scrum.
And having overdone them all, we sit here in the wreckage of our systems and we pause. Perhaps the middle way is the best. Perhaps all of these techniques have their place, a place somewhere between nothing and 479%. Perhaps… Wait! Is that a book on Functional Programming? That's the answer! We need way more of that!