I also agree with the post that there are a lot of different things to be good at in programming. I tend to be good at some of the ones that are not mainstream, and I tend to suck at some that are mainstream. Sometimes that makes me awesome, sometimes it makes me stupid.
There is some innate talent involved in having the personality and mindset to easily think logically, and analytically. Likewise, the ability to jump to higher/lower levels of abstraction.
However, these are areas that people with different personalities can develop. Maybe the guy who comes to it naturally will pick it up quicker, but 5, 10, 20 years into a career, I suspect many people have balanced the playing field.
The mini-skillsets referred to in the article do come into play, as does the experience of what problems, industries, etc, one has worked on in their career.
At the end of the day, I think the overall idea that one person may be 10X in one situation, but 1X in another is 100% accurate.
Using myself as an example, I excel when working on old IBM legacy platforms to manage document-based applications, and modernize them to today's web UI expectations. That has been my specialty for about 10 years now, and I really am quite good at it.
But aside from HTML, CSS, JS, I don't know squat about the tools used by the startups who are writing thigns from scratch these days.
So at the end of the day, I am at least a 10X programmer in my little niche, but would not even pass a phone screen for a YC company.
The flip side is also true. The "rock stars" in SV would crash and burn if they had to do some of the things I do, as they would have to learn old legacy platforms that would be archaic and depressing to them.
And yes, this situation is problematic for my long-term career, but seems to be a great example of how different skill sets perform vastly differently depending on the project.
This and "if you read books, you're already way ahead of the pack" or similar statements are just feel-good statements. It's very clear that the other guy and the two original team members are way more productive than I am despite me trying to hit all of the recommended reading books and reading HN/subreddits/blogs/etc.
You can read HN/books/stack overflow and be really good as long as you take advantage of the information and actually practice it in the real world. But until you go and actually measure real things like LOC/fix time/projects completed, the signals "reading HN/books/whatever" are just cultural signals.
Average programmers tend to:
* like new projects
* want to build "new things"
* not like fixing bugs
* not like reading code
* not like to redo their designs/code
* think their code is as good as it gets
Good programmers on the other hand
* tries to find joy in thr task at hand
* thinks their old code is bad
* aren't invested in their own designs
* don't fear trying solutions
* reads code rather than docs about the code
* don't mind fixing bugs
* happy when the code quality goes up, hates it when it goes down.
In other words - good coders CARE, average coders just want to have fun and build stuff. This means the latter group doesn't build the understanding of how to build good, bug free code. They prefer to build themselves into a corner rather than throwing out their designs. Thus they get less practice.
A bad programmer can do simple tasks nearly as fast as a good programmer.
But at a higher level of difficulty that difference might be 10X. Hell, it might even be infinite.
For example, the best NFL QBs will win 10X as many games as the 3rd string backups. But you wouldn't call them 10X better. In fact they are probably only 10% worse than the elite QBs in their completition percentage.
Or if you raised the height of the hurdles 4 inches in hurdle racing, some of the racers wouldn't be able to jump over it any longer.
And I say "average" programmer because average is fairly bad if you look at the workforce on a global scale.
Take the iOS app development. Consider someone who has never used Objective-C but has lots of experience doing client side web development. It would probably be faster for them to develop using a tool like Phonegap and use existing skills. It is theporetically sub-optimal to native code but surely the time spent learning phone gap will produce faster results than trying to learn an entirely new stack.
For example I am a 10x developer but much of my knowledge is company specific. This means I simply don't have much leverage; I am already paid 1.5x market rates. I could only change to a better job with a company that was willing to take a 3-5 year "gamble" on me. Unfortunately the average dev only sticks around for 1-2 years so companies don't usually make these long term hires.
For example I recently spent 50 odd hours of my own time learning the ins and outs of our companies internal serialisation format. In other words I invested about 8 weeks worth of my learning time for no personal gain. The knowledge is not worth anything to any other company. It's not a rational investment.
You just need to find ways to signal that investment - perhaps doing talks under the brand of the first company ?
But then again, I'm a weird kind of programmer. I'm a 10X+ programmer when working on my own stuff, or some challenge, basically for fun. Start paying me or expecting me to deliver, and my productivity drops to 0.1X. I've been unsuccessfully trying to figure that out for years and fix my work productivity, with little result. I feel like I'm wired to be obligation-averse. The moment I have to do something instead of just wanting to, I lose all my skills.
If you feel that the time where you're working on something that doesn't interest you is time where you could be doing something better your brain will feel mentally painful. That blocks your mental faculties and might induce you to seek for doing other activities (like being here on HN).
One technique to rewire the brain is to do time-bounded periods of work with a reward at the end. It's a bit like a work-up. Look for pomodoro technique.
I tried Pomodoro many times, with various results. Mostly I just can't stick to it for longer than two-three days at a time. Depending on <totally random circumstances> forcing myself to productivity induces big mental pain and/or tons of anxiety.
Thanks for the link.
Let's bring up recent web projects I've been doing. I'm working on an API-first system in PHP. Quite a chore, and most of the time I feel like running on 0.1X. Recently I had an opportunity to do a similar, smaller project in anything I liked - so I went with Common Lisp for like 5X productivity. Compare it with 10X I get when working on silly stuff of similar complexity (say, IRC bot that pretends to be a human).
I'm not sure how this works. Sometimes I deeply care (like in that 5X project, I cared because I want to carve out a space at my work where I can do Lisp instead of PHP). Sometimes I don't. The more of an obligation something is, the less I can get myself to care about doing it.
There are times when I write more code for that IRC bot in an hour on a bus than in 5 days of work.
Have you changed jobs much, is this a recurring problem?
I've worked with a lot of devs who haven't been able to settle because they're never satisfied with the status quo of the environment they land in. 6 months and they're onto the next thing. A lot of devs find their way into contracting that way.
I don't think this is an uncommon problem. A lot of (most?) devs suffer from the problem of not being challenged enough, and come up with elaborate ways to complicate projects by many orders of magnitude in order to get some excitement back.
For example, when you here a programmer say
We need to rewrite this app because it's crap.
He means, I want to have a go at writing an app from scratch because the first 20% is always way more fun and creative than the last 80%.
We'll do it in node and angular. It will be isomorphic and restful and awesome.
We need to use Riak and EC2
It's my third job so far, and it always is the same story. I quickly lose productivity and get frustrated by it, in a self-perpetuating cycle.
I shouldn't have trouble in changing jobs (I'm an experienced programmer after all), I usually worry only if I won't get fired in the first two weeks after the 0.1X mode kicks in. Anyway, while employed, low output keeps me in not good enough financial position to risk jumping (family to care about).
I agree with your sentiment about inventing challenges; I often feel that myself, and whenever I can I use the opportunity to learn something new while doing work tasks.
I'm bit afraid to share that directly with my boss (though I hinted it at times). Both for obvious reasons, and because I don't feel I have quite figured out what's going on with my productivity.
BTW. call me lucky, but throughout all my jobs, I never had a bad boss/manager. While their technical skills varied, they were all very honest, thoughtful and nice people.
Now there's plenty of space for jokes like do this to C++ and that language is so fat most people won't notice if a random component disappears. Or do this to PDP-8 assembly language or a turing tarpit and the language is so small that one component removal might make it no longer turing complete, maybe impossible to complete the challenge. But generally speaking, yeah, remove a big part or enough small parts and you'll take a 10x performance hit, sure.
Now there's "know" and then there's kyu/dan ranks from go. Too much binary thinking means people who have a correctly applied checkbox don't really know what they're doing, or maybe they do. Thats why its hard to predict.
So that means the average man can run the 100m in 15 seconds?
It's a much better comparison to stretch that distance out. How fast (slow?) does your average human take to complete a marathon?
Also note that the parent said "average runner" but you replied with "average man", most men are not "runners", so that is shifting the goals quite a bit.
How many people do it in less than 10s?
A lot of people probably do it in more than 20s
So the difference between someone in high school and a professional runner is 12 to 10 seconds, approximately, and the difference between professional and elite is .5 seconds.
When discussing engineering problems with these individuals, I never had to explain twice - Often, I didn't even need to finish my explanation and they already knew the optimal solution for that problem.
These people are impressive to work with but I think it often comes down to experience more than intelligence (but they are usually very intelligent too). When an engineer has mastered a particular set of tools/languages/frameworks, they can come up with more optimal solutions and they can do it faster.
A deep understanding of tools and techniques allows developers to look beyond the most obvious 'naive' solution to find the one which is the most suitable (using existing tools to do as much of the heavy lifting as possible).
Also, when a developer cares deeply about a particular project, they will invest more time reading about relevant technologies in their own time.
When it comes to learning new tools, most engineers are content to 'learn as they go' - That's OK, but it means that they are not as well equipped when it comes to finding that optimal solution.
I think engineers should take time to familiarize themselves with tools REALLY WELL before they start using them, especially if such a tool/framework/technology will impact the project for many years in the future.
Also some engineers might not be great, but they are good at picking the right tools for the right job and as a result the whole company ends up doing well. I don't believe in 10x developers because sometimes small engineering decisions can have a disproportionally big impact on company success.
"Programming Skill, Knowledge and Working Memory
Among Software Developers from an Investment Theory Perspective"
Journal of Individual Differences 32(4), 201-209.
And more research from Gwern: "DUAL N-BACK FAQ" :
"Working memory is important stuff for learning and also just general intelligence. It’s not too hard to see why working memory could be so important. Working memory boils down to ‘how much stuff you can think about at the same time’.
I magine a poor programmer who has suffered brain damage and has only enough working memory for 1 definition at a time. How could he write anything? To write a correct program, he needs to know simultaneously 2 things - what a variable, say, contains, and what is valid input for a program. But unfortunately, our programmer can know that the variable foo contains a string with the input, or he can know that the function processInput uses a string, but he can’t remember these 2 things simultaneously! He will deadlock forever, unsure either what to do with this foo, or unsure what exactly processInput was supposed to work on.
Today it seems every open position requires a "rockstar" developer, even for simple work. The demand for "rockstars" is so great, CEOs of tech companies complain of talent shortages, and companies resort to talent sniping. I suspect most programming jobs could be done well by an average programmer, thus ending the so-called shortage of good programmers and giving inexperienced developers the chance to further their skills on the job.
The work we do is not that unique. While often it will not be identical, but will share a lot in common. We learn what worked in the past in similar situation, and apply it successfully in the future.
That's it. Bottom line, experience matters a lot.
Others promote the weak developers.
Personally I don't think the 10X moniker is very useful. Imagine we'd be calling the marathon runners of the world 10X people. They may be a bit better at task 'X' (running a marathon) but they may suck at a variety of other tasks.
In the end it's all the 0.5 to 9.5 programmers that get the bulk of all the work done, and yet, everybody wants to hire only the 10X guys/girls and the not-yet-10X guys/girls are left to feel miserable because they're somehow inadequate.
If you want to go to the opera: practice, practice, practice. And then you too will be a '10X programmer' at some point in your life, the real question is whether or not you'll still enjoy it as much as when you did when everything was new and you were learning all the time.
One thing that I have noticed that makes a huge difference in your abilities: try to not be a single-technology programmer. If you branch out into at least two or three other sub-fields of programming (languages, theory) then you'll become a much better programmer in a hurry.
There's something to be said for experience, but keep in mind the old adage about "10 years of experience versus 1 year of experience repeated 10 times".
At the same time, there are others who grow their skill at an amazing rate, going from almost clueless to great over like 2 years.
(Assuming same workplace, similar tasks)
Problems solved for "fun" are very different from day job problems, but they often provide knowledge that can be applied.
It the extra knowledge what makes them great.
It is also a much stronger claim. Your claim is that the ONLY way to acquire the wide range skills is to program for fun. Such a strong claim generally requires greater justification, which you haven't provided.
I don't mean to be an ass, but I will: there are a lot of programmers that would effectively never be able to do this. We're asking about if 10X programmers exist? I'm saying even infinity X programmers exist.
I think a lot of this depends on the task at hand--some tasks are straightforward, others require a lot of, for lack of a better word, "invention", and that's where the difference lies.
If the task is "web front end to a database", that task is understood and executed on a level that there probably aren't many optimizations an individual can do. It's difficult to imagine someone implementing ten web front ends to databases in the time it takes an average programmer to do one.
On the other hand, if the task is "create a competitive AI to play the game of go", well, I think that there's a ton of invention required there, and an individual could in fact make a 10x difference.
This "fitness" is how well their skills, their set of learned intuitions, personal characteristics e.g. courage vs. caution etc. fit the given problem which can be sheer luck. This lets us realise that a great developer can have experience that has trained intuitions that actually work against them for a given task and avoid the nasty labelling of them as "they are not a 10x developer".
That said, intelligence and focus are common attributes that undeniably elevate the baseline significantly but by how much? If only we had a way to quantify productivity to test this stuff.
The best "building builder" is not the person who can lay bricks the fastest, but the one who can produce an awesome looking and very functional building.
I wonder what the "10x" ratio is for people like Paul Alen, or Marc Andreessen, or Dan Bricklin, or Dave Cutler, or Andries Brouwer, or Miguel de Icaza, or Bill Gates, or Tom Lane, or Markus Persson, or Linus Torvalds, or Bjarne Stroustrop, or Matsumoto, or (a personal hero) Grady Booch.
Maybe someone who has actually worked with some of these giants can tell us whether my theory holds any water at all.
I don't know what I'd do with Booch. Do some UML diagrams then check in to ClearCase?
If you study what novelists say, they are extremely uncomfortable when they start new work. It's the same for 10x programmers. There is an initial torment and courage involved in that choice that deters the average programmer. That there will be skills one doesn't have for the new creation is a given.
Any programmer is capable of mastering anything in the field and be just as good as the best of the best. And it is very obvious that many tasks can be done much faster by someone with the specific skills these tasks require. It is also obvious that some people have a CS/CE degree and a broad spectrum of skills that are useful for many tasks and some acquired special skills on how to approach new unfamiliar problems more quickly by having and expecting to deal with a lot of different ones. And those things do not make a programmer into a 10x programmer or a blob programmer or whatever, just more or less adapted to some specific tasks.
It's really 10 times of what? Productivity? Value delivered to company?
A developer who convinces the CEO that the million dollar project to put in <crazy consultant lead idea>is a bit silly and you could just use a simple web framework on the cloud is worth 10x in value to the company all the other developers who would have happily built crazy idea for them.
Even if the consultants are all "rockstars" and the in house does php.
So I think that being always context specific (ie in this case I need memcheck, in the other case I don't use C at all so it is a useless skill) is too deep.
There are a set of skills called professionalism that mark a 10x developer
- the ethics of selling profitable services that are not in the best interests of the client
- the investment and training to remain upto date with the common best practises
- contribution back to the global corpus of knowledge on common best practises
I think that as a profession we need to work on building and encouraging all members to reach such standards.
The other complication is the intellectual energy hurdle that each problem brings. Some problems can only be solved by a small percentage of programmers, while others can be solved by anyone who can fog a mirror. How do we measure difference between programmers when the complexity of problems vary so much?
Industry average is 2,000 lines of code per programmer per year.
I've regularly produced 10x to 40x that amount. Others I've talked to have done the same.
The difference between "low volume" and "high volume" programmers is usually pretty stark. My experience is that it's not so much experience as problem solving skills.
If you have a good understanding of the problem, you can come up with the correct solution, and move on to another problem. If you don't understand the problem, you'll work for weeks and get nowhere.
There's also a methodical approach. As an anecdote, I once had to use a script from another developer in the same company. It just didn't work. Paths hard-coded to his home directory (for a script supposedly used in the test suite), etc. I spent 3 days fixing it, and told him it had problems because it had no error checking.
His response? "I don't have time to write error checks."
My response was "WTF? I don't have time to not write error checks."
The 10x programmer has a fundamentally different approach to programming than the bad programmer.
With new code and familiar domain I'd say I can hammer in a few thousand LOC a week.
With a horrible legacy stack I've spent weeks on work that in the end resulted in a single new function call at a particular location.
The story you're telling isn't a bad programmer -- he's a liar! He probably copied the file into the test suite and watched it fail, but it allowed him to report progress to the PM. (Covering for the time spent fucking around on the Internet)
That clown needs adult supervision.
I know people who write that in a day when they start a new project.
Of course LoC isn't the best metric, but still.
The first books on algorithms, like Knuth's, tried to chunk computer science. Software patterns tried this with newer ideas later. We've seen similar projects in functional programming, cloud architecture, and machine learning. The catalog of ideas/hacks is vast and, unlike with aircraft documentation/training, isn't centralized or organized.
Aircraft techs have a deterministic advantage over programmers: they have well-defined triggers and search parameters to find the relevant nuggets. The light that's blinking red has a part code and a serial number and docs can explain the the light's various states. Systems guide techs through decision trees to identify the right procedures for this problem. Programmers experience miserably vague and inconclusive cues.
Aircraft techs benefit from large but finite and known problem sets: just so many parts and so many interactions among them. Programming keeps coming back to ways to simplify and constrain the number of things that interact in ways that produce unexpected results. How much of OOP and FP aspires to help coders avoid complexity?
Aircraft systems are evolving rapidly, from one aircraft model to the next generation. But these have, for the most part, been incremental changes. Contrast that to the six-months to a year it takes to mature in your switch to function programming. Or new architectures, programming languages, and operating systems that require rethinking everything you know. The cognitive burden is high and the duty to relearn is weighty.
So your theory about nugget/task fitness producing moments of 10Xness and sum(nuggets)/sum(projects) producing days/weeks/months/years of 10Xness maps well to the knowledge management world.
- someone will search and replace manually (hours);
- someone will search and replace with a regular expression (minutes);
- someone will use a modern automated refactoring tool (seconds).
but instead of that i spend a lot of time procrastinating and working like a 1x programmer in 1/10th of the time.
I'm in the latter category, many people ask me sometimes how do I know so much about so different skills: from networking, security and system programming to web development UIs and design. The truth is I just spend so much time reading and practicing stuff that would seem boring to most developers around me. I spend nights trying to learn this new framework which seemed interesting enough to dig into it, and once I learn to use it, I want to know "HOW". How does it work, which problem does it solve ... and I think only passionate people can do this.
I totally believe in innate talent. There are standard breakpoints in math teaching where people simply don't get it. No matter how much time you spend explaining it to them, their brains aren't wired up to handle certain levels of abstraction. At best they remember it briefly, but it never sticks.
(The breakpoints are roughly at basic 'manipulate equations to find x' algebra, basic calculus, and calculus in many dimensions.)
Being good at software and math requires an innate ability for symbolic abstraction and reasoning. It also needs a good memory, so you can keep a lot of details in your brain at the same time.
If you don't have those, you're not going to be able to do the job - certainly not well, and possibly at all.
Hard work will make the most of natural aptitude, but there has to be some natural aptitude to start with.
If this isn't obvious, I'd suggest learning some completely new skill, like painting or music. If you don't have natural ability you'll spend a lot of time flailing around wondering how the hell anyone can do it at all.
That's how most of the population feels about coding. The HN population is a self-selecting group that feels otherwise - but that doesn't make it typical.
I myself remember "sweating blood" to get definite integration; unfortunately never got a chance to do multiple dimensions.
Or take organic chemistry. I have a particular type of memory inherited from my paternal grandmother, anything I can fit into an organization of related things I retain well. And I have really really good 3D visualization. First term organic chemistry was easy, and I didn't have to use physical models more complicated than my fingers and knuckles. It's well known that at minimum this is a lot harder for a lot of people. Heck, it's an appropriate weed out class for premeds, appropriate in that it tests both of those capabilities which will later be needed to learn medicine.
By the time a person is old enough to be taking math classes, their "innate" abilities are a combination of nature and nurture. Hitting a "breakpoint" might be the result of deficiencies in their nurture, rather than truly innate (i.e. genetically determined).
The question is, if you took every person and raised them in the optimal way, how far could they go in math, programming, or any other pursuit? I think it's obvious that there would still be differentiation according to talent, but I also think it's likely that the average would be a lot higher than it is.
Now, if you get 10 fresh out of school people who also did not study growing up VS someone who has been doing this for 12 years, and who was also a hacker in their youth I know who I'd bet on!
A little critical thinking shows there must be innate talent.
Most human abilities / behaviors / properties vary around a central mean. Some people are short, some are tall. Some are smart, some... less so. Some are naturally good at something, others are naturally bad at it.
As an anecdotal data point, my daughter could stand on my outstretched hand pretty much from the time she could stand. The first time I tried it (over a king sized bed), she did it without any problems or concerns. No other kid I've met could do the same.
That's an innate talent.
The "10,000 hours" idea is also a myth.
Practice helps, but you soon reach a limit set by your genetics. And some people are likely to have genetics better suited to the problem at hand.
> The rule tells us, a mere 10,000 hours of dedicated practice in your particular field is sufficient to bring out the best in you.
No! That's not at all what Gladwell was saying. They even quote him:
> “The idea that excellence at performing a complex task requires a critical minimum level of practice surfaces again and again in studies of expertise,” writes Gladwell in Outliers.
Necessary, not sufficient.
But on the gripping hand I had a reading age of 18 or so at 10 - Average for population is 13 :-)
I think it helps with visualising some tasks eg set thoery and SQL
Evidence seems to show conscientiousness is 50% heritable.