In a recent blog Ted Neward made this remarkable statement:

I’m criticizing because this is what “software craftsmanship” gets us: an imposed segregation of those who “get it” from those who “don’t” based on somebody’s arbitrary criteria of what we should or shouldn’t be doing. And if somebody doesn’t use the “right” tools or code it in the “right” way, then bam! You clearly aren’t a “craftsman” (or “craftswoman”?) and you clearly don’t care about your craft and you clearly aren’t worth the time or energy necessary to support and nourish and grow and….

Now, to be fair, Ted was reacting to some unfortunate behavior that managed to hurt someone else’s feelings. You’ll see this if you read Ted’s blog, and follow the links therein. The long and short of it is that some folks who are identified with the Software Craftsmanship movement made some rude comments about some JavaScript code they found on GitHub. The author of the code read those comments and was hurt.

(BTW, There is nothing wrong with politely pointing out what you believe to be deficiencies in someone else’s code. You don’t want to be rude or condescending when you do this; but you do want to do it. How else can we learn unless someone points out where we’ve gone wrong? So please don’t let this event stop you from valid review and critique.)

But did Ted draw the correct conclusion? Does this unfortunate event show that the Software Craftsmanship movement is an excuse to create an elite upper-crust of programmers who look down upon the unwashed masses of mediocre programmers? Or was this event nothing more than the kind of thoughtless chatter that everyone does when they are behind the wheel, protected by the personal barrier of the windscreen, and yelling at the driver in front of them? (Guys! Remember! Twitter ain’t private!)

I think it was much more the latter. And I think I can prove that by going to the source document for the Software Craftsmanship movement: The Manifesto for Software Craftsmanship.

• As aspiring Software Craftsmen we are raising the bar of professional software development by practicing it and helping others learn the craft. Through this work we have come to value:

  • Not only working software,
    • but also well-crafted software
  • Not only responding to change,
    • but also steadily adding value
  • Not only individuals and interactions,
    • but also a community of professionals
  • Not only customer collaboration,
    • but also productive partnerships

• That is, in pursuit of the items on the left we have found the items on the right to be indispensable.

In this document I don’t see any imposed segregation; any intimation of those who “get it” vs. those who don’t; or any mention of the “right” tools or the “right” way. Indeed, what I see instead is a desire to steadily add value by writing well-crafted software while working in a community of professionals who behave as partners with their customers. That doesn’t sound like “narcissistic, high-handed, high-minded” elitism to me.

Ted then goes on to present a truly remarkable dichotomy:

I will now coin a term that I consider to be the opposite of “software craftsman”: the “software laborer”.

Ted defines the “software laborer” as:

“somebody who comes in at 9, does what they’re told, leaves at 5, and never gives a rat’s ass about programming except for what they need to know to get their job done […] who [crank] out one crappy app after another in (what else?) Visual Basic, [that] were […] sloppy, bloated, ugly […] cut-and-paste cobbled-together duct-tape wonders.”

Now let’s look past the hyperbole, and the populist jargon, and see if we can identify just who Ted is talking about. Firstly, they work 9-5. Secondly, they get their job done. Thirdly, they crank out lots of (apparently useful) apps. And finally, they make a mess in the code. The implication is that they are not late, have no defects, and their projects never fail.

I’ve never met these people. In my experience a mess in the code equates to lots of overtime, deep schedule overruns, intolerable defect rates, and frequent project failure – not to mention eventual redesign.

Ted has created a false dichotomy that appeals to a populist ideology. There are the elite, condescending, self-proclaimed craftsmen, and then there are the humble, honorable, laborers. Ted then declares his allegiance to the latter by saying:

I have respect for them.

He strengthens his identity with, and affinity for, these laborers by telling a story about a tea master and a samurai (or was it some milk and a cow) which further extends and confuses the false dichotomy. At the end of the story he boldly declares:

My name is Ted Neward. And I bow with respect to the “software laborers” of the world, who churn out quality code without concern for “craftsmanship”, because their lives are more than just their code.

So I’m confused. Is Ted equating “sloppy, bloated, ugly, crappy VB apps cobbled-together with cut-and-paste and duct-tape” with “quality code”? Or is this just another appeal to populism?

I’m not a psychoanalyst; and I don’t really want to dive deep into Ted’s psyche to unravel the contradictions and false dichotomies in his blog. However, I will make one observation. In his blog Ted describes his own youthful arrogance as a C++ programmer this way:

In my younger days, believing myself to be one of those “craftsmen”, a developer who knew C++ in and out, who understood memory management and pointers, who could create elegant and useful solutions in templates and classes and inheritance, I turned up my nose at those “laborers” […]. My app was tight, lean, and well-tuned; […] a paragon of reused code […] a shining beacon on a hill for all the world to admire.

It seems to me that Ted is equating his own youthful bad behavior with “craftsmanship”. He ascribes his own past arrogance and self-superiority with an entire movement. I find that very odd and very unfortunate. I’m not at all sure what prompted him to make such a large and disconnected leap in reasoning. While it is true that the Software Craftsmanship movement is trying to raise awareness about software quality; it is certainly not doing so by promoting the adolescent behavior that Ted now disavows.

Ted’s dichotomy is false in the following way.

1. Elitism is not encouraged in the Software Craftsmanship community. Indeed we reject the elitist attitude altogether. Our goal is not to make others feel bad about their code. Our goal is to teach programmers how to write better code, and behave better as professionals. We feel that the software industry urgently needs to raise the bar of professionalism.

2. There are few “laborers” who fit the mold that Ted describes. While there are many 9-5 programmers, and many others who write cut-paste code, and still others who write big, ugly, bloated code, these aren’t always the same people. I know lots of 12-12 programmers who work hellish hours, and write bloated, ugly, cut-paste code. I also know many 9-5 programmers who write clean and elegant code. I know 9-5ers who don’t give a rat’s ass, and I know 9-5ers who care deeply. I know 12-12ers who’s only care is to climb the corporate ladder, and others who work long hours for the sheer joy of making something beautiful.

####Conclusion There is no white-collar / blue-collar dichotomy! We do not have two programming Americas. The appeal to populism is badly misplaced.

What we have, instead, is a very young industry. Programming is barely 60 years old. I, personally, have been programming for 43+ of those years. When I started, the number of programmers could likely have been numbered in the thousands. Nowadays it’s in the tens of millions. What that means is that most programmers are young; and few have had the benefit of an experienced mentor. Most have graduated from college with the idea that the experience prepared them to be a professional. In most cases, it has not.

The result is that most programmers simply don’t know where the quality bar is. They don’t know what disciplines they should adopt. They don’t know the difference between good and bad code. And, most importantly, they have not learned that writing good clean code in a disciplined manner is the fastest and best way get the job done well.

We, in the Software Craftsmanship movement are trying to teach those lessons. Our goal is to raise the awareness that software quality matters. That doing a good job means having pride in workmanship, being careful, deliberate, and disciplined. That the best way to miss a deadline, and lay the seeds of defeat, is to make a mess.

We, in the Software Craftsmanship movement are promoting software professionalism.

This isn’t elitism, it’s realism – and it’s needed.