∞x developers
I recently saw an article trying to quantify whether 10x developers really exist.
It came to the conclusion that 3x developers exist, but they didn’t find any 10x developers.
They did so by measuring how much faster some developers did a series of tasks compared to others.
All very nice. Unfortunately they’ve completely missed the point.
It’s not the 10x developers you have to watch out for. It’s the ∞x developers you have to watch out for.
I probably interview an average of a couple of developers a week. The range of developers I come across is huge, but the distribution is heavily skewed towards the bottom end. That’s to say the median developer is a lot worse than the mean developer - there’s a lot of bad developers, and there’s a very few good ones.
If we were to take the median developer, and ask him to implement a simple console app, he would manage without any problem.
Ask him to build a website, and he could probably learn the tools to do so, and cobble together a reasonable website in a couple of months.
Ask him to scale that website to 10x the throughput, and he’d start sweating. He might manage, or he night not.
Take a million of him, and give him 10 years, and ask him to build a JVM or a CLR or a C++ compiler, or an operating system, or a database engine, or a browser, or some other really difficult task, and they’ve got no hope.
It doesn’t matter how much time, and how much manpower you give them, if they’re not up to scratch to the task you need, they won’t be able to solve.
Now let’s take 10 of the developers at the company I work for. We’re a startup, and none of us have years of experience. But the problems we are solving are unsolved problems, and so we can’t hire mediocre developers. All our software developers are bright, eager to learn, and interested in software development.
None of us have any experience in building a compiler or a runtime. But given 10 years, we would be able to come up with something that worked. It would be ugly, it would be buggy, it would be slow. But it would work.
Tell us to restart from scratch after that, and we would probably be able to come up with something quite nice actually.
If we were to get someone like Anders Hejlsberg or Linus Torvalds on the team - a truely brilliant developer with years of experience in that field - then they’d be able to carry most of the project on their shoulders, and just delagate the grunt work to us. And they’d probably finish what we could do in 10 years in 2 years. And it would be a better solution than ours.
My point here is, that measuring programming ability quantitatively is a waste of time. Instead you have to measure it qualitatively. Are these programmers up to scratch for the task I need them for?
If they’re not, it doesn’t matter how cheap they are, they’re not worth hiring. There’s no point saying “Well he’s not very good, but I can get 8 of him for the price of one good developer”. If he’s not good, he’s not going to help you or the team.
The good developer is thus an ∞x developer, since he would be able to finish this project in a finite amount of time, and the bad developer wouldn’t.
Note that for other projects, the good developer might be no faster than the bad developer, if it’s a simple enough task that’s it’s easily within his capability. I can probably make a command line guessing game just as quickly as Linus Torvalds. Faster even, since he would insist on using C. And if we were using a technology I happen to be more familiar in, such as WPF, I would almost certainly beat him. But ask me to build an OS, and I would be hundreds of times slower.