How much does typing speed matter?

I think the importance of being a good typist is that the act of typing doesn’t distract your train of thought. The speed is probably less important then the ability to think and have your thoughts come out of your fingers.

Jeff Atwood’s too easy a target, John — nobody ever said he had a deft hand with an analogy. Also, a closer comparison with a composer wouldn’t be skill at the piano, but speed writing musical notation. I found that I could get a lot more done on a piece once I changed my round noteheads and shaped flags to hash-marks and slashes for exactly the reason you point out: my hands could get a passage I’d worked out written down on paper while it was still in my memory.

I agree with you, it’s not how fast you can type, it’s how to keep your brain out of interruptions because of your low speed. As you said, you strictly should keep up your hands with your brain.

As a programmer, it doesn’t make sense if you’re typing at 150wpm while making lots of errors. Programmers gain speed gradually as long as they are coding for the market (not just practicing) that requires them to write lots of code all the day. Plus, programmers memorize all keyboard letters and symbols that no one else can really know them all. However, when programmers leave code and try to write any other thing, they usually type with errors because they used to code, to write in a special way, to use some strange abbreviations and shortcuts, and special way in character casing.

When someone’s holding a good deal of context in their head (i.e. programming), I’d argue that a quick typing speed makes it easier to act on one’s thoughts before any one of them is lost. Oftentimes code needs to be revised, and the cost of each mistake is multiplied when each line of code takes longer to rewrite.

Learning to type was a basic requirement I had to meet before I graduated from my public U.S. high school. I haven’t yet met a fellow employed programmer that hasn’t learned to type. Management types, yes, but programmers no.

A programmer that types slow, shows that they don’t have experience. By default a programmer should be able to type without looking at the keyboard, or hunt and peck. A keyboard is a tool of the trade, and they should be very good at using that tool. You wouldn’t want a plumber who didn’t know how to use a monkey wrench, or a mechanic work on your car and they don’t know how to properly use a socket wrench? That is the same with programming, if you don’t use it properly, then it shows that you don’t know the tools of the trade as well as you should.

At Microsoft, more than one programmer that I worked with got RSI in the wrist from typing. I don’t know whether to be impressed by a coder typing that much, or horrified.

I think of the correlation works differently. It isn’t that if you can’t touch type you can’t be a good programmer but of those who are physically capable of touch typing probably haven’t written as much code as those who can and while I recognize that there’s more to coding than just churning out big blocks of code. I think that once you’ve eliminated the clueless the people who have written more are likely to be better.

In my experience (35 years), typing speed does count, for a couple of reasons:
1. Getting sh*t done!
2. Capturing your thoughts quickly
3. Doing comprehensive documentation

The combination of touch typing and a keystroke oriented editor like EMACS has made me very productive.

And as a side comment, on one project we had our choice of conventional editor and command line compiling, or a ‘visual environment’ (Eclipse-like.) The best/most productive people tended to use editor+command line, for a couple of reasons:
a. They knew exactly what they were doing with that tool set
b. They didn’t want to waste any cycles on GUI, they wanted to write the code, run it through the compiler, and then if necessary test it out.

Those people also tended to stay away from debuggers, too, for similar reasons.

Florian, if casting a quick glance at the keyboard is derailing your thoughts, then you have less ability to concentrate than a fricken ferret on speed! Don’t just pull stuff out of where the sun don’t shine. Your eyes for example are saccading incessantly without you even noticing. And if you’re a programmer, and you’re in the flow ™ stuff like a glance to the keys will hardly (if at all) consciously register – let alone interrupt any thoughts!
Completely apart from that, I’d say that Stephen Hawking would probably make a better (and faster) coder by sucking at and blowing into his mouthpiece than even the fastest touch typist would.
Coding is mostly about thinking, then a lot of other stuff, and then typing: Programmers working on big projects will typically write around 10 lines of code per day, so if I bend backwards by one order of magnitude that would make 100 loc/day.
Anyways, the whole question is slightly absurd: Anyone who has done a lot of coding (which I guess might be prerequisite to being called a programmer) will have gotten used to using a keyboard. They may not be perfect ten-finger writers, but there isn’t any necessity for that. They’ll be fast enough.

http://en.wikipedia.org/wiki/Amdahl%27s_law would seem to be relevant to this conversation.

My father was an accomplished programmer that worked on some fairly well known projects for some very well known companies, yet he was absolutely the slowest hunt-and-peck typist I think I have ever met. It was really quite painful to watch.

My vote is that typing speed has absolutely no bearing on programming capability.

I type 100+wpm with accuracy, but am definitely not in the same league as my father was when it comes to programming skill.

Here’s the Star Wars equivalent of tough typing:
http://starwars.wikia.com/wiki/Form_VII:_Juyo_/_Vaapad

When the thoughts flow, you need to channel that stream into the keyboard, doing which needs minimal interruption.
Not to hint that programmers are a bit closer to the Dark Side, that is what *managers* are ;-D

The statistic I’ve commonly heard is that a typical programmer writes maybe 10 or 20 lines of code a day (presumably after several iterations of trial and error and cleaning things up). If this is true then a programmer is NOT a typist. A programmer is a problem solver who then implements the solution almost as an afterthought.

I’ve been a programing for 25+ years. Chief Architect on quite a few projects. Embedded and PC. I need to glance at the keyboard for reference. So I don’t touch type. But I do hold my hand in relatively the right positions. The primary job of a programmer is to think not code. Coding is what brings your ideas into existence. But most of the time its about understanding that lines particular implication to the algorithm and the edge cases of the problem domain, is there a better algorithm, should I refactor this, or is there an API for this because it seems pretty common thing to do.

I’ve tried dictating code which would be great for not only my speed but also my spelling. I found little productivity gain even with massive macroing for common things like loops and function setup. Code is notoriously full of misspellings and short variable names, and acronyms. They give enough productivity.

The reason i,j,k are used as index variables has actually more to do with your right hand location. But we tend too want more descriptive indexes that is why we spend the time. So that shows a bit of real speed trade off for quality already.

Command line hacking away is less permanent and therefore gets a greater benefit from typing speed. But if you need to do something more than once write a script.

Another good example is cut and paste the ultimate in speed. But in the end leaves code hard to maintain.

So give me a lazy programmer that thinks for productivity increases rather then types fast. One that knows the power of the command line and functional programming. I’d rather a young up and coming programmer spend more time learning basic algorithms, patterns and their related trade-offs, a deep understanding of the OS’s API they are working on, and they architecture they find themselves in. If programming productivity was about typing speed we stenographers would be making 6 figure salaries.

Writing code IS like playing piano, so being fast is of the greatest importance, I’d say. We’re also composers; when we’re planning our code, when we do UML, TDD and ERD.

Of course, when we’re actually writing code, we’re still designing it as well, but by than you should have a clear idea of what your code’s supposed to do. A good programmer should be able to speed trough that proces. Of course we lose speed if we run into something new, but the actual writing of experimental code should still be done fast.

Time is money, the faster I can write my code, the more clients I can handle. Man, would I love to be “only” ten times as fast as I am now!

Time is money, maybe epsecially in our proffesion. so if I could work “only” ten times as fast as I can now, I would be mighty rich by now

I’m a programmer and can type quite fast without looking but I have a ‘two and a half fingers per hand’ typing style, I’ve always wanted to properly touch type but think I need to go back, slow down, and start building the speed back up with the correct technique. It’s a resolution for 2011! I think if you want to master a career/area Atwood is right, try and master all of the things involved.

This Jeff Atwood is not a very bright man saying this I suppose.
Wonder if he considered the outcome of his words. Anticipation you should have before publishing.
Can you imagine Moses coming down the mountain with an Apple and a PC and the 10 commandments typed wrong¿?¿?

@S. Tavares

You clearly do not understand efficiency. You don’t get to pick fast vs. quality. You get to pick efficient vs. inefficient. You can both be efficient and good. But there’s plenty of indication that efficient and good go together. Meaning that inefficient but good is as rare as bad but efficient.

If typing speed was a good indicator of programming ability then where would that leave Donald Knuth, since he wrote the entire LaTeX program in pencil before he typed in a single character?

It is all about the content. Bad code can be typed quickly. Good code that is efficient and accurate takes thought. Typing speed is irrelevant.

When I became a programmer in 1961, I was told that I had to learn two skills: keypunching and touch typing. I have well outlived one — could the other be far behind?

This article was written by a true non-Vim user. Your keyboard is the main tool to get your thoughts to the computer. Faster typer is better for any task that requires you to use the computer.

David’s right. It’s not that fast typists don’t do any real programming; it’s just that these people touting “slow typers are bad programmers” are drawing a flawed conclusion from either anecdotal or non-existent evidence, something that should raise a HUGE red flag during the interview process.

You might as well argue that people prone to eye strain are bad programmers, or people who don’t use vim are bad programmers, or people who don’t use ergonomic chairs are bad programmers, or people who don’t use DVORAK keyboards are bad programmers.

Such arguments are a sure sign of flawed logic reinforced by personal arrogance (two things that are BAD for a creative profession), and it’s something I try to weed out when evaluating potential hires.

Another thing that John is doing here is comparing a continuous outcome (relative typing speed) to a binary outcome (being a hunt-and-peck typist). Which isn’t a valid comparison.

I would much rather hire a slow typing coder with good ideas than a fast typing one with bad ones. It’s simple reasoning: it is much more likely that the coder with good ideas will start typing faster given time, than the one with stupid ideas starting to get better ones.

Having seen countless situations where typing speed had considerable impact on what ultimately happened, I can say that the faster you type, the easier the flow of ideas. I have seen many programmers who were constantly frustrated having to work so hard to type and it affected their ability to program. It seems to affect their ability to think. The freedom involved in being able to quickly express yourself in prose or code helps you be creative. Having to work so hard to put something into the computer cannot help but stifle a person in some way, perhaps in several.

However, I do not agree that typing fast or slow has anything to do with meeting a need to type 1000 words per day; that pertains to keeping up a writer’s skills in defining prose content, not in being `creative` or effective. Typing fast only tends to remove barriers to communication and that is a good thing.

I find this article and the resulting conversation extremely interesting because it let me think about my own process in new ways.

As many have already said, obviously there are great programmers with poor typing skills, as well as bad programmers with great typing skills.

I can’t comment on any generalization as to “better typists are better programmers”, but to me it makes sense that better typing skills certainly don’t hurt.

I say this as someone who looks at the keyboard while typing. I am not a hunt-and-peck typist; I tend to use four fingers of both hands, but must watch the keys, looking up to the screen occasionally for a sense check. When writing non-code (like this) I think I type fairly fast, and spend much more time re-wording my thoughts, than correcting typing mistakes. When coding, the time spent typing is insignificant compared to formulating the required code. This is especially true when attempting to solve a new problem, navigating uncharted territory as it were.

The programming I do is mostly 3D graphics, and therefore heavily math based. When working out multi-variable dynamics in 3D space, the challenge is creating the algorithms needed for the desired results; this all happens in my head, getting it out through my fingers becomes trivial. Often times I complete whole sections of code never thinking about the typing, some times I can’t even remember typing it.

But…. With both text typing and generating code, I frequently mistype something, getting keys transposed, or actually offset by a key or character. Yes, I have to go back and fix it. However this costs very little time compared to grammar or spelling errors when typing text, or syntax and math errors when generating code.

I am a horrible speller… I would give up 50 words per minute of typing speed for no spelling mistakes any day.

Does this hurt my coding efficiency? Absolutely!

I try to use descriptive variable names, and often find myself having to correct misspelled variable names deep in my code. I do this much more often than fixing typos.

English is my first and only language, and I suck at it. If someone could point me to a book, or class, or training application that would fix my cross-wired brain, I would be a much better textual writer. BUT… I would never trade better language or typing skills for the visualization and mathematic skills I have, which would absolutely kill my programming ability.

Do I wish I could touch type? Yes, but only because the few typos I make are an annoyance.

Do I feel if I could touch type, I would be a better programmer? No, because typos are a minor annoyance, costing only a minimal amount of time. My typing skills hurt me much more when doing something like writing this post, but only because I’m writing this in MS Word, where my spelling mistakes are highlighted, and easily fixed.

So all in all, for me, my poor language skills have a much bigger impact on my writing and coding than my typing ability.

I have been writing code for 16 years and initially learned to touch type back in middle school. Several years ago, I broke my index finger on my left hand and part of the rehab for that was to practice typing on one of the typing practice websites. I have continued to periodically go back to that site for practice. The best I have ever been able to do is 55-60 WPM, so I doubt that I will be getting any dictation job anytime soon.

I know I have worked with people in the past that can type much faster than that and I admire their ability to do so. But I would take my ability to code over theirs every day of the week and twice on Sunday! Typing code in your language of course is the most challenging typing anyone will ever do. The use of symbols and numbers in every language makes typing code difficult. I can promise you the QWERTY keyboard did not have C++ in mind when it was being laid out.

And with CodeRush (and similar tools), I would say that pure typing skills are not as important as everyone makes it out to be. I would bet that a person that hunts and pecks, but knew all the keyboard shortcuts for CodeRush could rival the fastest typist. I know my limitations on typing speed, so I seek out these types of tools to help me out and it does make a difference. My $.02 worth.

I have use of only one hand for the last 12 years of my life. I have been a developer for roughly 14 years. Last year I went to a job interview for a senior development position and the interviewer was the CTO of a large financial software company. He noticed I used one hand and stated, you only use one hand, can you still type fast or does that hurt your productivity. I told him that as a developer you typically spend only about 15% of your time actually typing code, and that if he ever coded, he would know that. I then answered his question by telling him that I could type faster with 1 hand than he could with 2, which I was 99% certain to be true. I then told him the position wasn’t for me and left.

A few years ago while sitting in the job works center I was typing an article. As often occurred, the person next to me asked a question so I looked over to see what she was referring to during which; I continued to type.

I bring this up because I did this without noticing and would not have given it any though if her son had not been impressed by my apparent talent saying: “Wow! He’s typing without looking at the keyboard”.

When in my zone people tend to tell me that I type fast.

At the local community college, I have gained to some extent, the reputation of being a good programmer. Not that it was all that difficult considering the fact that I was programming long before I took a college class on the subject.

That said; my proficiency at typing has no bearing on my ability as a programmer. I would never attempt to write code while carrying on a conversation with the person sitting next to me. To be a good programmer requires some intense thinking. Intense thinking requires absolute concentration and dedication of thought.

A programmer I know told me that he once worked with a woman that could through out 2000 lines of code in an hour. It would however, take 2 to 4 hours to debug the program and get it running. He said, if she had just slowed down and made fewer typing errors, she would have been an excellent programmer.

The gal knew the language, as well as she could speak English, but, all the bugs in the code meant that it took her just as long as with a slower more methodical programmer.

Speed can be a good thing to have. Over the years however, I have learned that haste makes waste.
While it’s not likely that an individual will get hurt during a programming session, I not only have been injured on the job due to being rushed, so have others. I have also witnessed first hand the lower quality that comes from rushing a job.

Some of the comments posted here are quite irrational as well as illogical. They are akin to the response I got from a resume submission that declared: “there were so many spelling errors in your resume that I couldn’t read it”. Upon reading that statement, I promptly copy and pasted my resume into word which I believe to be a better spelling checker than my self and the tools on the website where I had posted the resume. The so many typos amounted to two misspelled words.
Typo number 1 was a legitimately misspelled word.
Typo number 2 was the purposely misspelled word in a business name.
So that particular individual was not able to read my resume due to a single misspelled word.

Look, I have compulsive perfectionist tendencies, so I’m all for doing things the right way, but if you’re going to deny a person a job because they don’t use all their fingers when they type, or they get there theirs mixed up. You are an evil tyrant pure and simple.

Being a compulsive perfectionist, I can be quite difficult to get along with. Realizing that I’m a compulsive perfectionist means that I do not ever hold people to the same level of perfection that I always fail to achieve despite my efforts to achieve them. Sure, I may blow up and get totally out of line at the first site of a mistake, like those dang pesky semi-colons that keep disappearing. But it doesn’t take me all that long before I realize that I make those same stupid mistakes.

There are mistakes however, that I have absolutely no tolerance for. Those mistakes that are not legitimate mistakes but more rightly fall under the heading of stupid. Claiming that a persons typing speed and style indicates their ability as a programmer is not a mistake. It is just plain stupid.

Far to often over the past six years I have seen so much, just plain stupid, being done by people who claim to be professional when in reality it only boils down to them being dishonest.
Employers expecting programmers to work in a high passed work environment or to multi-task.
A college’s web master/developer certification program requiring a networking concepts class which includes sub-netting a network. Yep, the first person you call when the network goes down is the webmaster. Don’t bother the network administrator, he gets paid to much to bother with such trifle issues as the network going down. Sarcasm intended.

People who expect a programmer to be a speed typist are as unreasonable as an employer that posts a position for a webmaster and expects them to know such languages as C, C++, Assembly, Java, and many other languages that have absolutely nothing to do with developing a web site.

I’m a compulsive perfectionist. I know I’m a compulsive perfectionist, but even I know that there is a limit to peoples abilities and skills. Typing fast has nothing to do with thinking up a program function and implementing it. All typing fast proves is that you have the physical dexterity and agility in your hands and forearms to be able to gain such speed in typing. It does not prove that you are a good programmer.

It is natural for your speed to increase through use. That however, does not mean a programmer is going to be typing 60 wpm. If a programmer is, he or she, is not likely to be writing a bug free program. On the contrary, it is more likely than not going to be riddled with a lot of bugs. Bugs that will take as long if not longer to correct if the programmer had debugged as each part of the program was created.

Nuff said.

As a side comment, I went to a military college (http://www.norwich.edu). Few guys there could type, so I made good beer money typing term papers

A lot of comments left here by readers disagreeing with you (ie claiming that typing speed does matter) are clearly from people who don’t understand how hunt-and-peckers actually type. Here’s a clue: they don’t actually LOOK for each letter as they type. They already have a good idea about where each letter is.

I have never learned to touch-type and I don’t care. I can type code just as fast as my touch-typist colleagues. Again, all you guys saying hunt-and-peckers are bad programmers don’t really know what you are talking about. Look at good hunt-and-peck programmers in the real world – they exist but not many of them do, which is why your views on them are skewed.

Eeeeeew, got a typo and my code won’t work.

We’re getting off topic, so all I’ll say about your solution is that it’s awfully -sequential-. One advantage of working with, for instance, functional programming languages is that you can envision modes other than sequential algorithms.

I don’t expect a programmer to be expert in 2000 different languages. What I expect is that he can demonstrate more than one way to think about -and express- solutions. At the end of the day, programming is about expressing abstract solutions using a limited vocabulary, syntax, etc. See http://en.wikipedia.org/wiki/Sapir–Whorf_hypothesis

For those who are wondering why you would goto 1 when you are certain that y solution will not work.
The infinite loop is caused by being stuck in the mindset that you are going to solve x problem with y solution. The fact that you are realizing it won’t work is irrelevant. Despite the evidence, you try to solve x problem with y solution. The getting up and walking away is what breaks the mindset and allows for new ideas to enter into the thought process.
There has been one advantage to having experienced this a few times, it’s more obvious to me when someone is stuck on using their solution as opposed to just solving the problem. Fortunately, I’m more concerned with solving the problem than holding on to the idea, so once I walk away and clear my head, I usually come up with a real solution.

My feeling is that experience with more than one language is critical in understanding that experience with any specific language is not necessary.

I have to qualify that by saying it is important to know both object oriented programming and a more linear language like Javascript. I say this because of the differences in how they work.

After you’ve learned more than one object oriented language you can easily figure out any object oriented language. But you will struggle quite a bit the first time you attempt Javascript. This was true in my case. I expect the same will be true going in the other direction.

Well since everyone is missing the point so artfully might as well do the same:

My cousin Jake was the best programmer in all existence and he only used his elbows so he made about 10wpm. So now Jeff assertion can’t possibly be true.

Any logical flaws I missed using there?

But I see now were on to the developer bi/tri/etc.. -lingualism. For me it’s just a business decision in the vast majority of cases I can’t afford to hire someone who is unable to code well in only Java. I’ve met and even hired a number of these idiots. People who were TA’s in computer science (in Java) but were hopeless writing code in a language they’ve never seen. So when it came to patching a legacy application they were utterly useless. By the time I made it through university I was required to have written code in a number of languages. If you want to work in any small organization (research, startup, etc..) you will need to be able to do this. I would also stress as others have done the need for knowing how to express problems in more than one paradigm (e.g. OO, functional).

…and while I’m ranting try knowing a thing or two about how computers and networks especially work too.

@Ketura – I agree about preemptive optimization it’s one of the cardinal sins of programming and your graph is essentially illustrating Ahmdal’s Law.

Why not just “speed up your thought process” well how about you define what that is, it’s objective metric and the methodology to increase it’s speed reliably. As far as typing goes all three of those can at least be stated with some confidence (and I’ll reiterate I’m not saying – and from what I see Jeff isn’t saying this either – that there’s necessarily a benefit in improving ones typing speed ).

@sNobody Special
I suggested “speeding up your thought process” just in contrast to speeding up one’s typing skills to improve efficiency. It perhaps would have been more accurate to suggest “improving your engineering process” or “clean up your work flow”.

And as for the graphic, I should hope it illustrates Ahmdal’s Law–I took it from the wikipedia page on that very subject

A programmer / sysadmin / etc. using hunt ‘n’ peck to type is like a construction worker using a tack hammer to frame a house.

@Ketura – the questions remain the same. define what that is, it’s objective metric and the methodology to increase it’s speed reliably.

So the answer to your question “Why spend time optimizing for when we can optimize for “. Is that the question presumes that the cost of all optimizations are equal which is clearly not the case.

In my experience the more poorly defined the term is (e.g. “software engineering process”), the greater complexity in optimization and the longer the ROI and an optimization which I can cost-justify is very often preferred to one I can’t.

Anyway despite that I don’t have a problem with the binary outcome of being a hunt-and-peck typist is a reasonable proxy for lack of proficiency in coding. I don’t believe that increasing your typing speed has any intrinsic merit. So this is more of a purely academic discussion about optimization strategies.

While I do not deny that there is some benefit to being able to type faster, I have come to the conclusion that those who decry “hunt and peck typists” as being unprofessional and bad programmers are in fact themselves unprofessional.

I infer from their obvious embarrassment concerning “hunt and peck typists” that they themselves are quite insecure about their own skill and talent as programmers.

These are as irrational and illogical as those that argue that the solution to unemployment in the United States is the need for an increase in immigration because of the delusional belief that every consumer produces 1.5 jobs, a theory which is proven false by the very existence of unemployment.

Likewise, the argument that only “touch typists” are good programmers is proven to be false by the very existence of good programmers who enter their code using the “hunt and peck” method.

The fact of the matter is, both skills and abilities are distinct and different from one another and, while a good programmer can increase typing speed with minimal effort, it will take quite a bit more effort on the part of a touch typist to become a good programmer.

There is another problem with this adamant position against “hunt and peck” typists. Being that the “hunt and peck” typists are likely to be increasingly in the older workforce, determining an individuals lack of programming skill based on their typing method can be construed as age discrimination. Such a determination can also be construed as defamation of character and or slander.

When hiring a programmer, employers should only be concerned with an individuals programming skill and ability, not their typing method.

@JonO
Yes you would.
Unfortunately, the position of power allows them to go on ego trips and make irrational decisions that are based solely on politics, not on genuine skill.

I was once told by an interviewer that I probably couldn’t do a job because I hadn’t done it in a while. Besides having four years of experience, the job was as complicated as riding a bicycle.

Sometimes I wish I was as quick witted as Robin Williams, because that individual deserved a good slashing. Comically speaking.

I agree that programmers shouldcbeable to type fast, but its not as important as accruacy

@sNobody Special
If I understanbd you correctly, you claim that by giving an applicant a typing test, you can “divine” their “programming skill and ability?” If that is what you mean, then I predict a great future for you – in Human Resources, or maybe Divinity School.

I have known really good touch-typist-programmers and really good two-fingered-programmers. Both types delivered both quality and quantity in equal measure. The claim that touch typists never interrupt their thought flow, by the way, is gainsaid by the amount of time they take back-spacing to correct their errors, since their error rate is usually much higher than someone who spends a fair amount of his time looking at his keyboard as well as at the screen.

@sNobody Special

I am relieved to be told that I still don’t “get” nonsense.

Of course evaluating programmers isn’t easy, but if you have been placed in a position of doing so, and you admit that you are not capable of it and instead use a metric like typing ability then I hope you make your inability clear to both those you evaluate and those for whom you are doing the evaluations.

I do not, by the way, make any claim that my experience is universal. You are the one who have made the statements that all good programmers are touch typists and all two-finger programmers are not. I offer my experience simply as incontrovertible proof that you have no idea what you are talking about.

Enough, I am done wasting my time trying to get you to admit that the world is nearly as simplistic as you want/need it to be. Take the last word if it is important to you. I am unsubscribing to this topic.

Oh and “evaluating programmers” isn’t necessarily the same as being able to determine PSA. Every person in the hiring process “evaluates” a programmer. Even if I ranked developers by typing speed alone – which I’ll restate yet again for other people as brain-damaged as JonO – that I don’t do nor do I believe anyone really does – it would still be evaluating them. What it wouldn’t necessarily be doing is providing a very good assessment of PSA or job success (which in some cases may be different things).

Nobody’s claiming that typing speed is a measure of programming ability in anywhere near the same manner that micromanagement is a measure of a player’s StarCraft skills.

@Mark – I think one of my comments got eaten. Anyway if PSA can be measured directly then you should be able to give me a precise definition and an reasonably unambiguous way to measure it within some standard error. I very much doubt that you can. “Looking for creative people” isn’t unambiguous in fact it’s at least as bad as saying you’re measuring PSA – probably worse.

In order for something to “in no way reflect” – in any usefully objective sense of the term. You would need a large random sample of developers. Some kind of metric as to their comparative quality (whatever that means) and their typing speed. You can then calculate the R. You don’t have that right? Hence you can’t really support that statement except anecdotally.

You’re also making a pretty bad logical blunder. I never, ever said learning to type faster improves ones programing. The fact that so many people here don’t seem to get that means either they don’t understand what a binary outcome is or don’t understand the limitations of doing a regression analysis on data.

As and aside I find it interesting that you’re pair programming and calling it “that’s how professionals work”. Given that it’s very much a minority practice in development shops and the last meta-analysis didn’t see much overall improvement in employing it.

I haven’t seen much in the way of compelling research on CMMI and while I think the goals are admirable and I have looked through the one and only one study “published” (but not peer reviewed) by CMU. From a statistical point of view the research is poor but it’s poor research in a environment (IT) where the research is F**king awful. So I suppose that’s something.

i thought the answer to this one is fairly obvious: there may be a correlation between typing speed and productivity but it’s certainly just a correlation and not a cause.

thought experiment: one of your “grandmaster” developers who is one or two orders of magnitude more productive than your other programmers and who types ~100WPM sustains some sort of injury leaving her unable to type faster than 10WPM. are you now going to replace her with someone that types 50 WPM but was an order of magnitude less productive? are abstract thought, ability to design for maintainability, debuggability, flexibility, etc. going to suddenly hit a brick wall because she types slower? not a chance.

besides, how many of you actually spend more than 5-20% of your time on a project actually typing in code? you do? if so, then in most cases i would suspect that you have not spent nearly enough time either looking into productivity-enhancing tools (say, code completion, macros, code generation, a more appropriate language for your domain, etc.) and methodologies (agile design and automated testing come to mind) that will shift that into time more productively spent than hammering on the keyboard.

or look at it this way: take a piece of software approximately 1,000,000 phyiscal lines of code, with an average of 50 characters per line.

1,000,000 lines * 50 characters/line = 50,000,000 characters
50,000,000 characters / (5 characters/”word”) = 10,000,000 “words” (as in WPM)
10,000,000 “words” / (50 WPM) = 200,000 minutes
200,000 minutes / (60 minutes/hr) = ~3333 hours

so, to *type* a million lines of code takes approximately one and two-thirds man-years at 50 WPM. one estimate i found for how much time is spent on a project of this magnitude (http://www.eetimes.com/discussion/break-point/4026827/A-Million-Lines-of-Code) was 67 people for 40 months. unfortunately it did not break that down but hey let’s go crazy and say that only 10 of them are developers.

let’s say of the ~333 hours of actual typing for each developer has to be doubled to account for throwaway prototyping, testing, and user documentation. that gives us ~667 hours of actual typing per developer over 40 months, or ~3.33 years.. which, nicely works out to approximately 200 hours per year of typing necessary per developer. obviously as an order of magnitude estimate.

so, with my assumptiom of ~2000 hours per developer per year (and most of the passionate developers i know would spend a lot more than that) we’re talking 10% of developer time spent typing on this hypothetical million line project with 10 developers that type 50 WPM. if they only type 25 WPM, they will still only spend about 400 hours, or 20% of their time typing, or at the crawling rate of 10 WPM about 50%. oh, and none of this factors in the tools like code completion, code generation, macros etc.

now, assuming the numbers here are close (i think they are quite conservative, personally), and given the advantages heretofore mentioned of the “grandmaster” developer which would you rather have: a “grandmaster” typing 10 WPM or someone one or two orders of less productive at 100WPM?

oh, and keep in mind the “grandmaster” will get more done in fewer lines and the code she writes will be more maintainable, debuggable, and flexible than the 100 WPM speedster.

just askin’.

(and yes i have a shift key but i forget what it’s used for. unless something needs CamelCasing. )