Have you ever noticed how the odd subtle feature here or there has profound impact? You can either inspire the “wooah, I can’t believe this app just did this!” for good or ill.
When I try new Twitter clients for example, the lack of a certain feature that I am used to can be the game changer for me. One simple example is expanding short URLs. I don’t want to see
http://tinyurl.com/aaaa. I want to see
http://bbc.co.uk/..... The fact that Twitter has the URLs part of the space limitation is their issue, not mine. I have a greasemonkey script that auto expands through the 301 redirect stack. When I tried Tweetie for the Mac, I looked for that feature. It gets a passing grade as you can turn on a feature that onclick does a popup with the full URL and “sure you want to go here?” Not bad, but not what I really actually want. The same goes for writing a message. Let me put in the full URL and if the message is too long, at that point auto shorten for me.
So, subtle features can make or break my enjoyment of a tool. On paper, two competing tools can look the same, but you find that one user base loves it, and another doesn’t. We have run into that a little with Git and Mercurial. On the surface they are both very similar DVCS, but subtle usage differences have resorted in very different reactions from our community. Also, the fact that Github exists (even though Bitbucket is doing well too) makes a huge difference.
One common problem that I constantly find myself grappling with is that I sometimes try to do too much “automagically” for the user. Surely, if I do all of this stuff for a user, they will love me! That is what computers should be doing, make them do less.
Although this is very true, and comes up in the Twitter examples above, and also in the fact that Google does an amazing amount of work behind the search box, it is a tricky balance.
One case that everyone has experienced is auto correction. I remember when this feature first appeared in Word and it drove me batty. I always felt like I was fighting the machine. No! Don’t capitalize that for me! I actually get that feeling with the iPhone to this day. The only reason that I keep autocorrect on in the iPhone case is that the keyboard is so fat-finger-constant that you have too. Still, a day doesn’t go by when I don’t type something that puts a capital letter in and then I have to back up to it and then remember to un-select SHIFT. Ugh. This is the kind of thing that makes your blood pressure up every time you do it, and you curse the fact that computers are still so dumb.
I made the same mistake myself with Bespin and the command line. Early on I thought to myself:
“since I know all of the possible commands that the user can run, if they have typed enough that there is only one choice, automatically fill it in!”
This seemed great. No need to even hit the tab key! In practice though it was silly indeed. I found myself at a command line with value such as “listst” (as it auto filled to “list” but I didn’t notice and kept typing the end). With years of command lines under my belt, this new functionality went against all of my training. Having to do a TAB myself turned out to be a feature. It gave me control. What I did do though was add a filtered list of commands above the command line which gives the user information on what is available, and when you are down to one you know that TAB will get you there.
This made me realise the subtle difference between autocorrection, and say Google results when they suggest “Did you mean ‘Hilly Mit’?” If Google just thought it was so much smarter than you and changed the terms automatically you would be as frustrated as Word autocomplete. This way, you get control, and when Google is right (90% of the time) you are one quick click away from your answers. Of course, Google is so good at searching that even if your term was a bit off, often the result is right there anyway so you don’t even need that click.
Another more subtle feature of the command line that tries to be smart, is the fact that if you have typed in a command that has no other options, and the command requires a parameter, a space is automatically added. This means that you skip a SPACE BAR hit and you get a visual cue. In reality it normally means two spaces in between the command and first argument (which is of course fine and is no different). It is still enough to bug people.
Of course, this all pales in comparison to the grand daddy of all, Clippy. Clippy offered no value, was wrong 90% of the time, and was incredibly in your face. All pain and no gain.
In conclusion, whenever I think about adding a feature that seems borderline too smart I stop and think:
- Is this too smart for its own good (like auto correct)
- Would it be better to subtly give the information to the user so they can act on it (like Google search “did you mean?” and Google Suggest)
- Should I make this a setting that the user can easily turn on and off (as in command line completion)
Have you noticed features like this?