The Net Negative Producing Programer

It has been well known for a long time that there is at least an order of magnitude difference between the most productive developers and the least productive. But if you've been in the software industry for any period of time, you've probably met this person: the net negative producing programmer (NNPP). This is the person that is so bad, that they actually have a negative effect on team productivity: you would be better off not having this person on your team.



The NNPP drains a software development team and the business in a variety of ways:

1. Initial hiring and training costs
2. Ongoing mentoring from your top developers
3. Unacceptably high defect rates
4. Very low output, if any
   
5. Lowers team morale (they make roughly the same amount of money as you)
6. Causes the business to delay or miss deadlines
7. Taking up a position that could be filled by a great programmer
   

So how do you identify and avoid the NNPP and what do you do if you are stuck with one?

Identification

The first step in ridding your team of the NNPP is identification. You may have an intuitive sense of who is the lowest performing member of you team, but this doesn't necessarily make them a NNPP. The NNPP will exhibit a number of the following red flags over a significant period of time:

• Takes a long time to get the development environment running
  
• Codes by copy and paste
  
• Reinvents the wheel
  
• Doesn't check in much code
  
• Takes a long time between check-ins
  
• Keeps saying the code is almost done
• Tasks always take significantly longer than estimated
  
• Has a high defect rate and/or significant defects
• Doesn't perform basic desk checking
  
• Avoids responsibility / passes the buck
  
• Doesn't use/understand naming conventions
  
• Asks questions that lack depth
• Asks too many questions (unable to do things by themselves)
  
• Doesn't ask enough questions (works in a silo)
• Doesn't integrate with the team
• Lacks passion for software development
  
• Types slowly

New hires, junior developers may exhibit more of these and any programmer might exhibit some of these from time-to-time. For these
developers, they deserve time, mentoring and training to get them on
the right track. But if you have a senior software engineer consistently displaying
a lot of these characteristics, you have at least an over-paid, under-performing developer and likely an NNPP.

You can catch these red-flags through with a variety of techniques:

• Performing Design Reviews
• Performing Code reviews
  
• Pair Programming
• Measuring defect rate
• Measuring estimates vs actual time
  
• Counting defects fixed
• Counting source control commits
• Reviewing daily source control logs

For instance, here are the source control commits and defects fixed for an actual 6 person development team over about an 8 month period. Each developer has at least 10 years of experience and all have the titles of at least "Senior Software Engineer".

This shows we have a big performance gap between our top and bottom
developers, but these two data points don't tell the whole story: programmer B is a new hire and what separates programmers A, the NNPP, and C are the other red-flags listed above: missed estimates, high defect rates, naming conventions and re-inventing the wheel.

Remediation

Once you have identified a NNPP, your goal should be to get as far away from them as possible. For better or worse, the team's productivity and ability to meet deadlines and produce value for the business reflects on you. You should want to be part of a small, highly productive team that builds great software. You can't do that with one or more NNPPs on your team. You can:

• Fire them immediately
• Give them a 30 day warning, then fire them
  
• Find them a new role
• Change jobs

Fire Immediately

If you are able and if your organization culture supports it, this is the best solution. Your team gets an immediate productivity boost and you get the opportunity to bring in a replacement that can be a net positive instead of a net negative. This is probably not possible in many large organizations or European countries, but for at will employment consider this your first option. If you are unable, or can't bear to fire them, you'll have to look at other options.

30 Day Warning

Similar to immediate termination, the 30 day warning gives the NNPP time to get their act in gear. If you've mis-read the situation or there are external factors that you haven't considered, this gives the NNPP a chance to prove you wrong. This also gives the NNPP a chance to start looking for another job which may solve the problem without having to resort to termination, don't count on it.

Find them a new role

Not everybody is cut out to be a programmer. Maybe the NNPP would be better off with a different role. You've already invested in hiring and training them, so they should at least be knowledgeable about your products, practices and culture. Maybe they would be a great QA engineer, a customer advocate, a sales engineer. Look around at the open positions in your company and see if there is something that might be a better fit. A tool such as StrengthsFinder might help them discover what they would be really good at instead of continuing to struggle with software.

Change jobs

If nothing else will work, you can always change jobs, internally or externally to get away from the NNPP and move to a place where you can be part of a highly productive team. There are no guarantees that you won't be in the same situation or worse at your next position, but you should have an idea of what questions to ask to find a good team.

Avoidance

Of course, the best course of action is to avoid the NNPP in the first place.

If you are building a team, you want to hire smart people who get things done. This article isn't about interviewing, but you must identify if they can:

• Write a program
• Understand code
• Debug
• Fix defects
  
• Desk check their code
• Learn new languages and skills easily

You can require code submissions and problem solving as part of the interview process, hire people you know, subject new hires to a 30 day trial period or use a variety of other interview techniques.

If you are coming into a new job, you probably won't know if there is an NNPP on the team already. Chances are, you won't interview with them, but you can do normal vetting and you always have the option to change jobs later or work from within to improve the team.

Conclusion

The Net Negative Producing Programmer is bad for you and bad for the business. While not everybody is a top performing programmer, we shouldn't stand for the NNPP taking away from what we can accomplish. Do your best to avoid the NNPP as new hires and be on the looking for them on existing teams.

References

• Productivity Variations Among Software Developers and Teams: The Origin of "10x", Steve McConnell
• 10 Developers For The Price Of One, Phil Haack
• Why Good Developers Are Not Getting 10 times the Pay?, Soon Hui
• The Net Negative Producing Programmer, G. Gorden Schulmeyer
• Programming's Dirtiest Little Secret, Steve Yegge
• We Are Typists First, Programmers Second, Jeff Atwood
  
• Preventing the Net Negative Producing Programmer, Kris Kemper
• Elitist or Optimist, Jay Fields
• The Guerrilla Guide to Interviewing (version 3.0), Joel Spolsky
• Top Interview Red Flags for Programmers, Code Crankers