I’ve found that many of the things Jeff Atwood posts about, most of us think about. The difference is that some are so blatantly obvious that you would never even consider blogging about it. But each to his own.
However, there are some things that just blow my mind. His latest post about programmers are typists first is one of them. Let me first say that I’m a firm advocate of annihilating the mouse from a developer’s toolbox. Ok, that might be a little extreme, but point being, you are more productive if you learn keyboard shortcuts and don’t have to reach out so much for the mouse. However, I wouldn’t say that developers are cats first, then programmers.
Initially one could understand Jeff’s title as expressing that being a fast typist is important. If that were the statement, to a certain degree I would concur, and I say to a certain point because at least on my team, we don’t measure productivity in terms of keys pressed per minute.
So Jeff comments:
We are typists first, and programmers second. It’s very difficult for me to take another programmer seriously when I see them using the hunt and peck typing techniques. Like Steve, I’ve seen this far too often.
Well let’s think about that for a moment. If you’re not a professional typist or never taken courses, the only way to improve is through practice. As a developer, the more you write code, the more you practice your typing skills. People also tend to say that you really can’t be a pen and pencil architect unless you’ve got your hands dirty with code, and that I do believe. So to a certain point, the previous statement makes sense, but I don’t think it’s black and white thing.
He continues to say:
Steve and I believe there is nothing more fundamental in programming than the ability to efficiently express yourself through typing. Note that I said "efficiently" not "perfectly". This is about reasonable competency at a core programming discipline.
What has the rate of keys per minute (KPM) got to do with efficient expressiveness of code?Efficiency can be an indication of how expressive or clear your code is, or how fast it executes where speed matters, not how fast you type it into a text file. I would say efficiency is more about coding if statements correctly or using LINQ where it makes sense.
This next comment blows my mind:
What I’m trying to say is this: speed matters. When you’re a fast, efficient typist, you spend less time between thinking that thought and expressing it in code. Which means, if you’re me at least, that you might actually get some of your ideas committed to screen before you completely lose your train of thought. Again.
I really don’t have much to say about this other than it’s utter nonsense. In fact he tries to justify it somewhat in the next paragraph:
Yes, you should think about what you’re doing, obviously. Don’t just type random gibberish as fast as you can on the screen, unless you’re a Perl programmer. But all other things being equal — and they never are — the touch typist will have an advantage.
Advantage over what? Over thinking faster? Over beating the next guy on the team on expressing his thoughts?
I’m also a self-taught typist, and I’ve learnt through practice, spending years writing code. My wife is a great typist also. She didn’t take courses either, she’s worked with computers for many years. She suck at programming, but she’s great at Office. Get the point? You become a good typist by practicing and using a computer. The more you use it, the better you become. You don’t need to take a course on typing before learning how to program.