The Myth of the Myth of the 10x Programmer
payne.org
payne.org
Chris Sawyer wrote 99% of the code for RollerCoaster Tycoon in x86 assembly language, with the remaining one percent written in C.
RollerCoaster Tycoon was a beautiful game which still stands the test of time to this day. The fact that a single person was able to build a blockbuster-level game almost entirely by themselves in assembly is a truly impressive feat which very few programmers would even dream of undertaking.
Being a "real" 10X programmer is like being a savant. It's about being FUCKING SMART, and it's about being able to deliver a working, polished product in the same time that a normal team of ten people would be able to deliver it (or in a tenth of the time that a single person might).
It's not always about being FUCKING SMART, sometimes just having a different attitude helps.
I've worked with testers who refused to write code but would rather test everything manually (and fall behind on every sprint!), while stupid (yes), you could easily come in and be a 100X more productive by just writing tests as code.
For one company I worked for we had an old legacy system (running DOS) that we used to produce master copies of our disk images. When we needed a new master it would take the better part of a day to make all parts work. I wrote a program that could do what the legacy system did but under Windows, taking a couple of seconds to run and now we could get a master image as a build artifact. I don't consider myself FUCKING SMART, quite the opposite, especially at that company with those coworkers who were despite the sound of it actually really smart, but unlike my coworkers I had not accepted the situation but felt that there must be something to do to improve it.
This is the secret sauce. The impulse to solve the higher order problem and the willingness to question fundamental assumptions in order to arrive at a solution.
Your non-10x devs might have attempted to optimize the DOS system, or maybe even introducing some kind of caching and just lived with the somewhat mitigated performance.
I took a couple of days to automate the process and reduced the deploy time to something that could be done multiple times a day and didn't require a developer. Am I FUCKING SMART? No, but I was able to see the bigger picture and realize that there are tools that could be applied to this problem.
...highly productive developers (10x or otherwise) are problem-solving at a much higher level. Their productivity won’t be apparent from a narrow test, any more than the overall skill of a world-class football player would be apparent from (say) how fast they could run the 100m dash.
The most productive developers are solving big problems, and are bringing judgment and experience to bear on essential design, architecture, and “build vs use existing library” decisions. They’re designing key abstractions that will pay dividends through the life of the project...
I have a personal theory the that the average 10x programmer is say 2.5x smarter than average, but also 4x more focused on work, netting a 2.5x4=10x total when you remove all the procrastination and general fumbling around of the average developer.
The 10x productivity comes in large part from the code they DON'T write.
That makes him twice as productive, not half.
If we change the question to are there 10x programmers within a team in some "average" company with CVs indicating roughly comparable experience, then ...
The answer is still yes, there are 10x programmers. I've witnessed it myself many times. Not so much because the highs are very high, but the lows are very low.
[0] Fabrice Bellard. John Carmack. Linus Torvalds.
Someone who's 2x smart and 2x experienced, only needs to spend 2.5x the amount of time to be a 10x programmer, and that's the realistic difference between someone who is just doing a job and someone who is following their passion.
Where you 10x more productive than other developers writing systems themselves?
https://norvig.com/sudoku.html
"In this essay I tackle the problem of solving every Sudoku puzzle. It turns out to be quite easy (about one page of code for the main idea and two pages for embellishments) using two ideas: constraint propagation and search."
If you gave this task to an "average" developer, how long would it take for them to implement? How many lines of code would it be? Would the implementation be correct? How long would their code take to execute?
% python sudo.py
All tests pass.
Solved 50 of 50 easy puzzles (avg 0.01 secs (86 Hz), max 0.03 secs).
Solved 95 of 95 hard puzzles (avg 0.04 secs (24 Hz), max 0.18 secs).
Solved 11 of 11 hardest puzzles (avg 0.01 secs (71 Hz), max 0.02 secs).
Solved 99 of 99 random puzzles (avg 0.01 secs (85 Hz), max 0.02 secs).
Also, can the average developer implement a spell checker from scratch on a single transcontinental flight?
https://norvig.com/spell-correct.html
So Norvig is always the paradigmatic example of the 10x developer, for me. Having a broad range of CS techniques at your disposal and knowing how and when to deploy them, is almost a super power.
(It seems likely to me that there were some false starts, because eliminate() returns either `values` or False, when both of its callers would be just as happy if it returned True or False.)
if( maybeNullValue ) {
myValue = maybeNullValue;
} else {
myValue = defaultValue;
}
myValue = maybeNullValue || defaultValue;
Also I'm not trying to say that there's not some YAGNI going on here--just that I suspect he did it that way somewhat reflexively, and that in that particular case we probably cannot infer he had originally intended to do something else with those results and then changed his mind later.
[0] at least in the Lisp world, which Norvig has extensive experience with[1]
https://github.com/dlang/dmd/blob/master/src/dmd/root/spelle...
but I'm sure it was much longer than it took Peter. This checker is used by the D compiler to look for a misspelled identifier when a symbol lookup fails. The identifiers in scope form the dictionary.
It works surprisingly well. I added it to the Digital Mars C++ compiler as well.
https://github.com/DigitalMars/Compiler/blob/master/dm/src/d...
That's pythonic.
You don't convert from a data type to Boolean.
A lot of the links are dead these days, I'm afraid, but back in 2007 this was the kind of thing that everyone on HN knew about!
http://ravimohan.blogspot.com/2007/04/learning-from-sudoku-s...
I saw that you mentioned a spell-checker, and thought "I'd use levenshtein distance. That wouldn't be hard to implement on a flight. I wonder what he did that's better." Turns out, he used levenshtein distance, and tuned the results with frequency estimates. I don't know if I'd have thought of that, but it's also not a mysterious technique--I'm confident a lot of people who work more in related areas than I do would think of it.
“Pushing button: $1 Knowing which button to push: $3999″
And that's how you become a 10x developer.
I got into programming because I love the toy problems, but it means that once I have something 90% solved in my head it becomes a huge struggle to continue. Sometimes in my working life I'd have to whip something up to fix an issue or provide a POC which gets thrown away or given to a team (I don't care either way) and those were the best projects.
I am now >10x at solving Kakuro puzzles with access to a command line and the repo (~100ms/10x10).
This is a very important point, but calling these highly productive developers "10x" doesn't really make sense. They are more like "infinity times" compared to the average when it comes to getting a difficult task done, since the average developer would just get stuck and never be able to invent good designs and solve the difficult problems. Even worse, some programmers are in the negative on many tasks, adding additional complexity and overhead while making little to no positive contributions, especially when you give them a problem beyond their capabilities.
There are some things that only top programmers are able to actually finish before the end of the universe.
And it only works on the test cases :-)
There are people out there who have difficulty working with others. Some of those people feel that this difficulty is because they're so FUCKING SMART and the others are morons who are beneath them. They're extremely difficult to work with in a team environment, but come across as completely confident about their own abilities.
These people are toxic to work with. They drag everyone else in the team down (part of the reason they are productive is that everyone else has to spend time and effort dealing with their bullshit).
Management should spot this and deal with it. But in a lot of situations the "10x" has managed to get into a position where they have a lot of information that the rest of the team doesn't have (deliberately, usually) and getting rid of them would be difficult. And some managers buy into the whole myth as well, and having a toxic "10x" on their team that they have to carefully manage is a point of pride, or something.
This archetype, the lone genius developer who is 10x everyone else, is extremely appealing to some people. Regardless of their actual ability, they start believing that they are this. And worse, behaving like this.
So while, yes, there are some programmers out there who are very productive, the majority of self-proclaimed "10x programmers" you're actually likely to meet are just socially unaware assholes with inflated egos.
In one example, re-writing a system written by 7 team members + architect, taking half the time.. Maybe due to working in an organization without a formal org position.. I had to make sure bad requirements, process, tech decisions etc.. don't get in the way of properly collecting requirements, designing and building this system, seen today as a hugely successful project for this company. I have to say, some people see me as an asshole, no doubt, other's see me as a bulldozer that got the work done and stand behind me and keep in touch to this day.
Our interaction will depend heavily on if you are in my way or not, though I don't consider my self toxic or hoarder of information.
I have no real insight into your personality and ability (but neither do you about GF).
Competent people who want or need to fix some dysfunctional monstrosity committed by a coherent group of less able developers are not necessarily welcome, even if they don't have pathological personality traits. All the more if they are not parachuted in to fix something, but e.g. some new starter not high up in the hierarchy. Consider that few people take kindly to being told (if only by implication) that what they've done is garbage, but obviously the world is full of garbage software.
I've seen this time and time again. Long-term diplomacy can sometimes work (assuming the company and individual have the time to spare), but they'll usually need some higher up backing or fail miserably/leave/get-fired.
Sure, but are you saying this is about individual productivity or had you considered it might be the costs of coordination?
Just offering my anecdotal story as a potential "asshole" offender per OP
But they also build the right product at the right time for the right user and do the work of an entire product + engineering team - often much faster.
Most large, successful companies today have a handful of these guys among the first 20 employees.
What we need to do is look at the intersections: There are people who are 10x engineers (Peter Norvig) -great. There are 10x engineers who are dicks to the people around them (Linus Torvalds). There are people who think they're 10x engineers but aren't, which are fine (let's be kind as use me as an example) and there are people who think they're 10x engineers who aren't - but are dickheads because of it.
Even if you are a 10x engineer, you shouldn't be a dick - because it's demonstrable that you don't have to be a dick to be a 10x engineer.
I would say it's pretty obvious that the group of people who think they're a 10x engineer and act like a dick is way bigger than the number of actual 10x engineers. That's what I see in the programming community general - everyone has the story of some guy who thinks he's a rockstar but is actually just making everyone's lives hell.
Now if you don't actually know if someone is a 10x-er you've got a group of possible 10x-ers and its polluted by this large pool of people who really are dicks, and really aren't a 10xer
My boss is a 10X all the time. I guess he believes in the mission he's on renovating the IT infrastructure of our org. He's super nice. The antithesis of what you speak of.
Point is: Personalities are different and not necessarily correlated with the 10X trait (if there is such a thing). It might be a host of different circumstances.
Honestly I suspect the idea of 10x developers was created as a way to explain to managers why you need to pay ol' Leslie over there the big bucks. If you claim Leslie works at 10x the speed and only needs 2x the salary, the math works out for a business major. So I guess that's the reason you need the number.
I think that's perfectly justified. So much is lost in software quality because those people think programming as dry labour and outsource to cheap sources, losing so much in future revenues but unfortunately that's not even measurable.
Joel Spolsky put it nicely in a post: It is not that it requires `n` bad programmers to do what one good programmer does. It is that `n` bad programmers can't build what a good programmer builds, no matter how big `n` is or how much time it takes.
Maybe coordination problems just drown out individual productivity most of the time. Or, looking at it another way, if someone senior (as an IC) hasn't found their way into a position where they have leverage ("impact") already, then they don't have the only (meta-) skill that matters.
But then again, when you won't pay people enough to retain them and "Leslie" happens to be the most productive and abhor interviewing, then maybe you end up with literally one person replacing ten.
Today, with Google and Stack Overflow, that gap has diminished, but there is definitely people still way better than "average" developers. However, if you have someone that keeps their skills sharp and their problem solving desire sharper, you won't fine anyone 10x - maybe 2 or 3x, at best.
Ironically, a lot of the 0.1X engineers I've worked with in the 2010s were the most technically competent. Obsession with cutting-edge tools and being technically correct over shipping quickly can sink a person's productivity.
They're the people leading the charge to rewrite the front-end in Vue after we already rewrote it in React when Angular fell out of style. Or rewriting the backend in Rust because Golang isn't trendy any more. Or refactoring the backend for months to increase test coverage from 93% to 95%.
My personal indicator of a 10X programmer is someone who knows when and how to trade off technical debt against speed of execution. A brilliant engineer with all of the knowledge in the world can still sink a team by working on the wrong things all the time.
From HN comments, I get the impression that this is a common problem at companies like Uber. Lots of smart engineers with great technical talent, but they spend all their time making pet apps and services which satiate their interest in and excitement towards programming/engineering, but which have not much direct relation to the actual product or any other ultimate business objectives. If there is any relation, it's indirection upon indirection. I imagine this is probably because the core product is so narrowly-focused and basically "done" that they have to look for any other way to spend their time and energy without getting bored and demotivated.
I would guess this happens at a lot of companies with single, simple (from the user's perspective), narrowly-focused products, like Twitter.
eh? The most important thing I think I've learned is how to trade speed of completion and flexibility and comprehensibility versus putting too much effort into avoiding technical debt and speedy execution.
The 10x engineers that I’ve interacted with can be found working on nights and weekends because they enjoy it and have nothing better to do.
Working those nights and weekends without coworker interruption also means that they get to learn more things freely rather than being interrupted.
As a result they tend to be highly productive, but I’d argue that it could be seen as unfair to the rest of the employees who want to live a balanced life.
What bothers me is the people that are happy to be a <1 developer. Or even a <0 developer, whose benefit to the team is net negative.
We can't all be above average. So we are either all 1 developper, or some of us are bound to be less.
If it ever gets to the point where everyone is floating somewhere between 0.9 and 1.1, I’ll revise my statement.
When they're spending all their working hours on one topic they're taking a huge personal sacrifice which is invisible to their employer while at the same time raising the expectations towards their colleagues. If there's for example two such maniacs in a team, the rest can say goodbye to promotions and raises even if they're actually just as good but don't sacrifice their life at the altar of programming.
That said I'm the 40 hour guy. I want to work to live not live to work. That will make me less of a developer than others but I think I still bring value to my work place. I don't want to look back on a life lived in a cubicle.
Realistically, I've never met any programmer who has more than 4 to 6 (on a really good day) hours of solidly useful work in them per day.
Time spent above that, and those 20+ hours above 40, are invariably spent spinning wheels and making mistakes from fatigue, etc. and I think ought to be discouraged in sensibly run orgs.
* Missing key insights which would shave a large percentage of work off of the project.
* Making mistakes in architectural decisions, which require hours of extra mundane boilerplate work.
* Introducing difficult-to-reproduce bugs which require hours, days or weeks debugging
* Destroying key hardware which needs to be re-acquired (if that's the kind of thing you work on).
At this point in my career I'm of the opinion that asking teams to pull late nights and weekends is actually detrimental to project timelines, over anything longer than a single day. All it does is reassure PHBs that maximum effort is being made.
I've never encountered someone that I think is genuinely a 10x programmer. I've worked with a few people that thought I was one, which I'm most certainly not, and I've explained that to them.
I've encountered a lot of what I would call .2x programmers though. As you've said, there are a lot of people that are really bad at the job. It's not a slight either - there are a lot of people doing this job that really don't care for it at all.
It's hard to be good at a job you don't enjoy. Especially if life forces you to do it 40+ hours per week.
Why stop there, throw a negative coefficient on it. Some bad programmers actively cost other people's productivity and drain profit when their poor decisions or implementations need to be fixed (or they constantly ask the same questions and never seem to grow past that stage).
I have. (Interestingly, some of these people knew this and had a surprising lack of modesty about it as well…) Usually I think it boils down to being able to have the experience to consistently guess right on things, come up with new ideas, and not get tangled in the weeds: most of them are smart, but not so smart that you’re just lost when talking to them.
That, BTW, is a sure sign that someone is trying to appear smarter than they really are. Having worked at 2 research labs over the course of my career I know more than my fair share of genius-level people. Without fail, they are humble about it, and can explain complex concepts in a way the rest of us can understand. This is something that just blows my mind pretty consistently actually, and IMO it is a sign of true, deep understanding of a complex subject. The person didn't just memorize formulas (although many of them excel at that as well), they understand why things are the way they are, the real meaning behind it all.
It could be that this is selection bias though, and I only got to know geniuses who aren't also assholes.
Nope. Explaining things well is a skill. One can be non-excellent at it. Its possible to have a moderately-good grasp of something that you can use while working with it, but not yet have come up with good ways to make your knowledge explicit in a well-organized fashion.
Part of being great at something includes an ability to abstract out common difficulties, which helps other people to understand (even when you are not that great at explaining).
I'm not aware that I've ever met a genius who was working on completely different principles to other people - everyone reaches the same difficulties and has to find a way to resolve those.
Agreed.
But moderately-good is also not "a sure sign that someone is trying to appear smarter than they are".
> everyone reaches the same difficulties
That is definitely false. I've had difficulties with social skills, the writing process, and knowing how to direct my attention. Some of these are so alien to other people that when I ask questions, it is not uncommon to get responses like:
* Just do the obvious thing.
* This isn't hard.
* What do you think {repetition of my question}?
* You're overthinking things.
* What the fuck is wrong with you?
The folks I've heard get discouraged from maths or science tell similar stories. Part of being good at the skill of explanation is asking questions which help you understand the other person's perspective and what their difficulties are.
> That is definitely false.
A bit strong, and I don't think your examples are necessarily contradicting this. Obviously everyone has their own experience.
Responses such as "You're overthinking things" most often mean: 'I overcame this problem with practice but it happened subconsciously, so I'm not able to express how I did this.'
Shoebox is logical computer, cupboard is computer, container is a distant "big" computer (server), pigeon hole is a virtual server.
Now you might have a few boxes of photos at different companies -- the cloud is being able to see/use all those photos at the same time from anywhere in the World.
[Perhaps too close to storage model vs processing model of cloud?]
What I have come to appreciate more over the years is the ability to communicate and make understandable code that other people can build upon. I think it's our greatest strength to lean on the collective ability of the group instead of depending on some person's individual skill.
And in the end the "10x" is merely a subjective measure, that very much depends upon the people you are comparing to. With a team of 10x programmers wouldn't everyone be then only 1x?
But this guy had the ability to focus on the most mundane things with unbelievable attention and focus - I would probably need to take amphetamines or something to come close to this level. Combined with the experience he had with this project he was by far the most productive person on the team (and the team had competent developers on it).
And it was not a case of a mad genius locking people in to his asylum project - this project was screwed over by that type of developer years before he joined the team.
They still very much exist. My previous job was at a bank and these people filled it.
For instance, when you move from C++ to Python, you kinda realise after a month or so that normal loops won't cut it for stuff like numpy arrays etc due to the huge overhead. I realised this personally because I knew how quick C++ was and I wondered why the same code in Python was so massively slow, and I read up online to understand it. Similarly in matlab, for loops are very fast but still inefficient. So now when I write code, I use inbuilt libraries as much as possible and in matlab, I make everything into a matrix operation so it is blazingly fast once I scale it to a million data points.
My colleagues have no idea what that shit is. They'll know every step of a complicated algorithm and implement it simply using loops.
When I get these kinds of messages I just want to strangle the person on the other end.
Cool, an error. What did you do to try and fix it? Or was your first step to contact me?! (hint: it is)
For example when Linus wrote git he singlehandedly outprogrammed every team of version control vendors. He was a 50x programmer. (If not more.)
This is a real literal example without exaggeration.
This is precisely where the 10x Myth comes from. Linus is not 10x a talented developer, productivity-wise. He is 1000x the value of some talented developers, because he figures out great things to make. But the "10x developer" is about productivity.
I suppose I am saying that if Linus/Junio/whoever can make git in 6 months whereas a regular dev would take 5 years, then he is a 10x--it doesn't matter why he is 10x faster.
If Linus had released Git quietly, but put his name behind mercurial and used it for the Linux kernel, would Git still be the de-facto standard today? Or is his popularity and influence at least as big a factor as his design or code skills?
Yeah but people here don't like to hear that :-)
I have another similar funny example - whoever invented bitcoin, that person single handledly created more value than all the YC startups put together PLUS a lot of other incubators, plus a lot of other companies. I wouldn't be surprised if in less than 10 years, you could add to that the total capitalization of the FANG (as in F+A+N+G) and still that one person will have had created more value -- alone.
It takes some special persons, who have not just the wits, but A) know extremely well one or more domains that are generally not connected - say software, finance and game theory for Bitcoin, or software development, project coordination of thousands of persons and hundreds of companies, and scale/complexity issues for Linus B) has already played with the existing solutions quite a bit and know why they suck C) has the opportunity (free time, etc) to scratch this own itch.
I know, people will often tell how it's wrong, how both project are special exception, but then what about Fabrice Bellard? What about the many others? Are they all special exceptions?
TLDR: I believe Kx programmers have a statistic distribution with a very long tail. There are some K=10, some K=50, some with a K even larger. It requires multiple skills + motive + opportunity. Any missing factor and the magic doesn't happen.
Deny the existence of the 10x programmers if it makes you feel better about yourself. Use their existence as a source of inspiration if you want to improve yourself.
Linux was sucking value away from real research in the form of copyleft (lost IP rights), financial speculation (VA Linux IPO, etc), hacking and other forms of cybercrime (don't they show nmap in the Matrix?)
But perceptions change.
The only thing that doesn't change much is the value created, as measured on the public markets.
Whether you like or dislike the morality Bitcoin (and there is more dislike on HN as usual), the market seems to indicate its potential is greater than an isolated dislike.
You are free to be like the Microsoft of the last millenium and consider Bitcoin as a terrible cancer. But I think your perception will change with time.
If your conception of value to society is as simple as "people pay money for it", maybe you should reconsider what value means outside of a purely monetary lens.
So far, bitcoin is a much costlier way to transact compared to standard methods - both to the end user, and in terms of energy/resource costs of miners vs. a VISA server.
It probably has some value in a scenario where the government is an adversary. But the government can regulate and track Bitcoin just as well as dollars if they wish to, like they already do in the US by requiring BTC exchanges to collect users identity proofs.
The arguments about how bitcoin is the next big thing and we'll all look silly for laughing at it now are basically empty. I'm sure i will feel silly if it takes off somehow, but that tells me nothing about if/why it will take off. I'll look silly for laughing at ghosts or leprechauns if they turn out to be real too, so what?
The most effective developers I see are those who ask the right questions. They may have lesser skills than other developers, they may be younger, less experienced, not as smart, etc. However they always produce more. Not because they can type faster, or algo better, but because they know how to leverage every aspect of their team from knowledge sharing, to knowing when to ask about refining requirements, etc.
They think about the whole problem, not just the slice given to them.
Of course there is always a spot for people who are smart enough to algo the shit out of anything, just not as team leads.
It's all I do, it's all I'll ever do. I'm not a balanced person and I'm ok with that.
These definitely still exist.
FizzBuzz is just an example of the general problem of "given a set of things, do something to a subset of those things" which comes up often in real world settings. If you knew enough to set up a loop and apply some conditional inside of it, then you passed better than some of the programmers I've worked with.
They crank out code that is easy to read, easy to understand, works right out of the box, and gives years of trouble-free operation.
Sean Parent is one of those programmers. It's pretty obvious when he describes how he replaced a nightmarish tangle of code that re-invented a simple rotate algorithm.
It's a remarkable talk:
However, I'm constantly amazed how many programmers fail to see the forest for the trees.
To a large extent, not seeing (or seeing and ignoring) this type of solution is learned behavior. Many environments are hostile to this world view. Writing tools (especially those that generate code...eek!) is seen as "over-engineering" and "unnecessary complexity". If you're in a factory, on a line, your job isn't to climb away from your leaf-node.
Any programmer has the potential to be 10x, they just have to see and act upon it. Few do.
But maybe the best thing to do would be to find a better environment, if you can?
When reworking printing software to support multi color, I researched a commonly used subroutine though several layers of calls and replaced it with, yes, a single character constant.
I lost count of the many legacy applications where I tossed out great gobs of code produced by "productive" programmers.
First of all, if you complete a project 10x faster than the expected time, managers will assume that they had overestimated the project, as opposed to recognizing that you're a 10x programmer. I have seen this time after time after time.
Secondly, if a manager does recognize that you're a 10x programmer then you will be seen as a risk: what happens if you leave the company? If the product was built by a team then that's a legit business. If the product was built by just 1 person then that's not a legit business as the business can suddenly collapse if that 1 person leaves.
Third, you make your co-workers look bad by raising the expectations bar. You will not win any popularity contests. You may make your manager look bad too, if your performance diminishes the value of the manager.
If you're indeed a highly capable programmer here's my advice: don't be a 10x programmer by doing 10x the quantity of work or completing projects in 1/10th the time. Instead be a 1.1x programmer, then expend your remaining energy helping your teammates grow, and broadening your influence. (So scale yourself horizontally instead of vertically.) This advice is often not easy to heed if you're introverted, and if you're extroverted you are already a manager instead of a programmer.
The damping effect is real.
All through reading this thread, my thought was that I'd rather be a force multiplier than a 10x programmer. I'd rather make an entire team write better, more maintainable code than just do more of the code myself. Past a certain point, the force multiplier adds more overall, plus their influence results in less _bad_ code, they raise the minimum bar.
This might be a symptom of working at a big company, but I have been really impressed by the ability of some projects to achieve their ends while others get stuck in quagmires due to the fault of nobody on the project per se, but rather the definition of the project itself.
For extremely hard problems, it's not difficult to measure greater than 10X differences between highly-talented senior developers and the average productivity of those capable of meeting requirements.
You have football players who play their entire life and they don't progress beyond a hobby team and then you've got the likes of Christiano Ronaldo and Lionel Messi.
The question is does it give a 10x dev a justification to behave like a dig? No, it doesn't. You still have to be a good team player, just like in a football team a 10x player won't perform well if he/she is pissing off the rest of the team.
So can we stop debabting about facts of life and just get on with it?
Genius level programmers are better than you at everything related to computer science. And if they aren't familiar with it, they will become familiar with it in a fraction of the time and then easily surpass you. This is why we call human intelligence 'general'. Because it applies everywhere.
Unless you think your ability to do your job is entirely dependent on tooling and learned knowledge, smarter people will quickly become better than you.
So, it's not 10x or anything-X even, it's just that, if the stuff that can be uniquely provided by "10x" people is important to you, then you need someone like that. 10 1x developers aren't likely to give you that (except to the extent that you have 10 chances to discover that one of them is actually a 10xer on some dimension).
A real "10x" programmer is a programmer who is able to unshackled themselves from the burdens that turn them into 0.1x programmers. Beware, however, because many of these people achieve their productivity at the expense of others on the team. Indeed, there is a special breed of programmer who will inflict 0.1x burdens on the rest of the team precisely so that they can appear to be a 10x programmer.
I once worked on a team of 5000 programmers, where the average number of lines of code produced per programmer per day was 1. We can all argue that KLOC per month is a terrible productivity measure. However when your productivity is around 20 LOC per month (without the K), there is something seriously wrong ;-) 0.01x programmers (at best)????
Or do you mean that only 1 line was written or re-written? If so, what are people doing, having 7-hour meetings?
Oh and also, "finding the 10x engineer" feels like a hotspot to inject hidden bias into recruiting.
If the team culture is to help each other, forgive mistakes and learn from each other without measuring who's the best the team will automatically build itself without the need to hire only "10x engineers".
Or so I suppose. I'm not an HR person or anyone else with expertise in this field so you should take what I say with a grain of salt. I've just been thinking about this a lot as of late.
These were mature and soft-spoken people; might be different with brash young hotshots.
I’ve seen this before in university too; competitive to get into can still be cooperative once in.
Additionally, elitist teams might scare off some people that could otherwise be great engineers if they just got a little entry help. Sure they can "get that elsewhere" but if every team behaved like that there's not only nowhere to enter, but there's also sort of an omnipresent assumption that you have to be good from the start in order to be able to achieve something in engineering.
I'm not saying your described team doesn't work but it's not exactly the kind of culture HR should be striving for in my opinion. (Albeit it's still far better than than a team that doesn't work at all or works against each other.)
Aside from that, if all of programming is competitive it will keep a lot potentially very capable people from entering the field because not everyone (regardless of ability) is made for competition.
I needed to add a feature that required a big rewrite of my framework. This would take maybe 2 weeks.
The next day I realized I could support that exact same user benefit with only a few lines of code.
Sometimes just looking at the problem differently, or sleeping over it can have a huge impact, not only compared to other developers, but also to yourself.
For this question to make sense, one should give a better definition of what constitutes the output of a programmer.
In a sense, there are Nx programmers for any arbitrary N because some developers can build things that other can't.
But we can't reduce the work of a software engineer to "programming". Most "programmers" today aren't developing some new hobby systems from scratch (it's the easy part IMHO). They work in the context of a team, they have to deal with legacy code (possibly boring, using technologies they don't like), they write doc, review code, discuss designs and solutions, they give talks to present their work, they train or supervise colleagues, they interact with difficult managers or colleagues and so on...
In that context, I wonder how "star programmers" operate. I wouldn't be surprised if some of them are even under-performers.
I've covered this in detail here: https://www.youtube.com/watch?v=Gho89X72Xas
I remember working with this one guy that was light years smarter than me, but if you watched him use the IDE it was painful. He did everything in the menus, slowly. How much of his life could he have back from memorizing f5 and a couple other shortcuts?
Maybe you could reduce waste in various ways:
* Learn keyboard shortcuts instead of pecking through menus
* Use search instead of browsing (especially with keyboard shortcuts!)
* Have you ever lost half a day debugging something that turned out to be dumb? (I have!) Is there a way to modify your coding style or your testing habits so you never hit that again?
* Do you know your stack well enough that (given the time) you could reimplement the same ideas yourself? (Or is it a magic box that you can't debug? How much time and effort do you spend prodding the magic box?)
* Have you automated all the manual things you currently do?
* Are you wasting a lot of time dealing with bad abstractions when something much more basic would suffice?
* Are you mastering your tools/languages/frameworks, or are you switching around so often that you spend a lot of time looking things up?
* Do you have input into how your tasks are written, or are you stuck with whatever breakdown someone else came up with? Is your work getting awkwardly twisted to fit into these milestones? Can you work out a better system with your leads?
That's the tip of the ice berg -- I think if you look at almost anything you do, you can generally find some aspect of it that's cumbersome and wasting your time. I feel like when you account for wasted effort/time, and removing it, becoming "10x" starts to seem a lot more reasonable -- it's not about being a genius, it's about being introspective and careful about how you perform your work. It saddens me to say this, but I think that sort of introspection is rare. I see so many programmers doing uncomfortable awkward things every day, because it's only like 10 extra seconds, except those 10 seconds times 20 times a day times a year and now that cost is out of control
Some of this advice is good but actually being speedy is not necessary.
10 x 20 x 5 x 47 (or however many weeks you work a year) divided by 3600 is about two days of work, or three minutes per day. Hardly an out-of-control cost. Now how many minutes do you spend on HN or other websites that have nothing to do with work?
The (potentially) bigger cost, but harder to quantify, is the effect of those distracting moments on your working memory, flow, and ability to focus on the task at hand. I, for one, would like to make code appear and things come to view on the screen at speed of thought. I think that just would make it easier to focus on the thing you're actually trying to solve, as opposed to the mechanical work of making the parts of the solution materialize in code.
What is really going to save you (and your team) time is knowing to have a test for the critical scenario(s).
Or knowing to build something right (and finding out what right means) the first time around.
From my perspective, it's all about trying to save yourself from future work.
However, to find a 10x guy in a high-performing team, that'd be a sight :)
The square root of the number of people in a domain do 50% of the work.
In a group of 121 the top 11 are doing 10x the work of the other 110.
I never assumed that the 10x programmer was actually writing 10x the amount of code in the same time but instead knowing how to do something in a 10th of the time, with less risk and cost (by a using a better algorithm, novel approach, or 3rd party package etc).
It's the difference between being a developer and a programmer
So they were 10X at that task. Are they like that, consistently, all the time? Maybe next time it's another person's turn to have the insight on how to drastically simplify the task.
This is not "10x people" at all then. This is a "10x day" or a "10x week" in a fairly normal person.
There are probably also a few 100x engineers, maybe someone like Elon.
But then he compares 10x developers to world class athletes... That’s a bad comparison. The 10x developer is the guy who takes the bus instead of running marathon!
Many things have become popular that were originally written like ass by someone who was better at making something people found useful than they were at data structures or thinking in big O.
A lot of genius language design people are nearly useless when the whole messy world of shit like network, filesystems and interacting with things not their language is involved.
Programmers being human also are not some consistent machines that constantly maintain some level of productivity regardless of what is going on in their personal life or their interests waxing or waning in a given problem space.
The people whose code has changed the world are maybe a handful or two. So, astounding developers much better than most do exist. But even they are not some multiple of every coder for every problem.
Nevermind, it's time to stop even thinking about programmers alleging truisms about programming and go get my MSNBC|FOX fix so I can get the necessary stimulus to knee jerk.
I suggest to flag this as fake news and all future articles intended to devalue young talented programmers who yet are to discover their true market value.
One could argue VPs and CEOs technically have people reporting to them, but managing people isn't really their job. They are mostly concerned with strategy.
It is also a concept which is NOT SCALABLE.
In sport it’s pretty obvious there are, and you can measure it because there’s a « winner » and a « looser » at the end of each game. But i’d imagine it’s there in pretty much anything.
A great team is not made up of lone rangers and wild stallions.
It is a daily occurrence that while you are trying to find a missing semicolon that I'm already cleverly arranging your old commits using git rebase to turn your finger-painting into a Van Gogh. My only advice is just to get used to it, because we aren't going away. The best thing you can do is hope to get a management role so that you can be freed from the burden of competing with us. Let's be frank: most of us 10x programmers are on the deep end of the spectrum and therefore won't want or perform well in a management role, but for those of us that can, managing normal programmers would be excruciating.