How important is it to be able to type quickly? Jeff Atwood has said numerous times that programmer must be a good typist. For example, a few weeks ago he said
I can’t take slow typists seriously as programmers. When was the last time you saw a hunt-and-peck pianist?
But programming is not like playing piano. Programming is more like composing music than performing music. Most composers can play piano well, but some cannot.
What if you write prose rather than programs? In his book On Writing, Stephen King recommends writing 1000 words per day. If writing were only a matter of typing, how long would that take? Half an hour at a modest rate of 30 words per minute. Say you have to type 2000 words to keep 1000 due to corrections. Now we’re up to an hour. People who write for a living do not literally spend most of their time writing. They spend most of their time thinking.
Clearly it’s good to be able to type quickly. As I’ve argued here, the primary benefit of quick typing is not the time saved in data entry per se, it’s the increased chance that your hands can keep up with your brain.
However, a slow typist can still be productive. Consider physicist Stephen Hawking. He is only able to communicate to the world via a computer, ALS having destroyed nearly all of his motor control. For years he controlled his computer via a switch he could toggle with his hand; he now uses a camera that detects blinks. He says he can type 15 words per minute. Still, he has managed to write a few things, 194 publications from 1965 to 2008.
Learning to type well is a good investment for those who are physically able to do so, but it’s not that important. Once you reach moderate proficiency, improving your speed will not improve your productivity much. If a novelist writing 1000 words per day were able to type infinitely fast, he or she could save maybe an hour per day.
You may not be able to increase your typing speed too much no matter how hard you try. According to Guinness Book of World Records, Barbara Blackburn was the world’s fastest English language typist. She could sustain 150 words per minute. That means she was only 10x faster than Stephen Hawking. Most of us are somewhere between Stephen Hawking and Barbara Blackburn. In other words, nearly everyone types at the same speed, within an order of magnitude.
Regarding Jeff Atwood’s assessment typing and programming, I imagine good programmers are often good typists. Typing well may be an indication that a programmer cares about his profession, but if so, he’s a good programmer because he cares, not because he can type well.
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.
John, I agree with your comment. I interacted with a lot of bad programmers, almost universally they could not touch type. My thought on the correlation was, they did not care about the execution of their craft, because if they did, touch-typing would greatly increase their effectiveness.
As a programmer, you don’t need to take dictation at 90wpm. If your error rate is very high, and your typing rate is very low, you will spend a lot more time just keying in your thoughts than you would otherwise. Not learning how to touch type shows that you don’t care about that lost time, which probably indicates you don’t care about your overall ability to get things done.
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 used to type close to 60 words per hour. I realized, in programming it doesn’t matter how fast you press keys, it’s matter of what keys you are pressing in what order. I slowed little bit but increased my accuracy considerably.
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.
Depends on your “speed of thought”. I learned touch-typing on a manual typewriter long ago and can still type 80-100 wpm, sometimes faster. Sometimes I still can’t keep up with my speed of thought. But I’m certainly glad I can touch-type because I don’t actually think about the typing part but about the content as I am typing. For a language I know well, this helps me immensely. YMMV.
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.
It’s not about speed, it’s about accuracy. For example, how much effort (lines of code) does it take to write a simple quicksort in C? Let’s say x. If we were to write the same quicksort in Haskell, that would result in code 2x or 3x shorter. The idea stays the same no matter if you are a quick typer in the C world, or a slow typer in the Haskell world. Even if you are a fast typer typing Haskell, that doesn’t change your status to a better programmer, it’s just one of the many skills that would be nice to see in your toolbox, but are not essential.
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.
Typing ability does matter. Just try programming using a Dvorak keyboard. Even a split keyboard is enough to trip me up. Really, even an oddly placed ctrl key is often enough. It’s the distraction.
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.
Touchtyping isn’t about typing speed primarily. It’s about the ability to type without having to avert your gaze from what you’re typing.
Everytime you switch your gaze from the logic you’re looking at (the code) to something else, you’re interrupting your train of thought.
There’s also the issue of efficient editors (like vim or emacs) that require you to type a bunch of commands. Typing them in a pecktyping style takes forever, but a touchtypist can issue them in such rapid succession that to the followers of lesser IDEs the activity of a vimonaut or emacsoneer look more like magic editing then something that was humanely doable.
Another issue with slow typing is if you need to write something else then code, like say, an email, documentation, hack down some dumb html or hand enter some data. Say you spend each day pecktyping 10 emails your emails for 2 hours and then you spend another 3 hours pecktyping documentation. Wouldn’t you rather use the majority of your day thinking and coding instead of wasting it needlessly serializing letters slowly?
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.
There’s also the matter of comments. Writing those is tedious enough even if you’re fast typist, slow one may be tempted to skip some.
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.
You think while you type ? Really ? And that is good programming ?
I don’t type while I think, I’ve already though before hand (pun intended).
Come on guys, a program doesn’t automagically design itself while you type, does it ?
Typing is just executing. Fast is nice but mildly relevant to actual programming skill.
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.
I think that fast typing is a side effect of doing a lot of programming. If you do a lot of programming, you will be doing a lot of typing, and your fingers should learn how to do their thing with minimal brain interaction.
I cut my teeth in the 1980s doing IBM 370 mainframe assembler programming. The IBM programming conventions are extremely heavy on comments. Generally assembler written by IBMers is massively overcommented — for a reason. It is very important that someone completely unfamiliar with your code be able to open up your program and immediately understand it well enough to make bug fixes and enhancements. This meant that every single line of code generally had a comment, and every page or two, there would be a full paragraph of comment-only text describing what was (supposed to be) happening. Once you get used to doing enormous amounts of typing, you learn to think what you want to say, and your fingers just magically make the movements. At my peak, I was typing 100WPM and essentially writing nearly bug-free code at that speed. Most of it was comments, but that was the nature of the style. And it’s a lot easier to find bugs when you’ve also written a paragraph describing what you intended to do, along with the block of code that attempts to do what you’ve described.
So if you are a fast typist, it probably means that you do a lot of typing. If you’re a good programmer, it probably means that you do a lot of programming. If you’re a slow typist, you’re probably not programming enough to get really good.
http://en.wikipedia.org/wiki/Amdahl%27s_law would seem to be relevant to this conversation.
I tried using Mavis Beacon and other touch-typing-training software when I was a teenager, but I never reliably got above 20 WPM or so. Now I work as a software developer. I doubt I type any faster than that even today, but most of the typing I do (code, documentation, correspondence, anything) is short bursts punctuated by thought, revision and research anyway.
A little off-topic, but I probably only type about 3 WPM in Arabic … then again Arabic isn’t my native language, I personally have never been fully fluent, and I’m a bit rusty since the last time I studied it formally.
Another thing you need to type well, of course, is a good keyboard, good posture, good air and good light. When I’m thinking of buying a laptop, I always try the keyboard, seeing how I can type code and text. I found a Compaq Armada m700 at a flea market once and have owned a few since, because I really like the keyboard (the 3-button mouse was a plus, as well). My work-computer these days is a Lenovo ThinkPad, which also has a durable and nicely responsive keyboard.
There’s limited potential for typing faster. It’s unlikely anyone could improve their typing speed by 10x. It’s more likely someone could learn to get 10x as much work done per keystroke by learning their software well, writing macros, scripting common tasks, etc.
I would not hire someone who tells me that touch typing ability is an indication of how seriously someone takes their profession. Such a comment tells me they are far too superficial to spot real talent.
I need employees who not only are able to do the job, but are also able motivate others towards excellence, something the judgmental type is unable to do.
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.
Crappy programmer here, if words per minute is the measure. When I type in prose, I prefer to use Dragon – so that I can keep up with my train of thought by speaking, rather than typing. If I’m typing code, I’m in NetBeans. If you can type “com.” faster than I can, then you’re a faster typist, but who cares? If you prefer your own typing speed to using the IDE’s knowledge of the underlying API, I would hazard to say that you have more typos (and compiler errors) than I do, and are therefor less productive. The only programmer I have known in the course of my 25+ years of programming that shared this typing speed belief didn’t understand the design choice between inheritance and composition, and probably preferred his own typing skills versus reuse. I suspect he had some idiotic notions concerning lines of code as well. I prefer less lines of code. And I demand an elegant solution. So it really doesn’t matter to me how fast I can type. My $0.02.
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
I’ve been writing code for nearly twenty years even though my left arm was amputated when I was just a teenager. Often tell people that I get paid for what I know not what I do.
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.
@Frank
I regularly think while I type, and I average between 500-2000 lines of code if I know exactly where to go.
And I’m not pulling this out of my hat. If I emulate pecktyping I feel horrible, I can’t keep my train of thought for the code and I’m slow as hell, also vim becomes inoperable for me in a pecktyping fashion.
There’s a thing I noticed about non touchtyping programmers:
1) They’re afraid to write documentation (not that I’m a fan, but I do it fairly quickly and well)
2) They use horrible variable names instead of nice descriptive ones.
3) Often instead of just bashing the logic down in the most straightforward manner, they go to extraordinary lengths to compose code of multiple layers of indirection and obscurity just so they don’t need to type another 20 lines of stuff
4) They’re usually afraid to to throw code away since the act of rewriting horrifies them
So yes, if you do not touchtype, you’re a worse programmer.
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.
You’re missing the point. Being able to touch-type shows that you’ve put in the effort to rise beyond hunt-and-peck. For a computing professional, any computing professional, this is pretty much required. Nothing says “illiterate boob” like an IT professional who’s clearly having trouble finding the keys without looking. That includes middle managers and brass. If they’re too cheap to hire a full-time touch-typing secretary, then they’d better be able to touch-type themselves. And not need a spell-checker to help them find the words either. I expect professionals to know their business.
Stephen Hawking is an outlier and so far out it’s not funny: It takes him hours to do the daily chores of getting up and going to bed, leaving him plenty of time to think. And that’s all he does. Most of us don’t have that luxury.
Personally I found that my typing speed actually increased when I started to write prose instead of code. The duty cycle of writing code is fairly low. Most self-taught touch-typing programmers aren’t that fast –some 60wpm or so, I can do 70 on a good day but I’m fully aware I’m only average for a touch-typist having known a guy born with a hand missing who does 85wpm regardless– and yes, 60wpm is quite enough but a far cry from hunt-and-peck.
Still and all, touch-typing is only the beginning. First you learn to read and write, then you learn spelling and grammar. Once you’ve mastered that you can start to say something comprehensible and perhaps someday you’ll be able to sway the masses with your prose… or your code. But if you don’t have the basics down, I’m not going to put effort into picking apart ramblings that might, possibly, contain a pearl or a gem or two. In fact, if you as much as mix up “there” and “their” often enough, or can’t be arsed to use “its” and “it’s” correctly, I’m going to drop the work and move on. There’s simply too many better things to do.
If you’re going to write then you need to pour every cluon, every brain-cycle, every tought into improving your writing. You can’t afford to let yourself be held back by having to think about where the keys are. This is the same when writing by hand: You write down the words without having to think how to spell each word, nevermind thinking about drawing each individual letter.
The original point was that hunt-and-peck is below the mark for basic proficiency expected of a programmer. And yes, yes it is. If you need to look at your keyboard when you should be looking at your screen, then you have some homework left to catch up on.
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
Seems nobody of the speed-typers does any real programming. True, you can write simple business logic faster. But if any real algorithmics comes into play, thinking will take 10x…100x or more the time that typing it in will take. This means typing speed is essentially a non-factor. However those that think it is a factor, very likely do not even understand real algorithmics. If you never do anything complicated, you do of course not know that it takes time.
Basically the belief that fast typing speed matters in programming is a strong indicator of weak programming skills, as these people have not understand large part of the skill-set at all. Don’t get me wrong, there is a large need for people typing in boring and simple business logic fast, but these are at the lowest end of the competency scale and will likely remain there. For them to judge the programming field as a whole is just arrogance.
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.
Being a faster typist does not make you a better programmer. There are just as many bad but fast programmers as there are slower but talented coders. For that lack of speed I’ll take quality.
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¿?¿?
Typing speed is almost as important as being a good coffee drinker. It has very little to do with your ability or even your output as programmers. I use IntelliJ and Eclipse to input most of my code, and the IDE guesses what I want about 60% of the time. Learning the shortcuts and the macros a good IDE has will make you far more productive and typing speed. Of course, you do need to be at least someone efficient at typing, but if I am hiring someone I would take the average typist who is smart over a fast typist that gives me crappy code. Also, good programmers are lazy by nature. The best code is often solves problems with the least amount of of lines. Less code means less chances for bugs.
@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.
I don’t think to be a good/great programmer you need to be a speed touch typist, but I know MY need to look back at the keyboard causes me problems. I can’t count the number of times I have ended up with typos and errors because of my not being able to look at the screen at the same time I am typing.
Also it is more of a problem if I am doing my thinking at the same time I am programming. Sometimes I think an then code, sometimes I think and code at the same time. Of course anyone who reads my code would think at some points I just code and don’t think at all, but that is a whole other discussion.
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?
Most of the “programmers” out there couldn’t code their way out of a wet paper bag, no matter HOW fast they can type.
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.
As with almost very argument pertaining to programming, your perspective depends very much on where you’re coming from (pun intended). For example, I’ve read countless arguments on the pros and cons of various languages, but the truth is that opinions on either side are equally valid. The problem is that very few arguments are presented within a clearly defined context.
I believe the same is true of typing speed. Some languages are inherently more verbose than others – I know it can take me hundreds of lines to express something in one language that only takes a few lines in another. Using my preferred language, I type very little. And in my particular field, I would argue that it is more important to be able to draw than to touch type. The ability to listen, imagine, and contemplate is also vital.
For me, touch-typing would make almost no difference to my workflow. But I can easily imagine other programming roles where the difference would be substantial. Without defining a clear context, this debate is unlikely to be constructive.
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?
I’m a terrible typist but a great programmer. I once thought that improving my typing would improve my programming so I took a typing course. I upped my WPM and accuracy but it made no difference to my programming! Copy typing is about learning to use the QWERTY keyboard to create spoken/written text as efficiently and accurately as possible.
For me, programming uses very different finger skills. It’s all about symbols, numbers and key-combination shortcuts. The QWERTY keyboard wasn’t designed to help with that. I’ve worn out several keyboards because the left-hand SHIFT, CTRL and ALT keys wore out!
I recently started to make the switch from Windows- to Mac-based development. Due to the different keyboard layout and seemingly torturous shortcuts my typing rate has slowed. Hasn’t stopped me from creating some kick-ass problem-solving
software though ;)
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.
I’m a graduate student in computer science and minored in music in undergrad, so I have experience with coding, writing papers, and composing. While I know several good composers who aren’t virtuoso pianists, they all play and can sight-read passably well — they make fun of their ability, but they have to be at least good to be able to compose music and know what it sounds like. The same thing applies to coding: you have to be able to try things and see what the most simple or efficient or effective way to approach a task is, and you’ll never get that if you just work on paper. Granted, it’s useful to take time off from your keyboard (whether PC or piano) to think and not be at it round the clock, but you absolutely can’t come up with something offline and key it in and have it work. It’s no coincidence that the most popular languages have been interpreted, not compiled, that the REPL from Lisp has been popular for decades in newer environments, that web APIs encourage experimentation, and so forth.
Writing papers is an entirely different skill from writing code. On my most recent project I needed to write a lot of code and try several things before I found something that would work. Once I found it, though, the paper has been taking weeks to write concisely.
piet: I believe Jeff Atwood is indeed bright. He’s had a lot of insightful things to say, piano comment notwithstanding.
Seems nobody of the speed-typers does any real programming.
That’s total bovine effluent. Next time you fly through Canadian airspace, including going to either Europe or north Asia, consider that the air traffic controllers are looking at code I wrote.
People who mistake ‘concise notation’ for maintainable software should be forced to maintain real systems.
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.