Hacker News new | past | comments | ask | show | jobs | submit login
Another Theory to Explain 10X Programmers (tuxen.de)
105 points by xvirk on Jan 5, 2015 | hide | past | favorite | 98 comments

I fell into a role once that was unquely tailored to my experience. To paraphrase, I spent years studying and playing with parsing technologies, and parsing legacy languages for static analysis (these were my side projects). I took a job that required a lot of screen scraping (not really but close) at which I excelled. Blew everyone away when I turned around a project in two weeks. The same type of project took their devs three months on average. To them I imagine I seemed like a 10x'er. They didn't know I'd been writing parsers for fun, for years before that.

An example similar to this would be Brendan Eich writing Javascript in 10 days, when he'd been doing language implementations for fun.

Yep, I've had that happen in a past. And the only reason I was able to tackle that "one problem no other developer could fix" was because I had already tackled it numerous times freelancing. In that case, I was almost a 100x developer.

Agreed. Got a call from a headhunter for a contract job I was uniquely suited for because of the niche I had been working for 10 years. I needed a change but was quite relatively content so I aimed high with my requirements, got the job, and then slam-dunked it so well someone tried to sabotage my efforts.

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.

I think a mix of things are coming into play here.

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.

There are 10X programmers. I'll give an example. If you take an average programmer and "the best of the best" and ask them to build a relatively complex iOS app, of which neither has previous iOS experience, the best programmers WILL finish the task up to 10x faster than the average. This is because the average programmer gets stuck on bugs, solving problems, complexity, and is slower at learning new things. The better programmer has a combination of skills that allows him/her to do the correct research and solve the problem at a much faster space. The rate of which grows as the complexity of the task increases. Thus reaching 10X.

Actually I believe almost everyone who is reading hacker news is a 10x programmer. It's really quite simple, the average IT person, especially in "enterprise" has very limited knowledge, but they do know some programming. Either in Cobol, Basic, ASP or Excel. Their job is to solve problems, but they're not really interested in their work. A job is a job, not a hobby. They have never heard about system automation, still thinks Linux is evil and a bedroom project and believes VMWare is a coming revolution for system administration, which they're gonna start to use soon.

I don't agree, if only because I'm the anecdote. I'm trying to pick up Rust and mess around with app/net security, but at my job, I feel like I'm in the middle of the pack. There are instances when I quickly fix stuff but also take forever to find a simple problem. To be fair, we do have a very extensive app with 15 years of code rot and only 2 members of the original team to guide/teach. But a guy that started a month after me is already 2x what I am in LOC/fix time. (I know, I know, LOC is a poor metric)

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.

The attitude you have is the one that eventually drives you to be a 10x. If you think you are awesome at what you do, that is when you probably are not.

> If you think you are awesome at what you do, that is when you probably are not.

Nailed it.

Here are some observations that may or may not help you:

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.

I agree. It reminds me of parenting, if you are thinking about how you can be a better parent, you are already ahead of the pack.

I wish it would be like that but my experience is that even average IT people are quite interested in what they do. (I'm still a student so my sample size is not that big).

I find it's heavily dependent on the company. Companies that see IT as core to a successful business tend to attract 10x programmers. If you are still in school then my advice is to learn to interview a company while you are interviewing for a job. Find the place that's going to push you more, regardless of pay.

The problem with the 10X label is that it models the productivity as linear relationship, when it's not, as you allude to.

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.

In this particular case, isn't "10x" just a factor of IQ then? Smarter programmers get complicated things done faster. That seems like a no-brainer. Problem is, how many of those people actually exist in programming? A much smaller subset than exist in the world, which is already a small subset of the general population. Hinging your company on hiring nothing but 10x programmers is like trying to hire a unicorn.

The scientific evidence [0] compares to "worst" for 10X, not "average".

[0] http://www.construx.com/10x_Software_Development/Origins_of_...

In my experience, the worst programmers have negative productivity. 10X programmers must be real monsters.

Because they have negative productivity multiplied by 10?

In that case, there are "InfiniteX" programmers. The worst programmers will get stuck on complex problems and may never complete the task without help. It all depends on the task.

And I say "average" programmer because average is fairly bad if you look at the workforce on a global scale.

Maybe these 10X programmers can quickly solve bugs and problems because they have faced similar issues before and spent the time nesseccary to understand the problem. In that case the important lesson is to limit the amount of novelty in your work so that you are mostly building on technologies you understand well.

In which case you'll probably inevitably end up building something with a suboptimal stack -- and limiting novelty also means you won't learn anything _new_, which sounds more terrible to me.

I am not arguing that you should elimate novelty completely. Just that the amount of time you have to learn new things is limited and needs to deliver returns.

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.

I think the point was to stay in the same niche, not to avoid new approaches to common problems in your niche.

If you give the average programmer a problem that is impossible for him to solve, the best of the best will appear as a infiniteX programmer.

I don't really agree. Consistent 10x programmers learn the skillset required for the job. Often that requires learning about topics that have little relevance in other jobs. Because of that there is little incentive to be a 10x developer. They are paid maybe 1.25x-1.5x average and have to put in 3-4x the effort.

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.

Partially. Doing so has made you more valuable to the company involved, and so marked you as more valuable to other companies (something about women finding men attractive that are already with another women - the first woman's rational investment is a signal that the man is worth investing in)

You just need to find ways to signal that investment - perhaps doing talks under the brand of the first company ?

I like this theory, seems to fit my experience and intuition much more than the "innate ability" kinds.

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.

It might be related to procrastination.

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.

See: https://class.coursera.org/learning-003/lecture/19

It's definitely related to procrastination; it's not while doing hobby projects I hang out on HN as much as I do ;).

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.

I agree. I'm assuming there are many 10X programmers; unfortunately, there are not many 10X problems (or at least, not commercially viable ones - for example, I'm developing a programming language, but I don't see any chance of it being a commercial success, so I only do it in my free time).

In my case I doubt it's just about the type of a problem. I feel it's as much about the context. I apologize for the vagueness, those are all results of years of introspection of my work performance.

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.

When I've been in this situation in the past it's because I've been in the wrong job. When you stop improving (your product, work environment, skill set, whatever), you stop caring.

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.
I'm bored of PHP and jQuery. I want to play with a new toy.

    We need to use Riak and EC2
I want to feel like I'm doing big data.

> Have you changed jobs much, is this a recurring problem?

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 also subcontracted once at another company, four weeks of fixing spaghetti PHP and JavaScript for a company that bought their system for cheap - and this was a very productive (5X+) and refreshing moment. I'm not sure what to attribute it to - the only thing that comes to my mind is clearly-defined and short (few hours tops) tickets to close, and zero personal responsibility for the project (i.e. of course I felt responsible, but it was my personal decision to care).

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 wonder if a thoughtful manager can work with that... somehow structure your workplace to not trigger the ugh-obligation phenomenon. (Or at least creep back up to 1X-5X.)

Maybe. I'd love to think that.

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.

Yeah, I hate other managers. :( A sensible manager should frankly find it interesting, not to mention an opportunity to help improve the team. But no, we can't have nice things, we must waste people's potentials...

No, my manager is awesome, though non-technical, so it's hard to explain some things (and yes, right now I'm the only strictly dev person in the company). He's a very reasonable person, and the recent ability to do a project totally my way was a way of accommodating my needs. I'm hoping we'll be able to build on that.

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.

Anything to do with crypto is a "10x problem", or at least a "careful specialists only" problem.

I don't think that Ruby/Python authors were expecting a commercial success either ;-).

A sports analogy appeared in yesterday's HN thread on this topic: the difference between an average runner and the fastest man alive is less than 50%. The counter argument here is that the measurable variable here isn't really the skill of the programmer but the success of the company (or equivalent). You only have to be best by a small margin to win. If you count wins between me and Usain Bolt he would be more than 10x as successful. Now you could argue that a lot of programming is just factory work; you can complete it in 20% longer time and your salary is lower by some factor. The truth is somewhere in between: a company with developers and other staff that are better than their competition by some factor, will go on to be a successful company a lot more often than others. The measurable business result could be thousands of times better. So what is being measured? We can't measure "skill" separate from experience, but even as a compound the interesting measure is the success of what you produce. If your product or service is earlier on the market or slightly better, you might have 10x the return of the "average".

In the spirit of providing reasonably good analogies, there's a game some people play where given a programming language the scissors are unleashed and a statement or construct disappears from the language temporarily and now the players try to implement "whatever" in the now slightly neutered language. The general spirit of ... write me a fizzbuzz without the mod operator or a function reimplementing mod.

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.

>> the difference between an average runner and the fastest man alive is less than 50%.

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?

For track runners, 12-13 seems to be regarded as slowish, so 15 might not be too far off. http://training.fitness.com/interval-training/what-average-1...

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.

Yes, the definition of "runner" is somewhat blurry but you could argue that you need at least some training to qualify, just like the 10x programmer is compared to an average programmer, not the entire population.

I think it's an ok comparison but remember this is not a normal distribution (I'm not sure what's the actual distribution)

How many people do it in less than 10s?

A lot of people probably do it in more than 20s

Precisely: the distribution of 100m sprint times is a curve with a small number of people below 10s. The question in programming is perhaps: are there people who should be paid 10x the average developers? Maybe such a claim is where the myth of the 10x programmer comes from? Comparing with sports: it's economically sound to pay a footballer who is marginally better than another 100x more because the wins count, not their performance! There are many arguments as to why someone with 4x problem solving speed doesn't actually provide 4x the business value, but in fierce competition a tiny individual performance advantage can mean a huge business advantage.

A relatively fit person ran it in approximately 15 seconds without training. High school training in track brings it down to 12, from when I looked it up in the last thread.

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.

The parent says "average runner" and you said "average man." There might a significant difference there.

Exactly. Just like not everyone can run an ultramarathon, not everyone can program fizz buzz.

My theory is that most programmers are really bad at it. The 10x guys are the few who actually know what they are doing.

Yeah but nobody wants to hear or believe that to be true.

I have worked with a lot of people in a number of different companies (including a few startups) and I can think of a couple of engineers who really stood out.

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, I think it takes a long time before you can judge if an engineer is really good - Many months, sometimes it takes years before you see any payoffs!

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.

100x -> 10x "working memory" + 10x skill


"Programming Skill, Knowledge and Working Memory Among Software Developers from an Investment Theory Perspective"

Journal of Individual Differences 32(4), 201-209. doi: 10.1027/1614-0001/a000052.

PDF: http://folk.uio.no/gunnab/publications/BergersenGustafsson20...


And more research from Gwern: "DUAL N-BACK FAQ" : http://www.gwern.net/DNB%20FAQ

"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. .... "

Why are we debating whether some programmers are better than others? Of course some are. What we should be asking is whether hiring 10X programmers is worth it.

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 whole 10X thing (which sounds like some superhero myth or whatever) is much simpler then we sometimes want to believe.

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.

That being said, some people appear to be better at recognising their (or other people's) past mistakes and learn from them than others. Some people just never learn.

If experience is all that matters than the industry could be a lot better if we would not let the 40+ software developers disappear to management. Instead they should get payed better to keep them?

I've found some companies who recruit from the trenches are led from the front, meaning the management promotes people who are skilled to management positions.

Others promote the weak developers.

10X programmers are what they are simply because they've already seen a similar problem before. The longer you're at the game, the more exposure you've had the bigger the chance that you'll be 10X as good at something as somebody else.

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.

That's why all the best programmers are the oldest guys in the room, they've been at the game longest...

That's not even close to true. I've worked in more than one shop where the 19-23yo kid fresh out of high school/college is 10x better than most of the 40-50s. Or, in a few cases, infinitely better than the guys in their 50s who are -100x (it required weeks/months to undo the damage when they finally left).

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".

I see some programmers that work at it, but after 5 years their level is just as it was when they started out.

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)

My belief is that a 10x programmer is one that codes for fun and because of that, has tackled a lot of different problems.

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.

That is not incompatible with the point made in the article.

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.

There's a story on the front page right now about writing a Haskell compiler from scratch.

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.

Its basically a form of the fundamental attribution error. Instead of looking at the properties of the person, we would often be better to identify the tasks themselves as having the potential range 1x-10x. Some tasks admit a narrow band but others (with many bear traps and possible shortcuts) have a broad range. The actual productivity is the fitness of the developer to the task and not a property of the developer.

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.

My theory is that the best programmers are not spitting out too much code fast. They are the ones who thought of how to build the best app.

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.

Heh, that was an odd mix of names. I'd love to work with Cutler above everyone else. Also fun would be debugging a kernel page fault or something with Linus.

I don't know what I'd do with Booch. Do some UML diagrams then check in to ClearCase?

It's not only about knowing how to build (the lots of tiny specific skills this article mentions). It's also about choosing what to build.

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.

There was a topic on rude programmers the other day and it got me thinking about all this labeling being the cause. VCs want to manipulate programmers, make them rate each other on artificial meaningless scale, call each other names, they even find new ways for programmers to offend each other, like that blob programmer thingy PG thought of. There is clearly an agenda.

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.

I am dubious about the 10x theory as a whole.

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.

Do we really know what the average programmer actually produces? We are all biased when deciding what is average as we use those around us to decide what is average - if we are surrounded by great programmers then our average is much higher than if we are surrounded by poor programmers.

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?

> Do we really know what the average programmer actually produces?

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.

The LOC/month amount depends heavily on the problem at hand.

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.

I've observed the same thing in different contexts, but IMO that's supervisory negligence that allowed an employee to go rogue.

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.

Lines of code isn't a good measuring stick.

Wow 2000 lines of code per year - that is around 8 lines a day! I consider myself a very average developer and I would write 20x this. Maybe I am not so average after all :)

I could delete more than that in a week :)

2000 Loc/year. Wow, that's almost hard to believe.

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 best way to solve a problem is not to have it in the first place. Great programmers aren't better at dealing with complexity, they are better at reducing non inherent complexity and finding ways to break inherent complexity down into pieces that are easy to reason about. That takes experience and dedication to the craft. The latter I think is a huge difference between 10x programmers and others. The simple desire to be the best you can is a powerful force.

There's an old knowledge management idea called the "knowledge nugget," a definable chunk of knowledge, skill, and/or ability that can be captured, learned, stored, found, and shared. This chunking plays a big role in disciplines where the body of knowledge is vast, changes rapidly, and where just-in-time skill acquisition is likely. Aircraft maintenance calls for more info about more parts about different aircraft than any one technician could know; so they wind up doing lots of look-ups and following procedures and limiting studying to the most commonly encountered problems and to understanding classes of problems/solutions.

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.

Where are people getting this "10x" figure from and what is the significance?

Kind of makes sense. How do you rename a type that is used in 1000 places?

- 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).

in my opinion, it's all about time and motivation. I have neither, therefore i'm not a 10x programmer. but if i did, i could churn stuff out no worries.

but instead of that i spend a lot of time procrastinating and working like a 1x programmer in 1/10th of the time.

"He is..."

Completely agree on this. I don't believe in innate talent. I believe we are all born with the same willpower to acquire knowledge. Some people will be ok with not mastering any specific skill as long as it does the job. Others who are "passionate" about certain fields or skills will try to learn as much as possible. So "passion" is a better word to define people's skills.

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 don't believe in innate talent.

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.

Issac Asimov famously hit a "breakpoint" at integral calculus.

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.

Quite a number of scientists are studying how brain development is affected by very early experiences, and so far it seems like it might be more than most people thought. Basic experiences of childhood like breastfeeding, number of words heard per day, amount of music heard, even the number of books in a house, have significant correlations with later metrics of mental success like IQ, grades, career outcomes, etc.

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.

Over 12 years, if you study & practice an extra 2 hours per day you will have studied the equivalent of 365 days for 24 hours per day, or 1095 days at 8 hours per day. That's about a whole bachelors degree worth of study. That's not even including normal work study and practice.

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!

> Completely agree on this. I don't believe in innate talent.

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.

I'm not a Gladwell fan, but that article presents a weak argument against a claim not even made.

> 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.

That's fine but the article you linked to doesn't support genetic limits. Was there a different article you meant to link to?

Not sure I agree I am dyslexic and I simply do not have all the inate skills that non disabled peopel have eg I have to work hard to spell of "of" and not "ov"

But on the gripping hand I had a reading age of 18 or so at 10 - Average for population is 13 :-)

Don't people with dyslexia have other inane skills, such as better spatial perception?

Suposed to be one of the diagnostic indicators but its not 100% garented.

I think it helps with visualising some tasks eg set thoery and SQL

>> I believe we are all born with the same willpower to acquire knowledge

Evidence seems to show conscientiousness is 50% heritable.


Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact