Enough Hot Air

Once upon a time in the not-too-distant past, a hacker I know blogged about using object-oriented C to implement a lightweight imitation of some of C++'s features for his latest project; almost immediately, somebody saw fit to reward this charming piece of acceptably self-congratulatory writing with a stern and quite public deconstruction. Does this scene seem familiar? Why does this keep happening? And what, if anything, can we do about it? We can hardly hope to appease all of hackerdom's malcontent — but we can at least try to avoid stepping on each other's toes. Accordingly, this article will waste no time on a platitudinous condemnation of the surf-by put-down; rather, I wish to take a moment to reflect on what the hacker did to earn it, and to consider what he might have done (or, rather, not done) instead.

Let me start by stating for the record that I think the hacker's solution was meritorious as such; that is, it solved the problem he formulated, so I approve of it on the grounds of its workingness. The techniques employed in this approach are simple and effective, and were considered best-practice C in the eighties. Some people found this style long-winded, though, and facilities were soon devised to address the awkward verbosity of the incipient object-oriented C idioms. The pre-processors that implemented these and other improvements to C went on to become distinct languages (namely, C++ and Objective C) and communities formed around them.

Or perhaps it was the other way around, says the sociologist looking over my shoulder — but that is neither here nor there for our purposes. The point I want to make is this: one can reasonably expect the people who embraced these solutions to wince when someone promotes the use of the very idioms their community has so laboriously abstracted away. Did the hacker really not anticipate this response? If he did, why did he preface the presentation of his solution with an explicit rejection of C++?

Whatever his motivation was, it's fair to say he paid for it. Indeed, justifying one's work by scorning a mature system on which one is not an expert works against the legitimate goal of being lauded for one's skills. It puts people off, and will only earn one points with the weenies who happen to agree. Moreover, it is likely to elicit overt retaliation from vigilantes (mostly the weenies who happen to disagree) and a spot on someone's idiot list. Indeed, in the aftermath of such a gaffe, any subsequent plea aimed at demonstrating compunction and competence – however unassailable and incontrovertible – is likely to be shrugged off as so much prejudiced ignorance and answered with a curt dismissal.

So here's my twopence-worth of unsolicited advice for programmers who desire the recognition of their peers: share your wins (and your FAIL) and toot your own horn if you like, but try not to steal the wind from another's sails when you do. Because there's more than enough hot air to go around already — certainly enough for every foghorn blowing at C.

I wish to acknowledge the contributions of Nathan Myers, Luke Kenneth Casson Leighton, and R. Steven Rainwater, whose suggestions and encouragement helped make this a better article. Any remaining flaws are my sole responsibility.

This essay started life as a diary entry, but was rewritten and submitted as an article in response to Luke's lamentation. The canonical version of this document may be more up-to-date than the version here.