There are no 10x developers, but there are 1/10 ones

Well, yeah, that's why I said tickets aren't fungible.

Still, when you have someone hopping on them as quickly as they're opened while someone else just grabs one every hour or two, something is wrong. What if I told you the "one every hour or two" person was doing the dumbest, simplest ones, while the top tech was doing the hardest ones (in addition to everything else)? It happened.

I once had a professor who remarked that if you have a large enough population, the distribution of their skills will form a normal distribution. The difference is that, in some fields, the difference between a genius and a dud is much smaller than others.

Absolutely. The parts that really bugs me is when I take on bi challenges. My biggest challenge so far has been building Nuuton. It took me months of thinking and reasoning the data flow and structures. On top of that, I had to pick which language fit the problem, rather which problem fit the language. My original choice was Lisp, because it allowed me to create DSLs. Something that would have really helped in building each individual sub-system. But at the same time, Lisp is not as simple to pick as it should. It has libraries, and an amazing amount of data ready to be researched. Yet, it does not seem (to me) as complete, in terms of libraries and community, as Python. Which was my second choice. Python has all of the libraries I needed. Sure, I had to play by Python's rules, but libraries and frameworks like Django really do save development time.

Them, I had to research the options available within Python that would allow for the architecture I had designed. Every sub-system is simply a black box that reads/returns data in a standard format. From the crawlers, to the data store, to the actual web app, everything is simply an API. Ultimately, I chose the Django rest-framework, because it had a lot of features built into it. Thing like authentication, a permissions system, throttling, and so on. Those were things I did not have to write. A simple set of Models/Views and I was off. With Lisp, I would have had to write that, and end up with a code base that would not have been as good as that one.

Nuuton is huge, in terms of sub-systems. But small at the same time. Everything is divided neatly, and is very simple to follow. The queue sub-system that handles requests/responses from the crawlers is very simple to follow. Plus you can actually see how the data is collected, cleaned, formatted, analyzed, stored, served, and modified.

But I'm not a rockstar, cowboy, or even great. I'm average.But worse is that I have this inherent thought that I will never become any better. Even though years ago I was writing Visual Basic apps (you know the type). This due to how much I struggle. Every day I have to research some class, or some method. Can it do that? What's parameters does it take? Does it fit the design? And sometimes I just write the damn thing and end up throwing it out because I realize it is too complicated. I also understand that I will always struggle. But I will never quit. Do rockstars struggle? Do the people that graduate MIT and go on to work on Google struggle? I don't know. Maybe if they do, they dont struggle as much as me. Guess thats the difference. Average struggles a lot, rockstars not so much. Yet I know thats bullshit. Who am I to question my own insecurities?

Why can't both be true? If you actually had some objective measure of programmer skill, wouldn't you expect there to be some kind of bell curve of skilled programmers, with 10x and 0.1x people somewhere at the tails?

> So I would venture that, for any pair of moderately experienced developers, it's almost always possible to find a pair of tasks such that one of them is twice (or even ten times) as fast as the other.

I completely disagree. The FizzBuzz syndrome is very real: when I do developer screenings, the majority of candidates simply can't program even tiny problems. There's no way they're faster than anybody on my team at any development-related task. And yet, they all have long resumes and a lot of experience. All those people are working someplace. And I've watched these 1/10 developers at work: they copy/paste lots of code, program through trial and error, and spend most of their time in the debugger. Eventually, stuff gets done, but excruciatingly slowly.

Once you reach a certain level of competence, then I think what you're saying is true. But there's a huge number of developers who don't reach that level.

On the other hand, I agree with you about this article. Some sort of insight on where this dev spent his time might have been interesting. Whenever I read things this vague, articles based on vague impressions rather than any hard metrics, I'm left wondering which side was actually incompetent here. Maybe this was one of the 1/10 CTOs, completely incapable of effectively communicating with people who don't fit his favored personality type. And if the feature the dev was working on was replaced with something else that only took 30 minutes to implement, maybe the original design was simply unworkable.