Mediocrity Is Not A Virtue

Some ex-colleagues just discussed one of Joel’s latest on Software:

One principle duct tape programmers understand well is that any kind of coding technique that’s even slightly complicated is going to doom your project. Duct tape programmers tend to avoid C++, templates, multiple inheritance, multithreading, COM, CORBA, and a host of other technologies that are all totally reasonable, when you think long and hard about them, but are, honestly, just a little bit too hard for the human brain.
The Duct Tape Programmer

Articles like that make me fucking angry, even more so when they get readership. I can’t for the life of me understand why in the software industry, for some reason, shoddy workmanship is praised.

To take a direct analogy, if a plumber you hired used duct tape to “fix” your pipe, you wouldn’t pay them. If a carpenter didn’t bother with joinery and used screws and wood glue for building your dinner table, you’d laugh in their face.

There’s a reason for that. Every one of us1 understands plumbing and woodworking just well enough to know that slap-dash solutions don’t hold up in the long run. We could do slap-dash ourselves; the very reason we hired a professional is because they have skills we don’t, because they can do better.

Enter the software market. Software’s just complicated enough that few of us understand how it works. We can be fooled into thinking that slap-dash solutions hold up in the long run.

Just because people can be fooled into that, that’s no reason to fool them. Worse yet, you might have fallen into your own trap and started believing yourself that the shambles you call code is production grade.

Have some self-respect! If you’re that bad at programming, a different line of work is probably better suited for you, and the world’d be better off at the same time.

Granted, software is harder on the brain than plumbing and woodworking, so a bit of leniency may be in order, my harsh words above a bit too harsh. But that proves to be fallacious logic: it assumes that the complexity of a field of work gives it special merit, an inherent worth that puts it above criticism.

As Joel points out, software needs to ship. Can’t argue with that. I’ve seen way too grand software designs that prevented that important goal from ever being achieved. I know the sting of that, and I fully understand, as they say, “where Joel’s coming from”. Dude. Been there, done that.

But you can’t let that blind you to the fact that broken software fails it’s purpose. Duct-tape solutions are broken by design; they’re not designed to withstand the tests of the real world, they’re merely designed to last just long enough for you to come up with the next duct-tape solution. Therefore, duct-tape programming is at the root of all that’s bad in software.

Crashes. Blue screens of death. Loss of data. The cutely named “organic” growth of software, that describes one layer of duct-tape on top of the other, until the original shape is not discernible any longer. The ageing and brittleness of code, that most developers take for granted.

What we need to do is call this practice by it’s name: shoddy workmanship. We need to be ashamed of it. And above all, we need users that will not put up with it, just like they wouldn’t put up with a leaky “fix” to their pipes. So let’s educate them, instead of trying to fool them and us that the turd we spray-painted gold is anything other than a turd.

Reblog this post [with Zemanta]
  1. Well, most of us. []

  • Andy

    Actually I’m glad to see a programmer finally come forward and admit that duct tape programming is a bad paradigm of development. Essentially it’s nothing more than patching, but given the hip buzzword treatment.

    Really I think the only seeming benefit of this program style is that it was seen to deliver software faster. But really, the maintenance costs are so high that over the long run you offset any speed gains up front by more frequent bug releases and shorter lifespan on the software overall.

    Well on this, you’re preaching to the choir. I wholeheartedly agree with you, and applaud your viewpoint.

    .-= » Andy’s last blog: =-.

    • unwesen

      Thanks. I figured you would, Mr. QA :)

      It’s since been pointed out to me by a lot of people that they understood Joel’s article differently. Some understood it to be mostly a rant on technologies that are too complex to use easily. I can sympathise with that point of view, too, to a degree.