8 ms·

I think 100x is hyperbol however you slice it, run away from anyone who tells you they are a 100x developer. 10x may be achievable... but I argue that it is at

by dktoao 6y ago

I think 100x is hyperbol however you slice it, run away from anyone who tells you they are a 100x developer. 10x may be achievable... but I argue that it is at least partly due to the prevailing code-base. Every competent developer is a 10x developer on a green field project just like every competent developer is a 0.1x developer on a messy legacy spaghetti-code disaster of a project (Making the differential 100x I guess). Good developers are the ones that create code that resists the slide from a 10x code-base to a 0.1x code-base. Important skills towards this end are a good sense for code architecture and testing discipline. But also: good communication, organization, documentation, teamwork. As an anecdote, one of my favorite developers to work with at my current workplace is a "high throughput" developer but who is personable, tests and documents the crud out of everything he does and makes it easy to extend and fix bugs in his code for other developers. One of my least favorite people to work with is also a "high throughput" developer who is a prolific creator of software, but everything created by this person is an un-maintainable, un-documented, un-tested, brittle block of procedural copy-pasta that ends up in the critical business path. And yes, this developer "snapped" about a year ago and it has been a 3 person project ever since to scramble to fix this stuff. So, moral of the story, be very careful with pure productivity as a metric for developers. Maybe a 100x developer is really just a 5x developer who enables 20 teammates to also be 5x developers? EDIT: I think I maybe didn't make my point super clear. My theory is that there are two (somewhat) orthogonal dimensions that you can judge a developer by: 1) Productivity, ability to get things done, this is what I assume (maybe mistakenly) that people are talking about when talking about an Nx developer because it is the dimension that maps better to a quantifiable value. 2) Quality, ability to create code that is easy to work with and extend. This doesn't map to a Nx scale at all. One of these qualities contributes towards a goal by compounding linearly, independent of headcount. The other compounds exponentially and also with headcount and is clearly the superior thing to think about when considering developer skill.

benmanns 6y ago
If 100x is from 100x the throughput of a 0.1x developer, in reality some developers are <0 net contribution. If I'm a 10x and the baseline/worst is -5x, then I need to start saying I'm a -50x developer.
- DudeInBasement 6y ago
  Better than expected
- cbanek 6y ago
  > in reality some developers are <0 net contribution Yes, sadly this is honestly true. Especially if you take into account the time spent to manage them, and then cleaning up after them, a person can easily be negative net contribution. Honestly that's one of the ways I feel I've made a hiring mistake. It's okay to invest more time than it would take me to do a task to teach someone else to do a task, knowing that they can learn and improve, and eventually that investment of time will pay off. Eventually they should be teaching me things too, and doing things without needing any help. But if someone is constantly taking more time, and it doesn't look like that investment is getting paid off, I get nervous. Then when the team starts slowing down, management will become even more resistant to getting rid of people, because you need to "go faster" which in their minds is simply some matter of headcount.
- dktoao 6y ago
  I feel like this can actually happen in practice... Your code sucks and then you hire a 10x developer who is really good a duct taping everything in your code to work with nasty hacks. Good times!
bob33212 6y ago
Reed is taking that into account. Reed and Netflix have been creating software for many years. They certainly have had "Rockstars" who could bust out functional but unmaintainable code. Those people are not valuable to Netflix because Netflix is looking for long term success. A 100x engineer exists in the context of a global company like Netflix. Because if a developer makes something just 1% better that translates into millions of dollars of savings or increased revenue because on the margins just 0.001% increase of new subscribers is thousands of customers.
- jacques_chester 6y ago
  > Because if a developer makes something just 1% better that translates into millions of dollars of savings or increased revenue because on the margins just 0.001% increase of new subscribers is thousands of customers. Generally, the idea of an Nx programmer is comparing programmers on their output, not their outcomes. Otherwise you go from trying to compare levels of skill to levels of luck.
  - bobthepanda 6y ago
    Yeah, you can do terrible programming work on an extremely popular product, or do good programming work on a product that nobody wants or cares about. And no one is 100% correct about what customers want 100% of the time.
- leptons 6y ago
  Netflix doesn't win or lose customers based on programmer performance, they win by having content that people actually want to watch. I don't care if the UI is 10% less slick, as long as they have stuff I want to watch. The only reason I've ever considered dropping Netflix is "why am I paying for this when there is nothing I want to watch". Fortunately, they have come through with some interesting content recently, and I'm still paying them. But give it a month or two with nothing I want to watch, and I'm pulling that plug, and no amount of 100x programmers will be able to keep me as a customer.
  - 6y ago
notJim 6y ago
> Good developers are the ones that create code that resists the slide from a 10x code-base to a 0.1x code-base That may be true of good developers. On the other hand, in my experience "10x developers" are the ones causing the slide.
- MiroF 6y ago
  > 10x developers If they're causing code quality slide, they're not a "10x developer."
  - kulig 6y ago
    From business people's perspective they are.
  - yakireev 6y ago
    "No true Scotsman"
    - jimbokun 6y ago
      A Scotsman will always be a Scotsman due to his ancestry or citizenship. If a 10x developer does not deliver 10x productivity or value of the median developer, they do not meet the definition of a 10x developer.
  - legulere 6y ago
    Depends on the project. If you have to develop features just for ticking off points in a contract that nobody will ever use or prototyping it can be pretty useful. If that code will run 10+ years then not.
- andrewingram 6y ago
  This feels like the ones often seen as 10x heroes, because they're the only ones who can be productive in the mess they created.
cbanek 6y ago
I don't think I'm a 100x developer or anything, but I think people underestimate the compounding interest of being a 5x-10x developer. If you architect things just right today, that can save you a lot of time tomorrow. Spending time testing today can save weeks of bug time later, which can be spent to create something useful, compounding on itself. If we say green field is 10x, and someone is doing good things, I think that should go up over time. Getting things like builds, documentation, tests, make people more productive. Whereas on the other hand, people who make code worse eventually start drowning in their own filth, and eventually slow down to nearly nothing. Filth also compounds.
- asciident 6y ago
  I was involved in an accidental situation where two teams at different companies worked on the exact same project from the same starting point, each led by different developers. This was not the company's core product, but a necessary part of it (for anonymity, let's say this was the device driver for a fancy piece of hardware). The lead developers on each selected different frameworks, used different data architectures, and set up different workflows. One project became hugely convoluted, with bugs that were very difficult to trace due to race conditions, the way the navigation worked, and choices that let to more complex code. The other team had a much simpler architecture, and was literally 95% less code. That team was able to add new features with ease, and without complex bugs cropping up out of nowhere. In fact, that project went into "maintenance mode" because there was nothing else to add, and the lead developer could just add one or two minor things when they cropped up, and instead spent most of his time on a new unrelated project. I'd say the lead developer with the better architecture was not only 100X, but the other team's lead developer would probably lead to the downfall of that company -- both morale and development speed would plummet to 0.
  - fsloth 6y ago
    Yes - excellent developers are a productivity multiplier. It’s not about the 12’o clock shoot-from-the hip duel - the one who shoots more codepoints in the general direction leaves winner. A piece of code - if it ends up in production - has so many potential ways to waste work hours that avoiding just a fraction of them is a huge win.
babesh 6y ago
I think one misconception is the range. I think that the range is dependent on the situation both immediate and long term. The immediate situation’s range is more bounded. The bottom of the range can veer into the negative and the top can go way beyond 10x. It’s more a phase change at that point. Example of >> 10x phase change: Jeff Dean and Sanjay Ghemawat with MapReduce and BigTable. For the negative, I think we all have seen the programmer who is useless and that actually requires other people to replace their work.
- dktoao 6y ago
  I agree, but I used 0.1 - 10x for illustration purposes only.
- rightbyte 6y ago
  Your best developers are your competitor's worst. It easier to destroy than to build!
victor106 6y ago
> Every competent developer is a 10x developer on a green field project just like every competent developer is a 0.1x developer on a messy legacy spaghetti-code disaster of a project (Making the differential 100x I guess). Wow!!! so true, never heard it said like this.
bjornsing 6y ago
It all depends on the problem space: if the deliverable is a program that produces a proof of Fermat’s last theorem then Andrew Wiles would have been a 1000000000000000x (or Inf) engineer on that project at a certain point in time... Also, there are entirely different “10x engineers” being talked about as one and the same here. The copy-paste spaghetti guy probably couldn’t even get a job at Netflix...
- dktoao 6y ago
  Agree, my model isn't complete. Unrelated to your point but I think a lot of people who write really bad code are the only choice because they are experts in another essential domain, and there aren't a whole lot of experts in both that domain and writing software. So you do what you can. There is a reason that code written by EE's is often derided as terrible.
yibg 6y ago
I don't know if it's 100x or 10x, but I assume that's just a figure of speech and used for effect rather than stated as an objective quantity. "The thing with "10x" developers, is often times they (or a group of them) can do things that the average developer can't. Take Netflix as an example, would they have even started on the whole cloud thing if they had average engineers? Or if they did, would they have been thought leaders in the space for so many years. > Maybe a 100x developer is really just a 5x developer who enables 20 teammates to also be 5x developers? Or just a developer that makes the lives of 2000 engineers a little bit easier.
deleted 6y ago
[deleted]
anm89 6y ago
I very much believe in 100x developers related to the .2 or -.5 x developer. These people have the potential to accomplish little or even slow everyone else down by focusing on the wrong things, and writing difficult to maintain code. In that sense a 1x developer is infinitely more efficient than someone who is a net loss to the team and 100x is nothing. I do agree that it would be very difficult to be 100x better than someone who has decent technical skills and generally displays common sense and stays focused on useful paths.
hintymad 6y ago
100X developers are the groups who turn impossibles into possibles. Some Uber engineers used to believe that Graphite was the best thing in the world and Nagios was second bar none, and they went ahead design a complex yet failing architecture for monitoring even when Uber's traffic was still tiny before Uber's M3 came along. This is what Netflix did with four engineers years before Uber's saga: https://www.quora.com/Are-Netflix-employees-really-that-good/answer/Yong-Yuan https://www.quora.com/Are-Netflix-employees-really-that-good... To those who couldn't scale out Graphite and got crushed under gruesome oncall alarms, the Netflix folks were 100x engineers.
- ipnon 6y ago
  100x in this sense is akin to doctoral level research. Think SpaceX turning the impossible into the possible with reusable rockets. Their returns on investment are now 100x greater than their competitors.
- user5994461 6y ago
  Graphite has been obsolete for 5+ years. There are commercial products with unlimited scaling, great UI, alerting and a hundreds things out of the box (see datadog and competitors).
  - chinathrow 6y ago
    That's not the point here. OP said, that the Netflix team could at the time deliver scale, while other teams couldn't.
    - hintymad 6y ago
      Yeah, and the key difference is simple: The 100x engineers in Netflix just understood that file-based lookup for key-value pairs won't scale for OLAP-like workload on time series, and of course they possessed the sheer capability of implementing the right technology from ground up.
    - diab0lic 6y ago
      I was on Roy's team at this time. I am not one of the four mentioned in the link, but I definitely know exactly who is being talked about. I wanted to comment that these four were considered outliers even by Netflix standards for being very high performing. So bear in mind the example is an extreme one.
lojack 6y ago
> Good developers are the ones that create code that resists the slide from a 10x code-base to a 0.1x code-base. 10x is 100 times bigger than 0.1x FWIW. > but I argue that it is at least partly due to the prevailing code-base. Its almost exclusively because of the prevailing code-base. We can't forget that the prevailing code base was built by developers of varying skills. You can have "100x" developers build it or you can have "0.1x" developers build it. > One of my least favorite people to work with is also a "high throughput" developer who is a prolific creator of software, but everything created by this person is an un-maintainable, un-documented, un-tested, brittle block of procedural copy-pasta that ends up in the critical business path. And yes, this developer "snapped" about a year ago and it has been a 3 person project ever since to scramble to fix this stuff. Was this person the aforementioned "Rick" from this article?
- dktoao 6y ago
  Obviously it wasn't "Rick" in the flesh (I think). But more a "Rick" class programmer. :) Sorry to anyone who's real name is Rick.
mettamage 6y ago
I have one friend and he programs at least ten times as fast as I do (in typing). I can barely keep it up with reading. And in my CS class I was in the top quarter percentile, he was in the top 1%. The difference is big. They type code as fast as I'm typing this comment, while having a sane architecture. The secret: they programmed a lot more as a kid.
- jimbokun 6y ago
  I think the sane architecture is the only relevant part. Real world "10x" developers are almost always in that class because they can solve the same problem with 1/10th the code of a 1x developer. Ability to solve problems with less code will always outpace faster typing.
  - khalilravanna 6y ago
    To be clear, you don’t mean code golf levels of code-shortening, right? E.g. they’re also not sacrificing on clarity and readability of code to shorten it. They’re just removing unnecessary work. I think this is definitely good and creates a net gain for other devs. Because the people who shorten code at the cost of clarity are some of my least favorite people. I once saw “half = num >> 1” instead of, say, “half = floor(num / 2)”. The latter is 100% more clear to more people and doesn’t gate-keep on engineers who haven’t memorized bitwise operators. (Also, this wasn’t a context where the bitwise operator would be optimized by the compiler in case they wanted to throw that hogwash out there.)
    - bobthepanda 6y ago
      Code golfing is mostly a exercise in asininity. But personally, short, standard, and sweet is preferable to crazy newfangled mental model. I've seen way too many real-world examples of the idiom "it takes a lot of skill to write Java in every language."
    - dktoao 6y ago
      In the good old days half = num >> 1 Was standard practice and understandable by most engineers, as well as far and away much faster than a divide. Now-a-days, using a compiled language they are going to be translated into the same machine code supporting your point. However, it might still be a good idea in a scripting language doing heavy math lifting.
lhnz 6y ago
Er, isn't it a bit of a strawman to suggest that people that talk about 100x engineers are talking about 100x productivity? Nobody I've met thinks that there are a set of people that believe there are "developers that write code 100x faster than other developers" but when people write comments on HN they act like this is a really common belief and only they are able to spot that it's not sane... Everybody that I've met considers technical prowess more along the lines of: the ability to write complicated code which others would find difficult to do, the ability to simplify a problem in order that it can be solved without complexity, the ability to optimize the performance of something in order that it uses less resources, the ability to come up with an innovative design that others wouldn't have thought of, the ability to explain technical ideas to their colleagues in a way that enables others to achieve more, the ability to balance short-term goals against a long-term plan, etc.
pantalaimon 6y ago
I think people often underestimate how bad the average programmer is out there. It’s apparently not unheard of to have C programmers who don’t know function pointers or even structs work, or who don’t know what a build system is (only ever used an IDE). There are many people who will just plug stuff together until it works somehow, without understanding why or how it works in the end.
- user5994461 6y ago
  Indeed, have a little trip to the outsourcing world, where you're paying for a team of experienced developers, some of whom have never developed anything before. That's the antithesis of HN of course. Most commenters here probably work for tech companies.
qznc 6y ago
It is depressing that people are happy to just throw anecdotal evidence around without even defining what metric they multiply by 10x or 100x. There is some literature on it. For example, this blog post [0] contains some references. I have only read Peopleware. It says 10x is the difference from worst to best in terms of time and number of defects across a few hundred programmers. Also interesting: Within the same organization, there was only a difference of 30%. This means the environment is much more important than the skill, experience, or personality of a programmer. I cannot find any studies after 2000. Most of the data is even older. The Peopleware data is from Cobol, Fortran, Pascal, and C. [0] https://www.construx.com/blog/productivity-variations-among-software-developers-and-teams-the-origin-of-10x/ https://www.construx.com/blog/productivity-variations-among-...

by dktoao 6y ago

benmanns 6y ago

If 100x is from 100x the throughput of a 0.1x developer, in reality some developers are <0 net contribution. If I'm a 10x and the baseline/worst is -5x, then I need to start saying I'm a -50x developer.

DudeInBasement 6y ago
Better than expected
cbanek 6y ago
> in reality some developers are <0 net contribution Yes, sadly this is honestly true. Especially if you take into account the time spent to manage them, and then cleaning up after them, a person can easily be negative net contribution. Honestly that's one of the ways I feel I've made a hiring mistake. It's okay to invest more time than it would take me to do a task to teach someone else to do a task, knowing that they can learn and improve, and eventually that investment of time will pay off. Eventually they should be teaching me things too, and doing things without needing any help. But if someone is constantly taking more time, and it doesn't look like that investment is getting paid off, I get nervous. Then when the team starts slowing down, management will become even more resistant to getting rid of people, because you need to "go faster" which in their minds is simply some matter of headcount.
dktoao 6y ago
I feel like this can actually happen in practice... Your code sucks and then you hire a 10x developer who is really good a duct taping everything in your code to work with nasty hacks. Good times!

bob33212 6y ago

Reed is taking that into account. Reed and Netflix have been creating software for many years. They certainly have had "Rockstars" who could bust out functional but unmaintainable code. Those people are not valuable to Netflix because Netflix is looking for long term success. A 100x engineer exists in the context of a global company like Netflix. Because if a developer makes something just 1% better that translates into millions of dollars of savings or increased revenue because on the margins just 0.001% increase of new subscribers is thousands of customers.

jacques_chester 6y ago
> Because if a developer makes something just 1% better that translates into millions of dollars of savings or increased revenue because on the margins just 0.001% increase of new subscribers is thousands of customers. Generally, the idea of an Nx programmer is comparing programmers on their output, not their outcomes. Otherwise you go from trying to compare levels of skill to levels of luck.
- bobthepanda 6y ago
  Yeah, you can do terrible programming work on an extremely popular product, or do good programming work on a product that nobody wants or cares about. And no one is 100% correct about what customers want 100% of the time.
leptons 6y ago
Netflix doesn't win or lose customers based on programmer performance, they win by having content that people actually want to watch. I don't care if the UI is 10% less slick, as long as they have stuff I want to watch. The only reason I've ever considered dropping Netflix is "why am I paying for this when there is nothing I want to watch". Fortunately, they have come through with some interesting content recently, and I'm still paying them. But give it a month or two with nothing I want to watch, and I'm pulling that plug, and no amount of 100x programmers will be able to keep me as a customer.
- 6y ago

notJim 6y ago

> Good developers are the ones that create code that resists the slide from a 10x code-base to a 0.1x code-base That may be true of good developers. On the other hand, in my experience "10x developers" are the ones causing the slide.

MiroF 6y ago
> 10x developers If they're causing code quality slide, they're not a "10x developer."
- kulig 6y ago
  From business people's perspective they are.
- yakireev 6y ago
  "No true Scotsman"
  - jimbokun 6y ago
    A Scotsman will always be a Scotsman due to his ancestry or citizenship. If a 10x developer does not deliver 10x productivity or value of the median developer, they do not meet the definition of a 10x developer.
- legulere 6y ago
  Depends on the project. If you have to develop features just for ticking off points in a contract that nobody will ever use or prototyping it can be pretty useful. If that code will run 10+ years then not.
andrewingram 6y ago
This feels like the ones often seen as 10x heroes, because they're the only ones who can be productive in the mess they created.

cbanek 6y ago

I don't think I'm a 100x developer or anything, but I think people underestimate the compounding interest of being a 5x-10x developer. If you architect things just right today, that can save you a lot of time tomorrow. Spending time testing today can save weeks of bug time later, which can be spent to create something useful, compounding on itself. If we say green field is 10x, and someone is doing good things, I think that should go up over time. Getting things like builds, documentation, tests, make people more productive. Whereas on the other hand, people who make code worse eventually start drowning in their own filth, and eventually slow down to nearly nothing. Filth also compounds.

asciident 6y ago
I was involved in an accidental situation where two teams at different companies worked on the exact same project from the same starting point, each led by different developers. This was not the company's core product, but a necessary part of it (for anonymity, let's say this was the device driver for a fancy piece of hardware). The lead developers on each selected different frameworks, used different data architectures, and set up different workflows. One project became hugely convoluted, with bugs that were very difficult to trace due to race conditions, the way the navigation worked, and choices that let to more complex code. The other team had a much simpler architecture, and was literally 95% less code. That team was able to add new features with ease, and without complex bugs cropping up out of nowhere. In fact, that project went into "maintenance mode" because there was nothing else to add, and the lead developer could just add one or two minor things when they cropped up, and instead spent most of his time on a new unrelated project. I'd say the lead developer with the better architecture was not only 100X, but the other team's lead developer would probably lead to the downfall of that company -- both morale and development speed would plummet to 0.
- fsloth 6y ago
  Yes - excellent developers are a productivity multiplier. It’s not about the 12’o clock shoot-from-the hip duel - the one who shoots more codepoints in the general direction leaves winner. A piece of code - if it ends up in production - has so many potential ways to waste work hours that avoiding just a fraction of them is a huge win.

babesh 6y ago

I think one misconception is the range. I think that the range is dependent on the situation both immediate and long term. The immediate situation’s range is more bounded. The bottom of the range can veer into the negative and the top can go way beyond 10x. It’s more a phase change at that point. Example of >> 10x phase change: Jeff Dean and Sanjay Ghemawat with MapReduce and BigTable. For the negative, I think we all have seen the programmer who is useless and that actually requires other people to replace their work.

dktoao 6y ago
I agree, but I used 0.1 - 10x for illustration purposes only.
rightbyte 6y ago
Your best developers are your competitor's worst. It easier to destroy than to build!

victor106 6y ago

> Every competent developer is a 10x developer on a green field project just like every competent developer is a 0.1x developer on a messy legacy spaghetti-code disaster of a project (Making the differential 100x I guess). Wow!!! so true, never heard it said like this.

bjornsing 6y ago

It all depends on the problem space: if the deliverable is a program that produces a proof of Fermat’s last theorem then Andrew Wiles would have been a 1000000000000000x (or Inf) engineer on that project at a certain point in time... Also, there are entirely different “10x engineers” being talked about as one and the same here. The copy-paste spaghetti guy probably couldn’t even get a job at Netflix...

dktoao 6y ago
Agree, my model isn't complete. Unrelated to your point but I think a lot of people who write really bad code are the only choice because they are experts in another essential domain, and there aren't a whole lot of experts in both that domain and writing software. So you do what you can. There is a reason that code written by EE's is often derided as terrible.

yibg 6y ago

I don't know if it's 100x or 10x, but I assume that's just a figure of speech and used for effect rather than stated as an objective quantity. "The thing with "10x" developers, is often times they (or a group of them) can do things that the average developer can't. Take Netflix as an example, would they have even started on the whole cloud thing if they had average engineers? Or if they did, would they have been thought leaders in the space for so many years. > Maybe a 100x developer is really just a 5x developer who enables 20 teammates to also be 5x developers? Or just a developer that makes the lives of 2000 engineers a little bit easier.

deleted 6y ago

[deleted]

anm89 6y ago

I very much believe in 100x developers related to the .2 or -.5 x developer. These people have the potential to accomplish little or even slow everyone else down by focusing on the wrong things, and writing difficult to maintain code. In that sense a 1x developer is infinitely more efficient than someone who is a net loss to the team and 100x is nothing. I do agree that it would be very difficult to be 100x better than someone who has decent technical skills and generally displays common sense and stays focused on useful paths.

hintymad 6y ago

100X developers are the groups who turn impossibles into possibles. Some Uber engineers used to believe that Graphite was the best thing in the world and Nagios was second bar none, and they went ahead design a complex yet failing architecture for monitoring even when Uber's traffic was still tiny before Uber's M3 came along. This is what Netflix did with four engineers years before Uber's saga: https://www.quora.com/Are-Netflix-employees-really-that-good/answer/Yong-Yuan https://www.quora.com/Are-Netflix-employees-really-that-good... To those who couldn't scale out Graphite and got crushed under gruesome oncall alarms, the Netflix folks were 100x engineers.

ipnon 6y ago
100x in this sense is akin to doctoral level research. Think SpaceX turning the impossible into the possible with reusable rockets. Their returns on investment are now 100x greater than their competitors.
user5994461 6y ago
Graphite has been obsolete for 5+ years. There are commercial products with unlimited scaling, great UI, alerting and a hundreds things out of the box (see datadog and competitors).
- chinathrow 6y ago
  That's not the point here. OP said, that the Netflix team could at the time deliver scale, while other teams couldn't.
  - hintymad 6y ago
    Yeah, and the key difference is simple: The 100x engineers in Netflix just understood that file-based lookup for key-value pairs won't scale for OLAP-like workload on time series, and of course they possessed the sheer capability of implementing the right technology from ground up.
  - diab0lic 6y ago
    I was on Roy's team at this time. I am not one of the four mentioned in the link, but I definitely know exactly who is being talked about. I wanted to comment that these four were considered outliers even by Netflix standards for being very high performing. So bear in mind the example is an extreme one.

lojack 6y ago

> Good developers are the ones that create code that resists the slide from a 10x code-base to a 0.1x code-base. 10x is 100 times bigger than 0.1x FWIW. > but I argue that it is at least partly due to the prevailing code-base. Its almost exclusively because of the prevailing code-base. We can't forget that the prevailing code base was built by developers of varying skills. You can have "100x" developers build it or you can have "0.1x" developers build it. > One of my least favorite people to work with is also a "high throughput" developer who is a prolific creator of software, but everything created by this person is an un-maintainable, un-documented, un-tested, brittle block of procedural copy-pasta that ends up in the critical business path. And yes, this developer "snapped" about a year ago and it has been a 3 person project ever since to scramble to fix this stuff. Was this person the aforementioned "Rick" from this article?

dktoao 6y ago
Obviously it wasn't "Rick" in the flesh (I think). But more a "Rick" class programmer. :) Sorry to anyone who's real name is Rick.

mettamage 6y ago

I have one friend and he programs at least ten times as fast as I do (in typing). I can barely keep it up with reading. And in my CS class I was in the top quarter percentile, he was in the top 1%. The difference is big. They type code as fast as I'm typing this comment, while having a sane architecture. The secret: they programmed a lot more as a kid.

jimbokun 6y ago
I think the sane architecture is the only relevant part. Real world "10x" developers are almost always in that class because they can solve the same problem with 1/10th the code of a 1x developer. Ability to solve problems with less code will always outpace faster typing.
- khalilravanna 6y ago
  To be clear, you don’t mean code golf levels of code-shortening, right? E.g. they’re also not sacrificing on clarity and readability of code to shorten it. They’re just removing unnecessary work. I think this is definitely good and creates a net gain for other devs. Because the people who shorten code at the cost of clarity are some of my least favorite people. I once saw “half = num >> 1” instead of, say, “half = floor(num / 2)”. The latter is 100% more clear to more people and doesn’t gate-keep on engineers who haven’t memorized bitwise operators. (Also, this wasn’t a context where the bitwise operator would be optimized by the compiler in case they wanted to throw that hogwash out there.)
  - bobthepanda 6y ago
    Code golfing is mostly a exercise in asininity. But personally, short, standard, and sweet is preferable to crazy newfangled mental model. I've seen way too many real-world examples of the idiom "it takes a lot of skill to write Java in every language."
  - dktoao 6y ago
    In the good old days half = num >> 1 Was standard practice and understandable by most engineers, as well as far and away much faster than a divide. Now-a-days, using a compiled language they are going to be translated into the same machine code supporting your point. However, it might still be a good idea in a scripting language doing heavy math lifting.

lhnz 6y ago

Er, isn't it a bit of a strawman to suggest that people that talk about 100x engineers are talking about 100x productivity? Nobody I've met thinks that there are a set of people that believe there are "developers that write code 100x faster than other developers" but when people write comments on HN they act like this is a really common belief and only they are able to spot that it's not sane... Everybody that I've met considers technical prowess more along the lines of: the ability to write complicated code which others would find difficult to do, the ability to simplify a problem in order that it can be solved without complexity, the ability to optimize the performance of something in order that it uses less resources, the ability to come up with an innovative design that others wouldn't have thought of, the ability to explain technical ideas to their colleagues in a way that enables others to achieve more, the ability to balance short-term goals against a long-term plan, etc.

pantalaimon 6y ago

I think people often underestimate how bad the average programmer is out there. It’s apparently not unheard of to have C programmers who don’t know function pointers or even structs work, or who don’t know what a build system is (only ever used an IDE). There are many people who will just plug stuff together until it works somehow, without understanding why or how it works in the end.

user5994461 6y ago
Indeed, have a little trip to the outsourcing world, where you're paying for a team of experienced developers, some of whom have never developed anything before. That's the antithesis of HN of course. Most commenters here probably work for tech companies.

qznc 6y ago

It is depressing that people are happy to just throw anecdotal evidence around without even defining what metric they multiply by 10x or 100x. There is some literature on it. For example, this blog post [0] contains some references. I have only read Peopleware. It says 10x is the difference from worst to best in terms of time and number of defects across a few hundred programmers. Also interesting: Within the same organization, there was only a difference of 30%. This means the environment is much more important than the skill, experience, or personality of a programmer. I cannot find any studies after 2000. Most of the data is even older. The Peopleware data is from Cobol, Fortran, Pascal, and C. [0] https://www.construx.com/blog/productivity-variations-among-software-developers-and-teams-the-origin-of-10x/ https://www.construx.com/blog/productivity-variations-among-...