Excellent Developers Are the Best Hires

I recently read a post wherein the author was condoning the hire of excellent programmers with abrasive personalities over bad programmers with cordial personalities. Superficially, I agree with this advice as it is ultimately better to have an individual who does their job well and delivers over an individual who you get along with very well, but who cannot produce.

A false dichotomy

The notion that you must choose between great developers with bad personalities or bad developers with great personalities is just plain false. The dynamics involved are far more complex than that, but let's assume for a brief moment, that there are only two criteria any company hires on; raw skill and congeniality.

The author posits that most companies do not have the luxury of hiring based on both skill and personality. He suggests Google has this luxury and yet they are always looking for good developers. His conclusion is that there are too few developers who are both excellent at the craft and reasonably compatible with the rest of the human race. I submit that perhaps Google's growth rate has contributed to their continual search for developers. I haven't any idea what their turnover rate is, but I do expect it also contributes to the demand.

Let's not forget there are far more developers in the middle of this continuum than on either end-point. I would surmise the majority of developers fall somewhere comfortably in the middle; decent developers with decent personalities. Neither excellent nor awful. Neither completely congenial nor damagingly dissonant. The choice between only the two extremes is invalid.

What makes for an excellent developer?

What are the criteria for excellence when it comes to developers? If we agree that a developer's role is ultimately the consistent delivery of software, then what atributes do we expect an excellent developer to have?

I think there are many facets to what a developer does, but I think we can all agree on three things an excellent developer must be; Knowledgable, Skilled, and Efficient.
Knowledgable
An excellent developer is certainly knowledgable.

Knowing not only a particular language, but multiple languages. An excellent developer knows that the idioms, extractions, and constructs of one language enrich their ability to write code in all languages.

An excellent developer knows that they are not an expert in all languages they use; perhaps (and most likely) in none. An excellent developer knows there is always more to learn. An excellent developer knows lessons can come from anywhere, not only from those they hold in high regard.

An excellent developer is knowledgable in the business domain. An excellent developer can speak with others about the problem at hand in terms everyone is familiar with. An excellent developer knows they should not make unilateral decisions, should not accept decisions from others made in isolation, and should not expect all decisions to be made by committee.
Skilled
Equipped with the knowledge there is always more to learn and always room for improvement, an excellent developer hones their skills. An excellent developer practices their craft. Not just working the same problem with the same tools day in and day out, but working different problems with different tools simply for the pleasure of learning.

An excellent developer does not wait for their employer to approve the budget and time off. An excellent developer takes the initiative and attends conferences, user groups, and weekend gatherings where other practitioners talk, share, and practice.

An excellent developer practices because they want to. An excellent developer improves themselves a little bit every day.
Efficient
For an excellent developer, efficiency is more than writing code quickly. Efficiency is writing code that is easy to maintain in the future. For an excellent developer, efficiency is writing only the code you need today without sacrificing the ability to make alterations tomorrow.

Efficiency is working in a manner that allows any developer on the team to pick up precisely where you left off and see the work to completion.

Excellence Precludes Unsociability

Excellence requires knowledge, skill, and efficiency.

Knowledge requires open mindedness in that one considers what multiple languages have to offer and recognizes that lessons can come from anywhere.

Knowledge requires humility in that one knows they are not expert in all tools they use and that lessons can come from anyone, regardless of status.

Skill requires discipline and commitment in that one must apply themselves not only at work, but outside of work as well; in divergent skills and tools.

Skill requires initiative. An excellent developer does not wait for training to be scheduled and budgets to be approved.

Skill requires social interaction for the best lessons come from the social interaction we have with other developers at conferences, user groups, and weekend events.

Efficiency requires wisdom. The wisdom to know what to build and what not to build. The wisdom to know when the extra effort today is worth the payout of tomorrow and when "good enough" really is.

Efficiency requires teamwork. Developers working in groups, covering each other's back, and sharing ideas as the solutions unfold before them.

If an excellent developer is knowledgable, skilled, and efficient, then an excellent developer is open-minded, humble, disciplined, committed, initiative taking, socially engaged, wise, and team-oriented.

It is, therefor, impossible to hire an excellent developer who has a bad personality.

7 comments:

  1. No mention of Deming?

    Also, s/efficiency/effectiveness/g

    - Bob

    ReplyDelete
  2. Bob:

    No mention of Deming. I agree a bad process beats great people every time. I also know that a great process allows the people to do what they do best. But this is not a posting about process.

    I don't think efficient and effective are interchangeable. They are not synonymous. I think one need be efficient to be effective, but I do not think that if one is efficient, they are therefor effective.

    ReplyDelete
  3. Looking at it again, I think we are in agreement on efficient and effective. You're not indicating they are the same, you are indicating I missed it by saying being merely efficient is sufficient when really one need effective developers.

    Agreed; thanks for the feedback.

    ReplyDelete
  4. @DocOnDev There are certainly developers with such huge personality flaws that it's important NOT to hire them even if they can code well. And like with most spectrums, most people fall somewhere in the middle.

    The point is that when it comes to hiring programmers, the most important factor is their ability to code. Without that, you have nothing. That may appear like an obvious statement to programmers, but if you look at the hiring process at most companies, their actual ability is never tested or, when it is, not valued highly in the decision-making process.

    If you assume that you MUST hire a programmer with a strong coding ability, then the hiring process would look much different. If you realize that programmers with strong coding ability are actually in short supply, then the management process would look much different.

    The programmer ranks are filled with people who cannot code led by nontechnical pointy haired bosses and most software projects fail. Virtually all companies who build software struggle to find good developers and most opt to hire sub-par developers rather than wait indefinitely. This isn't a hypothetical problem; it's the question faced by hiring managers every day.

    - Amber from Code Anthemn

    ReplyDelete
  5. @Amber, nice plug for your web site. I tend to disagree with you though. Doc hit it right on the head with his analysis. Attitude plus aptitude is what makes a good developer. Someone who has potential but doesn't try won't cut it. A person who tries hard but doesn't have the potential isn't good enough.

    But a person with the right attitude and aptitude can go far. Being able to solve a specific in a given language is nice. Understanding the fundamentals of programming and having the self-motivation to strengthen your skills is better.

    I'd pick a junior developer with a solid understanding of engineering and the passion to grow more over someone who has the skills but doesn't use them any day.

    ReplyDelete
  6. Congeniality is contextual. In my experience many great programmers are not so much lacking social graces, but having the "don't suffer fools gladly" streak which means that any PHB dictum is met with derision. Think Scott Adam's Dilbert!

    Many geeks are able to communicate very well once you get onto their wavelength. They just don't do baby-talk. Unfortunately, the boss is not always right, but he is always that boss!

    ReplyDelete
  7. Nice article. Good perspective!!

    ReplyDelete