Productivity really is difficult to measure, especially in software development.
The biggest productivity difference between two programmers isn't that one of them produces more of the same thing as the other. Or that one of them produces more of a better thing that the other. Or even that one of them produces a more of a better, different thing than the other. It's that one of them actually grasps the thing that should to be done and does it. And it can take a long time to even realize or understand what it is the programmer is doing (often, the programmer doesn't fully understand it at first either).
My biggest problem with the 10x productivity claims is that it ignores the most relevant difference. The best programmers don't do the same things faster, they do completely different things.
I thought the 10x productivity claim was originally from a study of comp sci students working on some algorithm (maybe compression algorithm) homework. In which case the "I think I've seen this before" example from the article probably factors in most.
The examples listed seem to appear at companies that have in-house developers, but don't really think of IT as an area they should focus on. Similarly, I often found my ex ad-agency co-workers have trouble understanding why I have to browse blogs/manuals, take time to think things through, sketch graphs and sometimes just start over instead of refactoring.
Really, software managers should have no trouble noticing a 10:1 skill difference between devs.
When the business of the company isn't software, there is a good chance that the manager won't be a software developer. The criteria the developer is judged by will have nothing to do with the complexity of the software or the time it takes to create. Instead, their work will be judged and compensated by the value it delivers to the organization. Even if it's crappy software.
You say that like it's different, or should be, at a software company.
I disagree. I think that all work for an organization should be judged and compensated by the value said work delivers to said organization, regardless of the organization type, regardless of the work type.
> Even if it's crappy software.
Surely you're not suggesting that crappy software is always wrong/bad.
Good software is often more expensive than crappy software. That added expense doesn't necessarily produce more value.
Good programmers know that they're trying to maximize benefits-costs, not maximize the former, not minimize the latter.
Worse can be better.
I absolutly agree with you, and on HN many of us are in a filter bubble in which the companies we are surounded my have a good deal of people that know software and creativity. The reality out in the real word though is much different. Many companies have managers that have never worked on software in their life, there is a school of thought that management is management, and for some disciplines it is true management is transferable, those of us in technology know this to be idiotic but if you came from a traditional enterprise and have seen multiple manager move from inventory to shipping and be successful you would believe the converse to be true. Years of observation reinforce this to those individuals and create cultures in which management is management.
They really weren't as bad as that statement makes them seem, and I think it was more a misguided "rah rah" statement than a core mentality, but there were days when I couldn't quite tell.
The tough part is extracting the business logic and correctly mapping this to code. If done well, this will create more value to the business than a drag-and-drop framework.
"We're middle-men (and women), glorified translators, and we're in the unbelievably fortunate position that programming computers is still much too hard for the average user of those computers, so we translate wishes and domain knowledge into a mental representation of machinery that performs some useful task."
The business logic is "the hard part" only in terms of client communication and project management, and then only barely.
Learning that "an Account Rep has Clients", and then modelling and implementing that, is ... not challenging? Three lines of ActiveRecord ('Duplo')?
They both vary tremendously depending on the problem, but on the whole, 'javascript widgets' trumps 'business logic' hands down. The fact that most business logic is simple is why you can glue things together so fast in Rails.
Olark's whole business is making a single javascript widget, and last I checked, they're still hiring.
Making things behave as expected in as heterogenous environment as the browser can be enormously complex as the sophistication and scope of the UI you present the user grows.
IMO, making that software to handle the business processes IS way more valuable to the business than a drag and drop widget framework. Especially if you execute it well, it can make the business hum.
PS: Yes, copy and paste is easy, and yes it looks like work, but it's rarely the correct solution.
But I agree with you if you're going in with a blank slate.
Yeah, but it's the part that most customers actually want. They pay for that, not for javascript widgets. A lot of customers are incredibly happy with basic, predictable interfaces, as long as they perform all the necessary "magic" calculations in the background, quickly and reliably.
So many developers waste their time chasing "the shiny", but most of the money is actually elsewhere.
And to answer the original question, yes it was complex, but that was 5 years ago. People didn't really know how to build complex solutions in javascript and there were no working examples you could just copy, paste and modify.
You were also very restricted by the speed that IE6 ran javascript on old computers.
If you believe this then perhaps you have never developed anything complicated at all.
"The fact that most business logic is simple is why you can glue things together so fast in Rails."
If it is this simple one must question why the work is done by a developer at all. Why are users not using some sort of web-based MS Access?
Actually, it might be even more complicated to _complete_ the extremely boring task.
* - in this particular example, js drag&drop being an interesting task is a subjective assumption, but I guess "yet another CRUD app" being boring is an objective reality :)
The other thing I've seen happen is that the more productive programmers are asked to do the more complicated things. So they'd be the ones creating a javascript drag-drop widgets framework while the less capable were stitching together CRUD apps with a bit of business logic in the backend.
This then looks like they're both delivering products, the CRUD app may even earn a lot more money for the business in the short term too.
I've even seen this kind of skill discrepancy in call centres when I temped as a student, this isn't restricted to the programming field. There's always a couple of people who knew how to fix actual problems rather than just enter payment details, they'd always be handed the troublesome clients but rarely got paid more.
I ended up as one of these myself, but none of us ever complained about being paid the same as Bob the lazy call avoider because it made our jobs far more interesting and satisfying.
In the end I guess part of being a high performer is that you know you're going to get the jobs that interest you and that in truth would just frustrate and demoralize your colleagues. It's not always about the pay.