Hacker News new | comments | show | ask | jobs | submit login
Year Five (jayfields.com)
60 points by lkrubner 1689 days ago | hide | past | web | favorite | 33 comments

For software engineers, it's extremely likely that whatever company you started working for in Year 1 will be completely different in Year 5. Google wasn't the same company in 1999 that it was in 2004, which wasn't the same company that it was in 2009, which won't be the same company that it will be in 2014. Leadership, culture, technology, teams, products -- these all can change, and you may not be happy with that outcome of that change.

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)

I think this is the same for all roles and isn't related to programmers or programming (IMHO). If you want your pay to rise at a faster rate you move.

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.

I'm pretty sure that it's not completely random. 4-year vesting schedules are common in the industry amongst companies that provide stock or stock options as compensation. Considering that that form of compensation ends on your fourth anniversary, it would make sense that engineers would at that point move on.

Isn't this only true for companies that provide a grant at signing and no other grants afterwards?

I'm surprised that more companies don't pay (the employees they want to keep) what their "flawless market value" would be

The only company I'm aware of that does this (paying "flawless market value") is Netflix.

How do they assess it?

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.

The average job in general lasts 4.4 years at this point, so this isn't just an issue for programmers. That's just the nature of things. At most jobs, you hit a ceiling pretty quickly, or you get grunt work that doesn't help your career, or you get laid off, or the people you like move away, something else happens that makes it a good idea to roll the dice again.

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.

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

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

"I'd do more work for them as a consultant. At 2x my previous hourly rate."

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.

Very true. But under the new regime, I was able to also work on my own personal projects the rest of the time. A big win for me.

Then it's not really that they were paying you less than you were worth, it's that there was an alternate business arrangement that was a win-win for everybody. :-)

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

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

> A mediocre programmer that the company trusts is worth $500,000++ per year

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

I actually have tried to measure the "10x" factor and I've come up with the scale here: http://michaelochurch.wordpress.com/2013/04/22/gervais-macle...

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.

If you could double a $150-200k salary at Google, then maybe I should have considered interviewing there. I've been invited more than once, but didn't really want the corporate environment.

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.

workers could get what they are actually worth

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?

I think that the problem entirely rests with #1. First, consider that this central third party already exists: Universities. I have a PhD, so I should be hired over someone who has only a BS and we should both be hired over someone who never went to college. Except a large number people on HN who do hiring don't agree with this ranking (and rightly so - I'm only an average programmer). Therefore, we need a new organization to do this certification.

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.

You didn't read the parent very carefully before calling it "bollocks". Parent sets up each idea and gives the reason it's not the solution. Here's what he says about using university degrees:

"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 agree with you completely that the universities aren't the answer here. I might have been good at 68k Assembler back when I was taking my computer architecture course, but I haven't touched it since the Lord of the Rings films came out. I wasn't trying to say that Universities were any good at this job, but that they're an example of how a central trusted certification agency can fail.

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.

> I've seen undergrad CS seniors write while(1){} loops in multithreaded programs because they forgot mutexes existed.

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.

> 1. A central third party certifies your "ability" or "smartness" in certain areas

I can see the strikes now...

It would be really great if someone could do that in a way that was trustworthy at high levels. The problem with those professional certifications is that they're targeted toward the middle of the bell-curve. Above the 95th percentile, it all comes to word of mouth and introductions. Which kills you if (a) you want to change cities or (b) you've been working 80+ hours per week on something and your networking has gone to shit.

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

I think the problem with your service would be on the supply side. Businesses would obviously love to have these best of breed programmers, but the getting people to take your test will be trickier. To put it differently, how would you respond if I ran a business like this, you took my test, and I reported to companies that you're in the 40th percentile among programmers?

That would be awesome to know. I often don't know how good or bad I am. I often think I'm pretty inept until I look around. I'd love to know how inept I actually am so I can improve.

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.

Honestly, I agree with you. My main concern is that I've known too many programmers with their self-esteem wrapped up in the idea that they're the world's greatest who would balk at any test that didn't end with being given a Turing award. Now, any business that can keep these guys out of your hiring pool is already a net positive, but it's also going to kill a disappointingly large part of your base.

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.

Perhaps one that displayed rating with an average salary of that rating might fix this problem?

Well, I wouldn't want any such service to become a hard requirement for getting jobs. I'm just saying that it would be better for me, personally, if I had a reliable way of demonstrating, on the drop, where I stand.

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.

We should talk. I have an idea that would incorporate this. I doubt that I'll be able to get the resources and will probably be starting a regular day job instead (and I never go into a job intending to "hop") but discussing the idea would be useful.

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.

Enjoy your below average salary with thinking like that...

I'm guessing that a programmer at one of the top proprietary trading firms does not get a below-average salary.

Depends, if others are making 5m a year while he is making 500k...

Of course, by his thinking, the others are being paid above their worth! While he is by definition correctly compensated!

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