Companies will often pay for relo expenses for someone, providing they stay for X years (else they repay the relo money back). Companies could do something similar with education, whether it's local college classes, inhouse training, etc. If you leave within the first year, you pay the company back those expenses. Or... have retention bonuses for people for staying past 1 year, and invest in education for people at lower wages. Many companies would find some real gems out there, waiting to be discovered, and would engender far more loyalty than most currently get.

As far as having to pay back if you are laid off or the company is otherwise dissatisfied due to their own lack of having a decent vetting process, ha ha ha. Indentured servitude. That's a new one. I'm sure that will get the best of the best. Not.

The vast majority of my friends did not get relo packages, because this is their first job out of school. Companies don't typically offer relo for fresh college grads.

I thought this discussion was about junior engineers?

Or keep whining there's no employees.

One of these paths is more productive than the other.

It worked, well, terribly. The startup folded in a year and a half mostly because of code-quality issues. I remember talking to the founders near the end of my gap year, where they said that of the 10-ish or so high schoolers they hired, only two of us really produced more than we cost (even on our piddly $20-30k/year salaries), and even then we needed a fair bit of management support.

These were also not random people - one of the founders had been a teacher at my high school (he'd been an entrepreneur with a successful exit before then), and he basically skimmed the top of the class off and got them to work for him. Many of us later had successful careers at Google, Bain, or hedge funds.

But there's only so much that you can do to compensate for inexperience. There's a lot that you learn in your first job or two, even if you already know how to program. And until you learn it, there's a good chance that you'll be negatively productive.

If you have to hire the senior engineers anyway, why not hire only the senior engineers, at least in the early stages of the company? They'll be able to get actual work done, you'll have a decent codebase, and you might actually be able to ship a product that can get you additional funding and revenue. Then, once you've taken care of the money problem and the startup is no longer fighting for its life, you can hire some junior devs to flesh out the product and exploit market opportunities that you didn't have the resources to explore in the startup phase.

Over longer timescales (years), this relationship doesn't hold true. This is why Google, Microsoft, and many of the other big players in the industry can afford to hire junior engineers. That one senior engineer and five junior engineers will turn into six senior engineers, all of whom have worked closely together, and then you have a gelled team that can accomplish great things.

But you have to get there first. When a startup's fighting for its existence daily, it's not cost effective or prudent to make an investment that will take a couple years to pay off, when there's a good chance that your company will be out of business in six months.

You jump from that stage to Google as if there's nothing in between, but almost every other company is in between. Plenty of startups have been around for years, and plenty of them have enough funding to ensure that they'll still be around for years. At that point it becomes possible to make the short-term sacrifices necessary to ensure long-term success, like training.

In a startup every person has to pull their weight and there really isn't time for a formal training. I'd venture to guess that in almost all cases, this new hire will decrease the value of your company as a programmer.

That said, this approach could work at a large firm with stable revenues, a formal training program, and relatively straightforward IT requirements.

  * Nobody to hire
  * No jobs

Body shop consulting firms like Accenture have done this for decades.

Except for the government of course

Do you have experience hiring someone with no technical experience and turning them into a productive employee? How did you train them? How long did it take?

Startups have two options: they can choose to be lazy and risk-averse or they can complain about not being able to find workers. They can't do both.

However, they seem to run into problems when they want to find senor people to mentor the entry level hires. Entry level developers are rarely able to lead a team much less handle the various technology decisions of the contemporary tech startup.

What startups should be more open to is CS types that don't have years of experience in certain languages but have the ability to learn quickly. Too much focus on minor technologies that could be picked up in a few days.

I have a degree in Comparative Literature (which is not an English degree, btw). I would consider someone with a serious music degree, maybe philosophy (e.g. PG). Most liberal arts majors are not cut out to be engineers.

The problem that you'll then have though, is that when you encounter a tough technical challenge, you won't have the benefit of having someone on your team who has seen it before.

So there must be some golden ratio. A solid emphasis on college recruiting to serve immediate needs, with a focus on building out a technical knowledge base accompanied by many years of experience.

I'd argue the opposite case — if it's true that a good programmer is at least 5-10x more productive than an average programmer[1], you'd actually save money by paying the experienced programmer significantly more when compared to hiring a team of beginning or average programmers.

[1]: http://en.wikipedia.org/wiki/The_Mythical_Man-Month#The_surg...

English degrees? The number of English grads I've bumped into in the software industry has been small (in comparison to just how many English grads there are). Math grads would be better since most would have had to do some programming already (even if just in Mathematica). Even physics grads..

However, I've never met anyone below the MD at an investment bank who's working anywhere close to 9a-5p (unless you meant 9a to 5a which is more often the case with analysts).

So honestly, I don't think your approach is too bad.

You mean in the sense that both approaches work horribly?

Your way gets you 10 programmers that do a really good job. Now find the other 69,990 programmers. (I like to think I get a lot of work done, but I can't get 7,000 people's work done.)

(If it was my company, would I have a bunch of unrelated development departments with no common standards on 5 continents? No. But it's not my company, so I don't get to decide, I can only observe.)

All I am saying is that using open source as a way to find talented individuals who love what they do and are really good is one solid way I have found to find new talent. If that can only get me X number of devs a year than that is X number I don't have to hunt through resumes for.

I agree with the blogpost that colleges aren't doing a good job of transitioning students to the challenges of startup/modern tech workforce. But, it seems to me that the solution would be a number of big employers like Google and others who are more able to take the risks should hire up the most qualified and teach them those skills. Simply, if the undergraduate education isn't good enough, someone's gotta teach em.

From what I've seen, you've got a lot of developers commanding 60-80k salaries. From a startup perspective, I don't really understand why this is the only acceptable path.

It just seems smarter to locate near some technical colleges in cities that have a lower cost of living, and pay entry level developers a salary between 35-45k to start. As they improve their skills, you up their salary... assuming that improvement comes with an increase in revenues/profits.

At that level, they hire for aptitude, not experience. The $60-80K that Google pays for beginning hires is on the anticipation that after training, they'll be worth at least that much, and Google can retain them long enough for them to make it back. It's fairly common knowledge that a new Google engineer won't be productive for 6-8 months at least.

The risk that a startup runs by paying $35-45K is that they'll get people with lower aptitude who'll never turn into experienced engineers. That's a pretty big financial risk to take, particularly for a startup with much less runway than Google.

Actual developers cost much more than that.

You can start here: http://arstechnica.com/civis/viewtopic.php?f=25&t=223259...

or glassdoor

or virtually any former dev there

With all the OSS projects going on, I can’t believe anyone serious about development wouldn’t just use that for experience.