Edit: I wrote this post 3 1/2 years ago, but never published it for reasons. But I like it so here goes:
I’ve already posted about the developer who took me aside and introduced me to programming.
But there’s a part of that story I have never publicly talked about, because it’s pretty embarrassing. But I think it’s important to share.
The lead developer at the startup I’d been doing marketing for was sort of a polarizing figure within the organization. He was brilliant beyond description and fiercely loved by his team, but some of us outside the development team labeled him as “arrogant”, “aloof”, or worse.
Certainly, there was some tension between marketing and development, and I was the worst of them. I mistook the lead developer’s emotional distance for a lack of feelings and felt justified in criticizing him.
One day, I made a point of excluding him from a group lunch, making snide remarks about why I didn’t want him there. Inevitably, I found out later that he had overheard my cutting remarks.
Not long afterward, he confronted me and asked what my issues with him were. I started by trying to justify myself, and eventually realized, with no small amount of shame, that there was no good reason for my feelings and actions, and I apologized. We decided to try and “start over” with our professional relationship.
Well, if you know me or read this blog, you know how it worked out: He introduced me to programming and became a trusted mentor and one of the greatest influencers in my life.
Grumpy != unkind
Since then, I’ve discovered that many of the most fascinating (and sweet) developers I’ve met are often mislabeled as grumpy.
Before I go on, it’s important to make the distinction between “grumpy” and “unkind”. I am not talking about people who act like jerks, and tear down others or their work to make themselves feel superior.
I’ll use the term “grumpy” in this article to point out a common public perception, but in no way do I endorse using it to actually describe a category of people.
I’m talking about makers who are often perceived as “prickly”, “not communicative”, or “aloof”. Developers who growl a bit when an arbitrary timeline is imposed on a project, or when dragged into yet another multi-hour meeting.
I’ve now had a few years of experience in this arena, and the developers people sometimes label as “grumpy” often become some of my favorite people. Let me try to crack open a few misconceptions.
Misconceptions about “grumpy” developers
Grumpy developers are not mean.
In fact, they’re some of the kindest souls you’re likely to meet. I’ve had several developers labeled as “grumpy” (or worse) take me under their wings as I was learning, encourage me, and patiently answer my ridiculous questions, all with no expectation of reward. And I have heard this from many, many others.
Grumpy developers are not cynics.
They generally distrust people who have something to gain from taking advantage of them. Many manager-types will set deadlines, promise features, and use flattery, intimidation, or both, all in service of extracting every ounce of their worth. This leads to a guarded state that is often mistaken for cynicism.
Grumpy developers are not egotists.
The best developers have at least a glimpse of their own capabilities. They know that when faced with a problem, however unknown or difficult, it is merely a matter of time before they will have the problem solved. Far from ego, this is actually a valuable form of optimism!
Grumpy developers are not loners.
They often crave connection but may avoid crowds. They’ll choose deep, one-on-one communication over sitting in a group, laughing and enjoying life like some kind of Pringles commercial. And sitting in meetings is like the world’s lamest Pringles commercial. So don’t be surprised when they turn down a meeting invite or “team building exercise” so they can get back to work.
Grumpy developers are not lazy.
Experienced developers quickly learn to hate repetitive busywork. So if you have a backlog full of repetitive, menial tasks, prepare to have them stack up. But these same people will frequently work a second shift after “office hours” just to have uninterrupted work time. That doesn’t smack of laziness to me.
Grumpy developers are not pedants.
True, some developers can be pretty pedantic at times. But the “grumpy” developers are usually neither dogmatic nor pedantic when they glare over their glasses at you when you try to check in code that is poorly tested. They are wincing inside at the pain that both you and they will soon feel as a result of bad coding decisions, and they’re not shy about correcting the problem.
Grumpy developers do have feelings.
The most shocking thing to me is how much people (myself included) feel justified taking potshots at higher-profile developers, especially ones who maintain large open-source projects. No matter how accomplished, people still have feelings, and it can be difficult to remember that when we disagree with them.
Why do people label developers as “grumpy”?
I think it’s primarily for one reason: Grumpy developers do not suffer fools.
So then… what constitutes a fool?
Imagine learning that an application in widespread use had left in obvious, gaping security flaws that could compromise the data of all its users. You’d be obligated to say something, right? You might even be angry with someone who would ship software that endangers its users in this way. The person who let this happen is seen as a fool.
The person who does no cursory research before offering criticism or asking a question is seen as a fool.
The person who makes politically-motivated, short-sighted promises is seen as a fool.
The person who hamstrings developers by trying to get them to conform to the manager’s schedule is seen as a fool.
The person who cannot take criticism, who choose preservation of ego over self-improvement, is seen as a fool.
These people generally receive no quarter from “grumpy” developers. I’ve been the fool many times before, and will many times again in the future. The trick to this is not to take it personally, but to dig for the source of frustration. You’ll find it isn’t personal and is usually easily rectified.
Maybe grumpy developers are just tired.
So here you have this group of highly-skilled, self-motivated people athat are fully aware of their own capability. And then they’re dropped behind enemy lines to sit in meetings, fill out forms, re-answer the same set of questions, and rapidly switch contexts, all while trying to carve out enough time to ship software.
And I think this generally applies to people in all creative fields. Would it be a better world if all these grumpy makers-of-things woke up with a newfound sense of “customer service”? Maybe, but I’m not convinced. In professions that require hours of solid concentration, there is a heavy penalty to be paid for being overly accommodating.
The secret to getting along with “grumpy” developers
As I mentioned earlier, I think a good start is to avoid affixing labels like “grumpy”. However you perceive their disposition, they’re people with feelings and a lot they want to offer the world.
There’s one developer in the Ruby community who’s somewhat legendary for being prickly, and I recently heard a story about him taking several brand-new developers under his wing to mentor and guide them. This has been my experience as well: many of the greatest kindnesses I’ve been shown as a developer have been from people that are often labeled “grumpy”.
Like so many things in life, the secret is not to flatter, coddle, or kowtow, but to be more interested in them as fellow humans than in what you can get from them.
(Incidentally, when you call devs “rockstars”, you really mean “racehorses”: they’re superstars now, but someday they’ll wind up at the glue factory.)
So the next time you label a developer as “grumpy”, perhaps take that as a signal that you might actually want to stop and really get to know this person, this fellow traveler in life’s journey, a little bit better.