ACM_总论_如何辨别优秀的程序员

       转自：http://kb.cnblogs.com/page/108524/

　　　　这并不是想象的那么容易。简历上的工作经历并不能说明什么问题，因为卓越的程序员并非总是有“正式”的工作经验来说明他们有多优秀。事实上，简历上的工作经历往往会误导。不过，从简历中还是可以得到某人是否是卓越程序员的一些细微线索。

　　我觉得自己是一个非常优秀的程序员。同时，我也花费了大量的时间在商业圈，找技术人员做项目，面试别人等等。正是如此，我觉得自己有足够的经验去识别一个优秀的程序员，我会在下文中分享，希望能够帮助那些 “商业人士”更好地找到人才。那些有可能成为优秀程序员但还没有摸到门道的，也可以阅读这篇文章，从而发现自己需要改进的地方。

　　在Paul Graham的这篇《导致创业失败的18个错误》文章里提到：

“在90年代，导致绝大多数创业失败的是那些劣质的程序员，很多这样的公司是几个商人共同创立的，他们有聪明的想法，然后让程序员来实现这些想法。但事实上要困难地多——因为那些企业家他们无法分辨一个程序员是否优秀。他们甚至都没有机会见到那些顶级的程序员。

事实上，那些商人选择自己认为优秀的程序员(比如简历上提到自己曾是微软的工程师)，但事实上不是。然后会发现创业之路就像二次大战一样艰难。”

　　如果你不是程序员，如何来挑选优秀的程序员呢？我觉得没有最佳答案。我想说你最好找一个优秀的程序员来帮你筛选。但你如何找到这个人？

　　这点上，我不太同意Graham。我觉得优秀的程序员有很多特质。即使一个商人也能识别。我下面来一一列举。

　　0. 激情

　　在我与别人合作的经历中，遇到过很多技术员：他们写程序，因为他们觉得这是份不错的工作。业余时间从来不会去编程。当他们知道我家里有一个局域网和3台电脑时，显得很震惊。他们只是在工作，不会主动学习新事物，除非工作中需要，或者为了找份工作。当一天的工作结束时就再也不想谈论它了。有些人觉得工作之余谈工作不适合社交。但如果你想结识一个优秀的程序员，体现出自己的激情是很重要的。

　　1. 自学并喜欢学习

　　时过境迁，编程语言也在不断进步和完善，新的技术会出现，新的标准也会到来。当然不是说，所有优秀的程序员都对那些事物有浓厚的兴趣，但有很多程序 员他们从来不会主动学习新事物，除非迫不得已，因为他们不喜欢学习新东西。这些人往往是在大学时学的计算机专业，然后渴望毕业后找到份好工作。

　　如果你打算雇佣某个程序员，只要提到“我能掌握那个，只要把我送到培训中心一个星期”。不要雇佣那样的人。优秀的程序员不需要培训中心。事实上，优秀的程序员会提到你从未听过的新技术，然后向你解释为什么必须用它，即使他都不知道如何使用。

　　2. 聪慧

　　有些商人觉得缺乏情商就是不够聪慧。事实上聪慧包括很多因素，情商只是其中之一。优秀的程序员不是不会说话，事实上，优秀的程序员通常是你认识的人中最聪明的。他们中的很多人有很好的社交能力。我参加过几次 London Ruby User聚会，除了少数几个特例，大多数人都很聪明，善谈，兴趣广泛等等。但你不会在公众场合看到他们谈论，然后会想“这是怎样的一帮geek啊”。

　　不要认为那些话不多的人就是好的程序员。他们不是，如果在完全放松的环境下都不能很好地交流，他们不是优秀程序员的概率会很大。

　　3. 隐藏技能

　　这跟激情有关，也是优秀程序员的一个特征。

　　我在9岁时就开始编程，那时还不是在PC上，后来迁移到了PC，学了Pascal。当我14岁时，用C和Assembler写了一个 raycasting引擎。花费了大量的时间与显卡打交道，终于可以看到很酷的图形效果。在这之前，我只是个二流的程序员，没有信心做任何复杂的事情。当我完成它时，我收获了自信。我知道只要我想，再难的事情我都能搞定。

　　这会在我的简历上出现吗？不会

　　我深信大多数优秀的程序员都有类似的冰山不会出现在简历上。他们觉得这不是“合适的经历”。可以对那些潜在的优秀程序员问一个这样的问题“你能告诉我一个自己独立完成的项目吗？即使是不完整的，在业余时间开发的，没有出现在简历上？”如果他们不能，他们很可能不是优秀的程序员。

　　4. 多种技能

　　这个很简单，由于对新鲜事物的热情和强烈的求知欲，那些22岁以上的程序员通常掌握好几门语言。这不可避免，学习一个新技术是最有意思的事情之一。

　　5. 证书

　　这其实不是一个优秀程序员的特征，很多有计算机相关证书，很多没有。年龄也一样，有些18岁就展露头角，有些40岁才有所成就。我的经历告诉我，大多数平凡或者差的程序员大学时才开始编程，为了他们的计算机课程。而优秀的程序员编程的历史可以追溯到更远。如果你的准程序员在大学前没有接触过编程，他所有的经历都是从第一份工作开始的，他很可能不是一个优秀的程序员。

　　声明

　　上面或者下面所说的特征不是必备的。你很可能会发现 NB的程序员不符合这些特征。我的观点是，你不太可能找到一个优秀的程序员不符合这些特征中的任意一条。当然，你也会发现差的程序员也符合这些特征中的某几个。但我深信，一个程序员，这些特征符合地越多，那么他是优秀程序员的概率就越大，作为一个商人，你可以信赖这些人。

　　总结

　　以下几个特征，能够帮助你找到优秀的程序员

@对技术充满热情
@编程是生活的一部分
@会在你的耳边谈论技术相关的话题，如果你有兴趣的话
@主动学习新技术
@对自己不能认同的技术，感到不适应，无法全身心投入
@聪明，对很多话题都感兴趣
@在大学/工作之前就开始编程了
@有隐藏的冰山，自己完成的大项目
@对许多不相关的技术有了解

 

 

 

下面是英语原文：

转自：http://www.inter-sections.net/2007/11/13/how-to-recognise-a-good-programmer/

                          How to recognise a good programmer 

 

How do you recognise good programmers if you’re a business guy?

It’s not as easy as it sounds. CV experience is only of limited use here, because great programmers don’t always have the “official” experience to demonstrate that they’re great. In fact, a lot of that CV experience can be misleading. Yet there are a number of subtle cues that you can get, even from the CV, to figure out whether someone’s a great programmer.

I consider myself to be a pretty good programmer. At the same time, I’ve spent a fair amount of time on the business side of the fence, filtering technical CVs for projects, interviewing people, etc. Thanks to this, I think I have a bit of experience in recognising good programmers, and I want to share it in this article, in the hope that it may help other “business guys” to recognise good programmers. And, who knows, perhaps some programmers who have the potential to be good but haven’t really exploited this can also read this and realise what they need to do to become good (although, as I’ll argue, that’s definitely not accessible to all programmers!).

 

In his article The 18 mistakes that kill startups, Paul Graham makes the following point:

“… what killed most of the startups in the e-commerce business back in the 90s, it was bad programmers. A lot of those companies were started by business guys who thought the way startups worked was that you had some clever idea and then hired programmers to implement it. That’s actually much harder than it sounds—almost impossibly hard in fact—because business guys can’t tell which are the good programmers. They don’t even get a shot at the best ones, because no one really good wants a job implementing the vision of a business guy.

In practice what happens is that the business guys choose people they think are good programmers (it says here on his resume that he’s a Microsoft Certified Developer) but who aren’t. Then they’re mystified to find that their startup lumbers along like a World War II bomber while their competitors scream past like jet fighters. This kind of startup is in the same position as a big company, but without the advantages.

So how do you pick good programmers if you’re not a programmer? I don’t think there’s an answer. I was about to say you’d have to find a good programmer to help you hire people. But if you can’t recognize good programmers, how would you even do that?”

I disagree with Mr Graham on this one. I think there are a number of very strong indicators of a “good programmer” (and, conversely, strong indicators of a “not-so-good programmer”) that even a business guy can recognise. I’ll summarise some key indicators and counter-indicators in a list at the end of the article.

#1 : Passion

In my corporate experience, I met a kind of technical guy I’d never met before: the career programmer. This is a person who’s doing IT because they think it’s a good career. They don’t do any programming in their spare time. They’re shocked when they find out I have a LAN and 3 computers at home. They just do it at work. They don’t learn new stuff unless sent on a training program (or motivated by the need to get a job that requires that technology). They do “programming” as a day job. They don’t really want to talk about it outside of work. When they do, they talk with a distinctive lack of enthusiasm. Basically, they lack passion.

I believe that good developers are always passionate about programming. Good developers would do some programming even if they weren’t being paid for it. Good programmers will have a tendency to talk your ear off about some technical detail of what they’re working on (but while clearly believing, sincerely, that what they’re talking about is really worth talking about). Some people might see that as maladapted social skills (which it is), but if you want to recognise a good developer, this passion for what they’re doing at the expense of social smoothness is a very strong indicator. Can you get this guy to excitedly chat up a technology that he’s using, for a whole half hour, without losing steam? Then you might be onto a winner.

#2 : Self-teaching and love of learning

Programming is the ultimate moving target. Not a year goes by without some new technology robbing an old, established standard blind and changing half the development universe. This is not to say that all good programmers pick up these changes and ride the bleeding edge. However, there’s a class of programmers that will never, ever pick up a new technology unless forced to, because they don’t like learning new stuff. These programmers will typically have learnt programming at university, and expect to get by on whatever skills they picked up there, plus whatever courses their company is willing to send them on.

If you’re thinking of hiring someone as a programmer, and he ever utters the words “I can work with that, just send me on a training course for a week and I’ll be good at it”, don’t hire that guy. A good programmer doesn’t need a training course to learn a new technology. In fact, the great programmer will be the one talking your ear off about a new technology that you haven’t even heard of, explaining to you why you must use it in your business, even if none of your staff knows how to use it. Even if it’s a technology he doesn’t know how to use yet.

#3 : Intelligence

Some business people assume that lack of social tact and lack of intelligence are the same. Actually, intelligence has several facets, and emotional/social intelligence is only one of them. Good programmers aren’t dumb. Ever. In fact, good programmers are usually amongst the smartest people you know. Many of them will actually have pretty good social skills too. The cliché of the programmer who’s incapable of having a conversation is just that - a cliché. I’ve been to a few meetings of the London Ruby User Group and I can say that with only a very few exceptions, most people there are smart, talkative, sociable, have varied interests, etc. You wouldn’t look at them chattering away in the pub and think “what a bunch of geeks!” - at least until you approach a group and realise they’re talking about the best way to design a RESTful application with a heavy UI frontend.

This doesn’t mean that they’ll all feel comfortable in every social context. But it does mean that if the context is comfortable and non-threatening enough, you’ll be able to have as great a conversation with them as you would with the most “socially enabled” people (perhaps better, since most good programmers I know like their conversation to revolve around actually useful topics, rather than just inane banter).

Don’t ever hire a dumb person thinking they’re a good developer. They’re not. If you can’t have a great conversation with them in a relaxed social context, they’re very likely not a good programmer. On the other hand, anyone who’s clearly very smart at the very least has a strong potential to be a good or great programmer.

#4 : Hidden experience

This is correlated with the “Passion” point, but it is such a strong indicator that I’d like to emphasise it with its own point.

I started programming when I was about 9, on a Commodore 64. I then migrated onto the PC, did some Pascal. When I was 14 I wrote a raycasting engine in C and Assembler, spent a large amount of time playing with cool graphic effects that you could get your computer to do by messing directly with the video card. This was what I call my “coccoon stage”. When I entered that stage, I was a mediocre programmer, and lacked the confidence to do anything really complicated. When I finished it, I had gained that confidence. I knew that I could code pretty much anything so long as I put my mind to it.

Has that ever appeared on my CV? Nope.

I strongly believe that most good programmers will have a hidden iceberg or two like this that doesn’t appear on their CV or profile. Something they think isn’t really relevant, because it’s not “proper experience”, but which actually represents an awesome accomplishment. A good question to ask a potential “good programmer” in an interview would be “can you tell me about a personal project - even or especially one that’s completely irrelevant - that you did in your spare time, and that’s not on your CV?” If they can’t (unless their CV is 20 pages long), they’re probably not a good programmer. Even a programmer with an exhaustive CV will have some significant projects that are missing from there.

#5 : Variety of technologies

This one’s pretty simple. Because of the love of learning and toying with new technologies that comes with the package of being a “good programmer”, it’s inevitable that any “good programmer” over the age of 22 will be fluent in a dozen different technologies. They can’t help it. Learning a new technology is one of the most fun things a programmer with any passion can do. So they’ll do it all the time, and accumulate a portfolio of things they’ve “played around with”. They may not be experts at all of them, but all decent programmers will be fluent in a large inventory of unrelated technologies.

That “unrelated” bit is the subtle twist. Every half-decent java programmer will be able to list a set of technologies like “Java, J2EE, Ant, XML, SQL, Hibernate, Spring, Struts, EJB, Shell scripting”, etc.. But those are all part of the same technology stack, all directly related to each other. This is possibly hard to recognise for non-programmers, but it is possible to tell whether their technology stack is varied by talking to them about it, and asking them how the different technologies they know relate to each other. Over-specialisation in a single technology stack is an indicator of a not-so-good programmer.

Finally, if some of those technologies are at the bleeding edge, that’s a good positive indicator. For instance, today (November 2007), knowledge of Merb, Flex, RSpec, HAML, UJS, and many others… Please note that these are fairly closely related technologies, so in a couple of years, someone who knows all these will be equivalent to someone familiar with the Java stack listed in the previous paragraph.

Update: As a clarification to this point, there’s in fact two indicators here: variety and bleeding edge. Those are separate indicators. A good variety of technologies across a period of time is a positive indicator, whether or not the technologies are bleeding edge. And bleeding edge technologies are a positive indicator, whether or not there’s a variety of them.

#6 : Formal qualifications

This is more a of non-indicator than a counter-indicator. The key point to outline here is that formal qualifications don’t mean squat when you’re trying to recognise a good programmer. Many good programmers will have a degree in Computer Science. Many won’t. Certifications, like MCSE or SCJP or the like, don’t mean anything either. These are designed to be accessible and desirable to all. The only thing they indicate is a certain level of knowledge of a technology. They’re safeguards that allow technology recruitment people in large corporations to know “ok, this guy knows java, he’s got a certification to prove it” without having to interview them.

If you’re hiring for a small business, or you need really smart developers for a crack team that will implement agile development in your enterprise, you should disregard most formal qualifications as noise. They really don’t tell you very much about whether the programmer is good. Similarly, disregard age. Some programmers are awesome at 18. Others are awesome at 40. You can’t base your decisions about programmer quality on age (though you might decide to hire people around a certain age to have a better fit in the company; please do note that age discrimination is illegal in most countries!).

As a final note to this, in my experience most average or poor programmers start programming at university, for their Computer Science course. Most good programmers started programming long before, and the degree was just a natural continuation of their hobby. If your potential programmer didn’t do any programming before university, and all his experience starts when she got her first job, she’s probably not a good programmer.

Disclaimer

None of the indicators above or below are sure-fire indicators. You will find great programmers who break some of those moulds. However, my view is, you’ll rarely find a great programmer that breaks all of them. Similarly, you may find poor programmers that meet (or appear to meet) some of these criteria. But I do strongly believe that the more of these criteria a programmer meets, the more likely they are to be one of those elusive “good programmers” that, as a business guy, you need to partner with.

The criteria in bullets

So, in summary, here are some indicators and counter-indicators that should help you recognise a good programmer.

Positive indicators:

Passionate about technology
Programs as a hobby
Will talk your ear off on a technical subject if encouraged
Significant (and often numerous) personal side-projects over the years
Learns new technologies on his/her own
Opinionated about which technologies are better for various usages
Very uncomfortable about the idea of working with a technology he doesn’t believe to be “right”
Clearly smart, can have great conversations on a variety of topics
Started programming long before university/work
Has some hidden “icebergs”, large personal projects under the CV radar
Knowledge of a large variety of unrelated technologies (may not be on CV)

Negative indicators:

Programming is a day job
Don’t really want to “talk shop”, even when encouraged to
Learns new technologies in company-sponsored courses
Happy to work with whatever technology you’ve picked, “all technologies are good”
Doesn’t seem too smart
Started programming at university
All programming experience is on the CV
Focused mainly on one or two technology stacks (e.g. everything to do with developing a java application), with no experience outside of it

I hope these help. Let me know below if you have any comments, or anything to add to them!

Thanks for reading.