
Another Theory to Explain 10X Programmers - xvirk
http://beza1e1.tuxen.de/articles/skill_matching.html
======
marktangotango
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.

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

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

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

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

~~~
FLUX-YOU
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.

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

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

Nailed it.

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

~~~
lifeisstillgood
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 ?

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

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

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

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

~~~
TeMPOraL
> _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.

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

~~~
bluedino
>> 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?

~~~
DougBTX
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...](http://training.fitness.com/interval-training/what-
average-100m-sprint-time-21720.html)

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.

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

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

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

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

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

------
pella
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...](http://folk.uio.no/gunnab/publications/BergersenGustafsson2011\(preprint\).pdf)

\---

And more research from Gwern: "DUAL N-BACK FAQ" :
[http://www.gwern.net/DNB%20FAQ](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. .... "_

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

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

~~~
qznc
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?

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

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

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

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

~~~
lerno
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)

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

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

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

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

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

~~~
trentnelson
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?

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

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

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

------
danieltillett
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?

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

~~~
danieltillett
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 :)

~~~
Gigablah
I could delete more than that in a week :)

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

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

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

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

------
aaronlevin
"He is..."

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

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

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

