I'm a pretty fast typist (80-100WPM on TypeRacer, usually) and I really never put much thought into my typing, since it was good enough. But I recently started paying attention to the kinds of mistake I make on Typeracer, and realized that I have certain combinations of keys which I don't make using the "home row" of the keyboard, but rather, move my hands to make. Every time I hit one of these, I have a 50/50 chance of not getting back to the home row correctly, meaning I have a 50/50 chance of throwing off my typing.

And I am a heavy VIM user, by the way, which means I am very used to doing everything from the home row, including every navigation you can think of. I even have AutoHotKey scripts to give me vim-style navigation everywhere in windows, so I never have to move my hands.

Now with this program, I finished running an example and noticed 2 shocking things:

1. There are a lot of keys which I'm not used to typing from the homerow, which happen to show up a lot in regular Python code. For example, periods (.). And underscores. I was used to shifting my hand to type these characters. I don't notice this during every day work, since I'm actually programming, but I did notice this while playing a program specifically designed for typing.

2. At the end of the program, it gives you statistics, and I found out that I was only about 48% effective, meaning 52% of the keystrokes I made were accidents that had to be backspaced out. This is a lot. Part of it is "first time with this program" bias, but it still means I have a long way to go.

Anyway, I recommend running through this program, it will probably teach you a lot.

P.S. Just one bit of constructive criticism: the way the program presents mis-types is a little annoying, and hard to follow. I recommend doing the same as TypeRacer, that is, have the "mistaken" keystrokes be visible somewhere, so the typist is very clear on how many keys he needs to backspace out. This is much closer to how people type in the real world.

I'll tell you how I'd like to use it. This may seem odd, but I'd like to be able to upload code that I'm interested in learning, and then type over it just like in these lessons - but not to speed up my typing, but rather for learning.

Writing is a unique channel for learning new things. (Reading is too, of course, but everyone knows that.) Even if you're merely reproducing keystroke-for-keystroke what someone else wrote, following in someone's footsteps helps the brain absorb new patterns and is particularly good for something one's a beginner at. If what you're copying is the work of a master, then you're absorbing really good patterns. I would totally use a tool like this for that purpose. It's a way of learning with one's hands.

But pure typing efficiency? That's hardly a way to become a better programmer, only a more prolific one, and more code is not what we need in this business.

So basically I wish I could subvert the purpose of your tool and send it off in a new direction. :)

Things I particularly liked: not making me type the indentation (because any sane editor will do that for me), allowing backspace, providing examples in numerous languages.

Things that bugged me (and which only become an issue because the example otherwise proves sufficiently realistic that any remaining differences feel awkward, like an uncanny valley for typing code): showing faded-out code I'm not expected to type and skipping it, not allowing any navigation other than backspace (I frequently "correct" errors by ignoring them until I finish typing what I wanted to type and then going back and correcting them, which means the "collaterally typed before backspacing" characters are not wasted keystrokes), not allowing copy-paste (particularly important for lines like #include or import), not showing incorrect characters I've typed.

Things you probably can't do anything about: typing a file in a more natural order than top-to-bottom (the Haskell exercise starts with a giant export list, and the Python exercise starts with an import list). Normally, you'll extend those as you go, rather than typing them all at once.

I personally would prefer a side-by-side text entry, rather than typing on top of existing code, so it's easy to see progress and mistakes (even if you don't highlight mistakes in the text).

EDIT: It looks like about 50 words per minute, maybe 55, is the max speed you can type and have the cursor actually be visible enough to be a guide of where you are in the text.

Regarding indentation: I think you made a reasonable choice in excluding it across the board. Definitely better than requiring it to be typed everywhere. That said, ideally you would require the user to make the keystrokes to un-indent whenever an IDE wouldn't automatically.

Also: Something in Objective-C please. Those square brackets took me a lot of practice to get used to.

This is all bringing back horrible memories of our disastrous demo actually, but very nice otherwise.

Here's a straight-up bug: I had to turn off a Chrome extension (Type Ahead Find) that I use for incremental search. It was intercepting key strokes that were supposed to go to typing.io. That hasn't happened with Ace and other canvas-based text editors. My friend also mentioned that it didn't work with his Danish keyboard.

Beyond these annoyances with the implementation, typing the C code from Redis reinforced how difficult (and frankly infuriating) it is to spontaneously conform to an unfamiliar coding convention. E.g. no spaces in "while(1)" throws me off completely because my brain is thinking "while 1" and my fingers translate that into my customary "while (1)". If you want this web app to be relevant to real-world programming, you need to let people upload their own code samples.

For even punctuation heavy, syntactically gnarly prose, I can average 140+ WPM without much effort. Typing.io put me at around 100 WPM for the first few sections of the C Redis lesson. I'd say I'm good for at least another 15-20 WPM if the environment wasn't so utterly alien.

My german keyboard didn't work :(

What do you mean "access"? Do you mean "authenticate as"? Do you mean "go screw with my email"? I seem to remember that I sometimes see specific access requested, but this one is vague. Possibly this is the result of requesting sign in with no permissions at all.

It is interesting. I wonder if I can learn to make fewer typos.

But keeping my fingers on the home keys to type has always felt really awkward to me. I tend to position my hands differently depending on the word I'm about to type - in a way that let's me "roll" my fingers along in just the right sequence so it tends to be a series of short bursts where it would seem as if I'm actually just smashing a bunch of keys at once over and over again.

Edit: I just tried type racer and was getting 80+ wpm. /me wonders how people get 140+. :O

I was considering doing something like this in the terminal, possibly using an adaptation of gtypist. However, I the more I thought about it, I realized that I would be better off writing a module for my everyday text editor, since I would have access to completion, copy/paste, indention, macros, etc.

I don't want to 'talk down' all the work you did with this. I'm really glad you made it and I am going to use it, for sure.

Keep up the great work!

I think a great place for this to go would be if the code bounced around a bit more. Perhaps, start with what seems like the most commonly used function and write that function header and whole function; then, start writing all of the different subordinate methods you called in this primary method, and so on until the whole class is created. The way it's written write now, in particular for Java, isn't a way that I code and I imagine it's not the way that many people code.

Just my two cents. Otherwise, it's an interesting system so far.

And besides improving your code-typing speed, it's also a nice way to get a hang of all different languages you might want to delve into. Alternatively, you can also polish your muscle memory on all the thousands of function, classes and method names you can find in your typical language/framework of choice.

I cannot fathom how people can find the time to actually approach any particular problem at a reasonable depth if it will take them more time to type out the solution than reading and understanding the existing code and determining how to solve the problem. Sure there's code where there's boilerplate, or add a line to a bunch of files, or tons of ways that raw typing speed doesn't play much of a benefit, but when it comes time to type, having to move your hands and look to find the { is akin to a carpenter having to read every label to find the bottle of glue.

I need to improve my typing speed and reduce the interruption as much as possible.

The blog post[1] Steve Yegge was the one that triggered me to consider touch typing seriously.

1. http://steve-yegge.blogspot.in/2008/09/programmings-dirtiest...

Previously I've thought a lot about architecture, code, algorithms, etc. And then typed that in ~1 hour per day. However when I started doing real TDD with running tests every few dozen seconds, everything changed. Now I actualy code almost all the day - play with ideas, throw them away, implement in a multiple ways, refactor a lot. And that is a blessing when you may implement your ideas as fast as you may, so that instead of analyzing the solution, you verify it.

Other reason is I've changed my approach to application architecture. Previously I've used the standard PHP/Ruby/JS frameworks and fit my code into predefined places, generated scaffolds, etc. However then I started applying DDD, PoEAA and similar ideas. All the advanced design principles require a lot of boilerplate code - a lot of mappers, DTO transformers, domain classes, view models, etc. So I actually need to type ~3 times more code than before.

And then I've started using VIM. You better not make typos when using VIM - crazy staff happens and it breaks the flow.

I wrote a typing tutor a while ago and this is a somewhat common pitfall, to manually handle characters by pulling key codes. Instead you should let the O/S tell you which character was typed (and also check key codes, for things like backspace) which then handles different layouts / locales etc.

Edit: Ok, it works in Chrome - so it's not working for me in Firefox 14.0.1 on OS X Lion.

Now that I can use it, I love it, but I have one request - I'd like to be able to go back and see my stats, please!

KeyboardJS has a basic locales mapping: https://github.com/RobertWHurst/KeyboardJS , Unfortunately it appears to only have en_US at the momment though

This on Firefox 14, Chromium 18, Opera 12, for Linux Mint.

Otherwise, this is great!

EDIT: Does it read the key-code, instead of the character? Is it not possible to listen for the character input?

It occurs both in Chrome and Firefox.

It wasn't even enough to press the corresponding button where semicolon is placed on English layout, I had to actually switch keyboard-layout and then press the correct button to get past it.