|The cranky user: Could you repeat that?|
One of the most common tasks computer users face is repetition -- performing the same task more than once. Computers are fairly good at this. So why do people spend so much time repeating tasks by hand? Often the interfaces they use are resistant to automation, and other interfaces are obscure or unavailable.
For most users, this ability extends to printing multiple copies of a document, or perhaps, with training, a mail merge. Batch processing is almost always considered a "power user" feature, if it's possible at all. In general, though, many tasks are simply not subject to automation. Need to rename files? You rename them one at a time.
Users spend hours, even days, carefully repeating tasks. Open each file, then do each of three steps to it, then do exactly the same thing over and over again. New company logo? Go through each file using the logo and update it. By hand.
Some macro recorders have been observed to record exact key presses and mouse movements - meaning that even the slightest deviation can render them useless. Sometimes, the recorder just doesn't notice a given action. I was frustrated to no end to discover that the AppleScript script recorder could not detect or record screen resolution changes, when I wanted to make a script to change resolution before starting a game. In this case, there was no way to script the change, without third party software. Sometimes there is a way to script the action, but the macro recording software doesn't recognize it.
Macros are an excellent start to making programs usable. It is unfortunate that many sites, quite justifiably, ban them entirely for security reasons.
There is no convenient way in most GUI environments to express the idea of "do this twenty times" or "do this series of operations to each file I have selected". Unix users often do such things without a second thought.
You can have this same experience in other environments in which programming is a standard feature. Amiga users often produced small scripts; similarly, even fairly naive Macintosh users have been known to produce fairly flexible AppleScript programs.
Programmers vs. users
In the end, users are programmers; they are people who come up with a series of operations they wish a computer to perform and direct the computer to perform those operations. When an office's local domain expert in a given program can rattle off the instructions for a common task from memory -- without looking at the computer -- reliably enough that other people can follow them, chances are that person could easily learn to describe this same series of operations for the computer. AppleScript's pseudo-English syntax is probably intended to take advantage of this.
Using the tools you have
Of course, sometimes, the tools aren't quite up to snuff. There is something exceptionally irritating about building a script to automatically perform a task that would otherwise have taken you the whole afternoon, only to discover that you should have clicked buttons on several occasions because the scripting tool can neither suppress nor respond to confirmation dialogs.
Often, the tools used for scripting are entirely separate from the tools used for normal use of a computer. This increases the learning curve for scripting substantially; one of the advantages of the Unix model is that the tools you use when scripting tasks are the same tools you would normally use when performing these tasks yourself. Familiarity, in this case, breeds ease of use.
In many cases, these tools already exist, and this is simply a question of user education. However, it is often also a question of completeness or accessibility. Tools for automating repetitive tasks should be reasonably easy to find, and should be able to control any task the software can perform.
This Week's Action Item: Do you ever repeat the same task several times on a computer? Can you make the computer do it automatically?