So you're watching a new TV show and you're hooked. It's clever, the characters are believable, the dialog is witty, the cinematography is inspired, the direction is tight and the plot is engaging. You want to see more. You're in love. With a TV show.
Jumping The Shark
A few episodes, or a few seasons, later you start to see flaws. The formula of the show is revealing itself to you and you fall out of love. Perhaps you still watch but eventually you'll give it away. "Jumping the shark" is a tired cliche that is often deployed at times like this, to indicate that the show has run its course and the production team are attempting to wring more content out of an essentially used premise.
But sometimes it's not the show that has changed. You, as a viewer have just grown a little more insightful, matured a bit maybe, your belief suspenders snap and you're no longer at home in the show's fictional world. As when relationships between people break down, there are often reasons on both sides.
For me, Lost is a good example. After an initial flurry of enthusiasm I became frustrated with the glacial pace of the plot, eventually confirming initial fears that yes indeed it did suffer from the X-Files syndrome of the perpetually imminent revelation. But the show hadn't changed by the time I stopped watching; it was like that from the start. I just expected it to proceed differently to the way it did.
The same disillusionment can of course apply to other media, although it tends to be more apparent in serialised media such as TV shows ... and websites.
Recently I have become disillusioned with Jeff Atwood's blog called Coding Horror. Now of course this event wouldn't normally warrant an article on my own blog, and I'm sure you'll be relieved to hear that I am not planning to write lengthy explanations anytime I hit the Unsubscribe button. However in this case I believe that some detailed criticism needs to made, as I'm sure many of you are also Coding Horror readers.
I was initially attracted to Atwood's blog for its relatively simple premise and smart delivery. With startling regularity over an extended time he managed to deliver bite-sized morsels relating to the stated domain of programming and human factors. He writes well and generally illustrates his point in a clear and easy to digest style. It's quite engaging.
As an individual blogger I cannot help but admire the dedication and sheer persistence on display here. Over the years he has managed to churn out many substantive articles, far more than I ever will on girtby.net, for example. And there is a lot of great material there.
So, a dude with a blog, why would I rag on him in public, you might wonder. You would be completely justified in asking whether I am motivated by jealousy or some other malice, perhaps because he is so much more prolific and popular than I. These are good questions and if he were just another average Joe developer trying to better himself through blogging, I certainly should be keeping my opinions to myself.
However, Coding Horror has become so popular that Atwood has quit his day job and struck out on his own. To my mind, this raises the bar somewhat. Professional bloggers deserve more scrutiny than dabblers, just as in many other fields.
Not only has Atwood has gone pro with is blog, but has recently started a venture called stackoverflow to collate accepted wisdom from the software development community. It is early days, but from what I can gather there is still likely to be Atwood's editorial hand in the output, despite intentions of adopting community generated content.
In other words, Atwood seems to be setting himself up as an authority figure on software development and, well, I have some issues with this.
The bite-sized morsels posted to Coding Horror are all very well for bite-sized topics. But things can often go awry if the topic is too complex to be distilled down easily. Oversimplification often ensues, as in the following examples, all recent:
An attempted critique of XML makes a case that XML is difficult for humans to read. He gives some dodgy examples — including a SOAP message of all things — but completely misses the point that XML is intended as a good compromise between machine-readable and human-readable. Sure the alternatives may look simpler, but show us the code to parse them. In grudgingly accepting that XML is OK for some tasks, Atwood gives no clue as to what those tasks might be. To me, the entire article reads like someone who has looked at an XML fragment and had an adverse reaction without any understanding as to why it is, and perhaps should be, the way it is. (Norm Walsh on the other hand, understands probably more than anyone, and provides a polite rebuttal.)
A similar "it's-too-hard" reaction seems to be at the heart of an article on humane markup languages such as Markdown, Textile, etc. His conclusion is that he'd "rather rely on a subset of trusty old HTML than expend brain cells trying to remember the fake-HTML way". The oversimplification here is in not realising that Markdown (and possibly others) accept all HTML tags anyway and it adds value by being more readable and writable. If nothing else, Markdown makes it possible to conduct discussions about HTML without going completely insane. I expect hilarity to ensue on his stackoverflow project once people start contributing code snippets with angle brackets embedded deep within. I wonder how many brain cells will be expended on entity escaping.
Admittedly Model-View-Controller is an increasingly vague concept these days, but I just couldn't buy Atwood's example of it; HTML = model, CSS = view, and of all things, browser = controller. For starters these things aren't even of the same kind; HTML and CSS are declarative languages and the browser is a piece of software. If you're going to apply the MVC concept that broadly, why not make the controller, I dunno, the mouse? Or the user? And surely if anything is the model in this case it is the DOM? On their podcast, Joel Spolsky took Atwood to task a little bit over his application of MVC to the web, and it's worth a listen.
A comment that software forking is "the very embodiment of freedom zero" demonstrates that Atwood has no idea what freedom zero is. Freedom zero is the freedom to run the software in question without modification, and forking is inherently modifying the software, hence doesn't even enter into consideration of freedom zero.
Common to all of these are a superficial understanding of the topic at hand. In short, Atwood just isn't credible.
(I have also had cause to disagree with his opinion on many matters, but this is not in itself a good reason to dismiss him. Neither is his seeming obsession with, but never ownership of, recent products from Apple; I'm not sure what to make of that.)
Instant Developer Credibility, Just Add Code
In a recent podcast, Atwood disclosed recently that he had never learned C, one of my developer essentials. To me, this revelation is a profound hit to his credibility; it is like finding out that the chef who cooked your meal is a robot with no sense of taste or smell.
So what language does Atwood use to illustrate his articles on the finer points of programming? Well here's the really puzzling thing. I can't remember reading a single article on Coding Horror which actually included any original code, horrible or otherwise. I've got a vague recollection of a Coding Horror article which incorporated some third-party code, though I can't remember the topic now.
To be honest I should have realised this as a problem a lot sooner. Now that I think about it, all of the other coding-related blogs I read regularly are imparted with credibility through the code that is posted to them, or by the projects in which their authors are involved. You'll note that one of the reasons I decloaked myself on this blog was to take advantage of the accumulated credibility from (mainly) the code posted here.
On a more positive note, I'm sure the stackoverflow project will be a great opportunity to demonstrate Jeff Atwood's abilities as a software developer and bridge the credibility gap.
It's Not Me, It's You. And Me.
So, getting back to the question about leaping over metaphorical aquatic predators. Like I said, there are often reasons on both sides as to why the author and the audience member part ways. Sometimes it's them, sometimes it's you, and sometimes it's both.
Here, I think it's a bit of both. It seems quite apparent that Jeff Atwood has stepped outside his expertise recently, and that this is something he did comparatively rarely in the past. I haven't gone groveling through his past posts, but from my recollection I'm pretty sure his hit rate used to be better.
But I've changed my attitudes also, having learned to be a better assessor of credibility, and more suspicious of short answers to complex issues. And of those who don't demonstrate their developer credibility by actually posting code. I always thought that brevity was a good thing for blog articles, but maybe not.
Either way, I'm going to look elsewhere for good writing on software development. What about you? Are you a Coding Horror fan?