Monday, October 6, 2008

SMS fun

Put together a few things, and I'm quite pleased with the results.

It's all centered around the Perl module SMS::Send.

I did two interesting things with this:

1) A simple 10 line script that sends a message to my phone. This has been exploited in several interesting ways:
  • Alerts when a large job is done - I can walk around the house or office, and my phone buzzes when a task is complete.
  • maildrop filters that send the subject of certain emails to my phone
  • libpurple plugin that sends instant messages to my phone when I am away
2) A slightly more complicated daemon which watches RSS feeds and sends headlines to my phone.

These have done something interesting to my interaction with the computer. In essence, I've gone from polling to interrupt-driven. This saves me the time I would otherwise spend checking to see if there are new emails, RSS updates, new IMs, etc. It both puts this all in one place, and - more significantly - makes this one place fit in my pocket.

Of course, I've quickly learned the importance of disabling interrupts - thankfully, this can be done either explicitly by turning off the phone, or implicitly by ignoring when it dings, as appropriate. Conveniently, missed interrupts are naturally queued.

While the system at present is quite usable, it could undoubtedly benefit from some phone-side tweaks in presentation and manipulation of messages. Perhaps when I get a phone running Android, I'll play around with such... For now, though, I'm quite happy.

Friday, July 4, 2008

Keyboards suck.

Don't get me wrong. I love my keyboard. Keyboards are a marvelously effective way of turning what's in my head into bits in the computer. There are a few types of input they don't do well with - describing paths or relative motion - and this is why we have mice and tablets and suchlike, but on the whole they are pretty solid.

So why do I say keyboards suck?

Well, two reasons. First, aesthetic. Keyboards are ugly. We've seen steampunk mods and wooden keyboards and shiny shinies, some of which go a phenomenal way toward making these things *less* ugly, but they're still ugly.

Second, for portable applications the keyboard is huge and awkward to transport, or small and impossible to use. Presently, with laptops, there's little cost in increasing keyboard size up to the same size as the screen, which we don't want to shrink too small to begin with. This, however, ceases to be true when working with projection displays, wearable displays, or flexible displays (can you say "scroll"?).

So, the first issue applies to all keyboards all the time, while the second is mostly applicable to mobile applications. I have two projects which deal with these issues. The first deals only with aesthetics, but is hugely simpler (indeed, I already have a working prototype). The second deals with both issues.

Project the first:

While computer keyboards are ugly, piano keyboards are not. This is a personal, aesthetic judgment, but that's the way I feel about things. So what, I wondered, if we could type on a piano keyboard?

The solution is pretty simple. The term I've coined for it (which doesn't seem to be used, although there could be another term I'm unaware of) is "partially chorded." Those familiar with chorded keyboards may have a good idea where this is going. Two octaves are used for the input scheme. In the upper octave, one keypress generates one keypress based on a mapping. Chords in the lower octave are used to pick the mapping in the higher octave. Mappings should be chosen such that letters frequently paired are grouped, minimizing changes of chord.

As mentioned, I threw together a prototype of this using input from a friend's MIDI keyboard. The results are promising. With a guess at a reasonable set of mappings and a few minutes practice, I was able to type at nearly 10 WPM. Not bad, I think, when I've never used a similar system of input.

With just a little wiring, you can run your experiments, compile your code, and send your emails from in front of a pipe organ. How mad scientist is that?

Next step here is writing linux drivers so this can be used in any application, not merely my test program.

Project the second:


My idea here is to use the habits we've already burned into our synapses, but rather than detecting them by means of keys pressed, pick them by watching the shape of the hand. My hypothesis, based on observation of my own hands while typing, is that I seem to do enough different things that what button I'm pressing should be detectable without actual knowledge of where my hands are located. This removes a significant difficulty in producing such gloves based on only intrinsic sensors, while allowing typing in a broader range of positions (perhaps while walking, for instance).

Some gesture support would be a worthy addition, but more than that is probably feature creep. If I can come up with a good way of faking a mouse, that may be added. Manipulation of 3d objects, however, is not a goal at all.

First step here is to figure out what sorts of sensors might be appropriate.

Monday, June 30, 2008


Okay, so... this is mostly a place for me to ramble about my projects. I found myself rambling to different people at different times, and decided I needed to consolidate my rambling in one place - cutting down on duplication of rambling. Yup, all my rambling in one place...

I've always got a lot of projects. They'll be introduced in turn.