If you had an inclination towards PDAs in the late 90's or early 2000's, you most likely hold both memories and opinions about the (now mostly forgotten) input system found on Palm OS devices, namely Graffiti, which was most likely inspired by the Unistrokes system, developed at Xerox PARC in 1993, by David Goldberg.
If you don't have any connection to this era, or simply did not care much for pocketable computers back then, the Graffiti system can probably best be described as a way of entering text by drawing simplified glyphs on a touch-sensitive surface or display using a pen.
Most likely because it required you to actually learn something new (the specific alphabet of glyphs) some hated the very idea with a passion. Others, myself included, found it to be an elegant, precise and convenient way to interact with computers.
Even though Graffiti had it's flaws, it's definitely my all time favorite way to interact with mobile and handheld compute devices. Some of the reasons I prefer it over anything else include:
The Precision Any other type of pen or handwriting-based systems were, and still are, a sloppy affair. Such systems will usually have you write whole words or even sentences, and then perform some brand of half-baked OCR on that, which never works well, because let's face it, nobody (except that girl you sat next to in grade schooi) can handwrite in a legible manner.
Since these systems procces text in larger chunks, you are, more often than not, left with many random errors scattered in the resulting output, making it useless for purposes such as programming, or interacting with a terminal. Systems based on the Unistrokes concept doesn't suffer from this problem, and can be used to accurately operate any kind of computer system.
The Zen If there is one thing that makes me want to eject a mobile device into a heliocentric orbit, it would be staring at my own two thumbs, as they unwillingly peck and hunt for undersized simulacrae of keys, on a miniature make-believe QWERTY, my gaze forever divorced from what should be the actual subject of my attention. It is physically impossible to touch-type on a touch-screen. Oh, the irony. Systems like Graffiti and Unistrokes let you input text blindly, while keeping your focus on your work.
The Speed & Comfort While it will never be as fast as touch-typing on my split Corne with a customised Halmak layout, the entry speed is comfortable even for doing actual work and longer writing sessions.
Since you can just write strokes straight on top of each other, you don't have to move your hand around while typing, making it a very comfortable input method.
The Versatility A system based on the Unistrokes concept can provide almost any conceivable sequence of inputs to the operating system, including the use of modifier keys such as control, alt and shift. This makes it possible to easily use the keyboard shortcuts already in place in most program.
Macros and multi-character sequences can also be triggered from simple strokes, which is very useful indeed.
The Configurability The ability to modify the stroke-to-input maps for a system like this is an incredibly useful feature. It makes it possible to fine-tune the stroke recognition for a near-perfect matching rate, and to tailor the system exactly to your own style of working, and the tasks you need to solve.
A system that can map any keycode and even arbitrary unicode sequences to simple strokes and gestures is a very powerful tool.
But hang on, wait a second! If you've actually used Graffiti, you'll know something is wrong here. Some of those features I talk about above would have been amazing to have, but were not actually part of Graffiti.
Ok, I'll admit that I got a bit carried away, and started describing my own ideal version of such a system, instead of what actually was back then.
The good thing, though, is that instead of just talking about it, I've actually made it real.
As a proof of the pudding, this entire post is written with Penboard, an Android input method I created to combine the best things from Palm's Graffiti with the features I always felt were missing.
While I wrote it primarily for my own use on pen-based e-ink tablets and devices, it will work on any Android device as long as it provides some way to draw glyphs on the input surface.
I wrote a custom recognition engine for Penboard, based on a slightly modified version of the $1 Recognizer, tuned for rotational variance of the drawn glyphs, and with the ability to use multiple variants of the same symbol for increased accuracy.
There's no "AI", machine learning of indeterministic fuzzy buzzwords here. Just a high-quality, fast and deterministic recognition engine based on sound and efficient math and geometry.
The engine is quite fast too, with each stroke usually taking from 5 to 20 milliseconds to process, even with a large map of 75+ strokes, on my relatively underpowered e-ink tablet. So you can write as fast as you want. I've also created a comprehensive character map that includes mappings for almost all keys on a full keyboard, including modifier keys.
So far it's working really well, and - on a mobile device - I think it's a huge improvement to use over any type of virtual keyboard or traditional handwriting recognition.
If you like this sort of thing, you're welcome to try out an extremely early version. Don't expect any frills, or even helpful guides currently. The settings are currently non-functional, and you can't actually modify the character maps without editing the JSON map inside the app. The recognizer and input system works nicely, but that's about it.
Here's the pre-release Penboark APK file if you want to try it out.
The internal map display is also not functional yet, but if you're used to Graffiti, you will already know how to write almost everything, as my map closely mimicks the original Graffiti map. I modified some glyphs to suit my own taste though, so you probably want to know the following:
I made this primarily for my own use, and since I can always just recompile the app with map modifications, it's working more than sufficiently for myself already. But if there's interest in it, I could probably have an updated version uploaded here soonish that can actually display the loaded maps, and allows you to modify them easily.
Let me know if you found this useful or have any comments. If you want to see this concept developed into an open source and freely available program, please consider supporting my work.