Expectations: When to be automagic, and when it makes sense to be explicit
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.
Autocomplete
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?
April 24th, 2009 at 10:59 am
There are many features like this, but you’ve just established one of the basics of interaction: don’t get in the way of the user, do things for the user when the user wants you to do them. Even though users choose between similar products that have certain features over others mostly for ideological reasons, it’s important to remember that imposing (even if the feature can be disabled) is never good. So if you want to allow command line completion to be turned on or off, remember to set the default to off.
Personally, I’ve been watching your development of Bespin for some time and based on that I think the best option would be to use something like Google Suggest, because it is a feature that could eventually be applied inside the code (ie: after typing “document.”) later on, and consistency is always a good choice.
Great post, great insight!
April 24th, 2009 at 11:24 am
That’s probably why pretty much every automatic autocomplete feature not only autocompletes but also selects the added text. So if you type “li” it will add and select “st”. If you then type “s” it will replace “st” (because of the selection) and autocomplete will add “t” – selected again of course. So you can type the command yourself – or you can press End to just accept the suggestion and continue typing.
April 24th, 2009 at 12:35 pm
I’ve been thinking about this in the context of social web applications, and their interconnections.
Sure, it’s a nice idea to have a bunch of webapps using one another’s apis, until you have no clear idea of what information is being passed between them, and what action on your part might or might not result in some feed story or notification about your being blasted to all your friends.
Yes, these apps should do a lot for you, and they should be easy to use, but they should also make it very obvious to the user what they are doing with that user’s data.
April 24th, 2009 at 7:33 pm
I’ve been coming to like mercurials approach to command completion, which is that it doesn’t complete stuff at type time (that’s just happening in your shell), but you can type any unique prefix. So you can do:
hg qseries
hg qserie
hg qseri
hg qser
and they all do the same thing. If you type
hg qse
you get:
hg: command ‘qse’ is ambiguous:
qselect qseries
Of course one can get used to typing “qser” and then suffer if a new command that starts with that string is added…. but if the command set is reasonably fixed, this lets people remember the abbreviations they want on their own time.
April 25th, 2009 at 1:40 am
Hi,
well maybe you just implemented autocomplete in a bit clumsy way. As Wladimir said it should never actually insert stuff without you approving it, this way you never get “listst”. For example OpenOffice autocomplete does a pretty good job at it.
Since we are also working on automagic tool at Zemanta, we’re discussing these kinds of things a lot. I’d be interested in your thoughts how blogging and text authoring in general could be improved by tools that understand the text to a certain degree beyond spell checking.
Andraz Tori, CTO at Zemanta
April 25th, 2009 at 2:19 am
One very annoying autocomplete feature of some editors is automatically adding braces of any sort. You know, you type
printf(
and it autocompletes to
printf()
with the cursor between the parentheses. But of course, you’re typing so quickly that you never notice and add the closing parenthesis yourself, so you end up with two.
Eclipse is very smart about this, remembering that the parenthesis was auto-added, and overwriting it if you type it explicitly.
On a side note, your anti-spam question is missing from the proper tab order.
April 25th, 2009 at 9:32 pm
My usual feeling is that if an application is going to try and be clever and helpful, it has to be near on perfect at doing so. Any less, and it’s an annoyance that people will want to turn off. And once it’s turned off, it doesn’t matter if you subsequently make the feature better in the next release – because the user already has it disabled. You only get one shot at getting this kind of thing right.
April 27th, 2009 at 4:58 am
Bang on! Of all companies, Google almost never irks.
On a slight tangent: I use Windows XP, and alert bubbles often pop up in the system tray. They are so irritating. You can’t like disable them forever which a youth like me would much love to interpret as a conspiracy of sorts of Microsoft. hehehe
Like in relationships, they really are the small and subtle things that matter!
So like talking more of those notification bubbles — if you wanna close them, there’s that tiny cross at the top right corner of the bubble that you gotta point your mouse to and click — and you wanna close them 99% of the time — and the rest of the space of the bubble, anywhere you click and the window that links to the bubble opens.
For notification the system tray shoots a bubble
It looks so clean and obvious
But trust you me it is Microsoft’s conspiracy subtle!