Year Five
blog.jayfields.com
blog.jayfields.com
Likewise, unless you're a completely static individual, your own preferences will change. You might not mind a completely chaotic startup environment at age 26, but you might be over it by age 31. So given all that, over a five year period, what's the likelihood that you and and your company will evolve into being as good of a fit in Year 1 as it was in Year 5? Pretty damn unlikely.
Given this paradigm, the two errors most companies make are:
1) Treating this phenomenon as "disloyalty." For a lot of companies, it's not acceptable to say, "the company went one direction, I went another, let's stop dating and just be friends." Good companies understand this happens, treat their former employees like alumni, and a lot of good things can come out of "just being friends" (e.g. that former employee recommending to others they work at the company). Bad companies act butthurt and whine that Generation X/Y are a bunch of ungrateful 'job hoppers.'
2) Having stupid policies for those that continue to be a good fit through Year 5 and beyond. If a former employee ever says of a previous employer, "I liked it there, I just got a way bigger salary increase at my new company" or "I liked it there, but after I was promoted to Senior Engineer, the only real way to advance was through management/business," then that company lost a software engineer over something completely controllable. I see so many companies locking themselves into 2.7% annual cost of living raises for their current employees while they offer 20% more to new hires, and then complain "it's so hard to find good engineers." Well, no shit.
The OP has essentially managed to set parameters with his current employer where he's essentially in control on how his job will evolves, so he can ensure it evolves organically with his preferences, which is probably why he likes working there so much. But in lieu of having every engineer negotiate such a framework with their employers, it'd probably be a lot more effective for those employers to recognize that this "Year 5" phenomenon happens, and adjust accordingly (ie. not holding it against employees who no longer feel like a good fit, and compensating those who continue to be a good fit and produce)
If you do it too often then your CV looks bad, if you don't do it enough then your pay tends to rise slower than you would like.
3-4 years is that middle ground.
Typically, I can figure out in 6 months whether a job is going to lead to real membership in the effort and, if not, then I look for something else. Why shouldn't I? It's my life. Why am I some sociopathic "job hopper" for leaving?
Also, this guy seems pretty solid in general, but this...
There's always someone willing to pay you more than you're worth. After several years with a company it's likely that they're going to pay you what you're worth, but not what some other company thinks you're worth.
is total loser thinking. No, actually. The company you're with is going to pay you less than you're worth, knowing that most people are averse to change. That's also why landlords almost always raise rent in the first year.
To get anything even close to what you're worth (a half-decent programmer is worth $500k+ easily) you need to job hop to a degree that (a) most people can't stand, and (b) those who can stand it are unusual enough that regular society thinks there is something wrong with them.
Actually, the only way workers could get what they are actually worth would be for society to implement a basic income-- then no one would need to work, and companies would pay something resembling the actual value of the work furnished to them-- but I wouldn't hold my breath for that.
>is total loser thinking. No, actually.
When I finally quit my employee-day-job, I told them I'd do more work for them as a consultant. At 2x my previous hourly rate. They said yes, and I've gotten that rate several times since then as well from unrelated companies.
>a half-decent programmer is worth $500k+ easily
I would argue about what "half-decent" means, but generally think you're right that $500k for a good programmer would be a reasonable value. And by good I mean close to the 10x-25x end of the spectrum. [1]
I would describe someone in the 2-5x range as "half-decent" myself, and someone in that range is probably worth closer to $160k/year, tops. Someone at the top end of the productivity scale is faster, yes, but also produces better code, can debug that code more quickly, and can solve some problems that a "half-decent" programmer will simply never complete adequately.
[1] http://www.devtopics.com/programmer-productivity-the-tenfini...
Well, this is largely because overhead for employee positions can often run 2x salary. As an employee, you get benefits, health insurance, perks, job security (of sorts), and you're not "on the clock" the whole time - most companies do not expect that employees are actively working 8 hours a day, they expect they're getting 4-5 hours of focused useful work and the rest is lunch breaks, watercooler talk, impromptu discussions, administrative stuff like e-mail, and idle diversions like Hacker News and Facebook. As a consultant, you're only supposed to bill for the time you're actively working, and all the rest is your own time. It's quite possible that as a consultant with 2x your hourly rate you're costing the company less than you did as an employee.
When I've had friends that have converted from consultant to employee at the same company, the rule of thumb is 1000x hourly for annual salary, even though there're 2000 hours in a work-year. The difference is because of overhead, and the differing accounting for time.
I think the right measure of a programmer's worth is "the amount they'd get acqui-hired for if they made a product that caught some large company's attention." (Which really isn't that hard, these days, if that's what you set out to do.) By this measure, even the most crap programmer is worth $500k.
To me, this just proves that most programmers are stuck on dead-end make-work (see: http://michaelochurch.wordpress.com/2013/01/01/fourth-quadra... ) of very low yield.
Acq-hires are a sign of advanced trust sparsity. Enough bozos have gotten in (and bozo management is a more common culprit in this regard than bozo engineers) that the company has lost faith in its ability to find talent at the bottom. That might be a problem with its people; more often, it means that the middle-management filter keeps out light both ways. Employees don't know what's worth working on; people at the top don't know who the good employees (if any are still around, and once this happens many have left) are.
A mediocre programmer that the company trusts is worth $500,000++ per year. An untrusted programmer is worth zero (actually, I'd argue, negative once they realize that the organization will never trust them) and put on low-yield busy-work or sent on wild goose chases (maintenance projects that won't work, "make it work exactly like the old system, but <X>" projects) and generally loaded with crap work to test reliability.
Most companies, because developer salaries are so low in comparison to what we're worth (if trusted), feel like that's an excuse to hire 5x the number of people they actually plan on trusting. The problem is that good people are the first ones to leave when given crappy, obviously evaluative, work.
I disagree with that number as an absolute statement. Most companies just aren't as insanely profitable as Google, Microsoft etc. (for whom this number might very well be true).
The reality, though, is that the value ratio between a 2.0 and 1.0 is anywhere from 1-plus-epsilon [0] to 100; usually 3 to 10. Most people would say that 2.0 is the "10x", so someone like me is actually a 6-7x. However, it's context dependent. With a hard problem and limited or no legacy, it can be 20-100.
[0] Actually, it might be sub-1, when one considers that a 2.0-level programmer would probably be miserable doing junior-level work.
Still, I think it's a fair call to say that even the 3-4x are worth $200k per year. Why? If you treat them very well, you can turn them into 10x-ers and you'll only have to give them ~10% raises as long as you keep giving them interesting problems.
People have forgotten that mentoring of untapped talent is a huge arbitrage. Yes, some of them leave. But if the ones who stay are worth millions to you and half do, you're still going to come out ahead.
If I were running a tech company, I'd pay guys like Peter Norvig $2 million per year and my juniors $150-200k and just have the Norvig-level guys (and gals) mentor them. Some would jump to Facebook and Google to double up their salary, but I'd make a huge profit margin on the ones who stayed.
I would claim to be a 2+ programmer myself. You don't need to believe me, of course, but based on your descriptions of the various ranks, I believe I would qualify. And yes, I do want to get into a position where I'm mentoring junior developers, but so far it's been sufficient too just handle all the programming myself.
Writing all the code for both the client and the server gets old after a while, though, even if it means that everything works really well, even on low-end commodity hardware. So yes, I think I will be following your suggestion and hiring a junior developer soon. At least if my Kickstarter (not yet live) funds.
What if we can reduce job searching to an approximation of perfect competition?
What if...
1. A central third party certifies your "ability" or "smartness" in certain areas (this prevents dumb things like "can u implement merge sort? lol!" ten times over). The certification would be temporally limited to, say, 60 days. After 60 days you would have to re-certify if you are still job searching.
2. You interview a few places for cultural fit and specific technical issues, then multiple companies (time limited to a week or two) submit public offers for you (if you are as good as you think you are).
3. Employers bid against each other for you (standard "each bid extends the bidding by X time units" rules so you don't get sniped).
4. You take your pick of employers based on how you personally weigh comfort, responsibility, pay, distance, and cultural fit.
Is that workable? What would the gross objections be?
We got that new organization. Microsoft did certifying with the MCSE. Of course, I've heard MCSE used more often as a punchline than as a job requirement, so that hasn't helped us too much, either.
Thus, we move into the tests companies actually perform while hiring. Here, we still have the problem that no one agrees on the smartness test. On the one hand, puzzles that I've considered trivial logic puzzles that have been declared obscure memorization tests by people who are certainly more qualified than I am. On the other hand, I've seen programmers who literally couldn't tell a hard drive from a network card breeze through interviews on the basis of rote memorization. Even if we could find a good rubric for grading programmers, we'd need to sell the businesses on this test.
I agree that hiring is completely broken and that outsourcing it to a company who makes it their expertise is pretty much the future of business. Honestly, the reason I've written so much here is because I've spent a lot of time thinking about this idea, too, and these are the issues I've run into. However, until problem #1 is solved, I don't see this going forward.
Sorry, but bollocks.
I've passed a few chemistry courses over the years. I should not be allowed anywhere near any lab equipment these days.
Course knowledge is transient. I've seen undergrad CS seniors write while(1){} loops in multithreaded programs because they forgot mutexes existed. I've seen CS PhDs copy/paste PHP code online to get a website together because their focus area was compiler register allocation.
I go through periods of time where I use Python extensively. Then I don't use it for a year. It doesn't mean I "don't know" Python, but it takes a while to get the APIs and libraries loaded back into my head (especially if I've been using two or three or four other languages in the interim).
By "certify ability" I don't mean anything as egregious as an MCSE or CCIE (or even a droll CCNA), but more a pre-level of interviews to weed out people who are literally a waste of time. The "certify" process would have different tracks depending on intended job target. A Programmer's Programmer would be get a heavily algorithm set of tasks/questions/live code tests while a devops person would have a practical set of questions with a few programming-ish things thrown in for completeness.
A central, trusted, certification can weed out inept interviewers too. Everybody knows some interviewer who asks really obscure questions (or simple questions worded poorly) from the back of an algorithms textbook. Then, they use the confusion of the interviewee as an excuse to rate them lower in the post-interview team meeting. Crap like that is unacceptable.
"Except a large number people on HN who do hiring don't agree with this ranking"
So you agree with him, but insult him.
The whole point of the parent's post is that a "central, trusted certification" is very hard to achieve in practice.
I don't, however, see how it's going to get rid of the the bad interviewers. Since the idea is to do a pre-interview to screen out the dead weight, it means that the individual firms will still need to do a more specific interview. Thus, we'll still have the same local interviewers asking the same questions about trigraphs in C. The problem isn't just that these people suck at giving interviews - it's that they believe that they're GREAT at it.
That sounds more like they memorized mutexes, but never actually learned them. Learning is what happens when you're forced to tackle a hard problem with a [new skill]-shaped hole. It doesn't happen when you read a textbook and then regurgitate it onto an exam. Universities (at least at the undergrad level) aren't actually very good at imbuing learning.
I can see the strikes now...
If someone could verify programming ability above the 95th percentile, that would be a huge service.
Unfortunately, I can't just make people know how good I am by saying it. You can't either. No one can. And social proof (which is what drives most economic decisions) comes down to reputation politics rather than capability.
I think open source is the best way for a person to do this, but how often does a company actually read someone's open-source contribs? The one startup I was at where I was actually involved in recruiting, people just checked to see whether the candidate's technology choices matched their language prejudices (there was a serious tech-stack war going on at the time).
Also, a lot of companies only need 40th percentile programmers. Everybody seems to want to hire I-Can-Create-Google-In-A-Weekend people. Sorry, but your online coffee ordering startup doesn't need me to waste an hour in pre-interviews rehashing sorting algorithms from undergrad. I've a library of work. Let's talk like humans, not machines requiring proof-of-work tests against each other.
Also, while I agree that the coffee shop website doesn't require Donald Knuth, the hard part will be convincing the coffee shop owner that that's true. Especially with the meme that "A players hire A player; B players hire C players". It's just an issue of marketing. If your firm was promising a 40% programmer for $50k and mine was promising a 99.9% programmer for $25k, most of the hiring manager I've known would hire mine, despite my testing procedure obviously being crap.
Also, I'd want people to get some direction on how to improve. Who cares if you're a 40th percentile programmer now? What matters is what it will take to get you to 80 or 90 or 99. That's what's actually important: getting better.
The main thing for me, however, is that it'd be great to have some insight into which companies and managers improve peoples' careers (for the long term) and which hurt. Transparency into that could bring about a dramatically different market.
Assessing programmers is a good idea, but what I would really like to do is start measuring companies and managers for how they affect peoples' careers, so we can reward the faithful and punish defectors.
If you look at salary trends, you're also picking up reputation, which corrupts measurement. Of course anyone leaving Google is going to be getting a bump. If you could asses actual skill and noticed that it wasn't doing much for the underlying (e.g. their actual capability growth) which will have more effect on their careers in the long term.
Now, the problem with the auction site concept (not to say that it won't work; but you'll have to make the ability verification both very accurate and very respected) that you're talking about is the "ghetto" effect that most recruiting sites get. Good engineers are nervous about signing on because it's still stigmatized to be looking for work at all. Top-end employers are going to prefer word-of-mouth for similar reasons. It's really hard to make a job-searching site not a ghetto, and once it is one, trust-sparsity sets in and it's inferior to the (non-scalable and infuriatingly intermittent) word-of-mouth economy.
The only company I'm aware of that does this (paying "flawless market value") is Netflix.
I'm not convinced that anyone can even measure what an individual programmer is worth, especially because project/person fit is always a contributing factor but huge at the upper levels. So I'm curious as to how they would do this.
Of course, by his thinking, the others are being paid above their worth! While he is by definition correctly compensated!