According to The Free On-line Dictionary of Computing, "usability" is the "effectiveness, efficiency, and satisfaction with which users can achieve tasks in a particular environment of a product. High usability means a system is: easy to learn and remember; efficient, visually pleasing and fun to use; and quick to recover from errors." In an earlier paper (2005), I built on this definition to outline four dimensions of usable software: cognitive, physical, productivity (or practical), and emotional:
Design systems so that users perceive all information they need to operate it, and can easily learn to use it:
Design systems so that users can operate them with minimum physical effort:
Design systems so that users complete tasks efficiently, quickly, and with minimum error:
Systems should be designed to:
By the criteria of these four dimensions, today's operating systems and applications fall short of being highly usable, particularly for people with disabilities. For example, keyboard interaction with the ribbons of the "Fluent User Interface" in Office 2007 and Windows 7 is less usable than the menus that they replace. Whereas the rules for accessing menus by keyboard are relatively straightforward, navigating through ribbons via keyboard is labyrinthine, unpredictable, and labour-intensive. There are enough inconsistencies that describing keyboard interaction rules is exceedingly difficult. For users who depend on keyboard access, the proliferation of ribbons means that driving software is becoming more, rather than less, complicated.
One response to the growing complexity of software is to use macros. In this paper, I highlight macros that I developed while providing assistive technology support services to employees with disabilities in computer-intensive work environments. Macros can be scripted to work in standard and non-standard applications, and repair usability and accessibility problems.
This paper focuses on macros that reduce cognitive and physical effort. Cognitive effort is reduced by simplifying multi-step processes; making program features work the way that users expect; and decreasing the need to memorize hotkeys or recognize icon images. Physical effort is reduced by decreasing the number of keystrokes or mouse clicks; shortening reaching distances; and eliminating the need to target screen objects precisely. I also provide examples of macros that reduce both cognitive and physical effort.
Although I emphasize macros that reduce cognitive and physical effort, the examples address the productivity and emotional dimensions of usability as well, e.g., reduce the likelihood of triggering unanticipated actions, and foster feelings of success.
A macro is a software shortcut for performing a sequence of steps. A macro may perform one simple step, e.g., insert a word, launch an application, or click on a screen object; or a reproduce a complex, multi-step process, e.g., select text in one application, copy it, switch to another window, paste it, and finally, switch back to the original program. Some macros have a modicum of built-in intelligence. "Smart macros" collect information from the user and from the user interface, and make decisions on the basis of this data.
The macros described in this paper were developed using Macro Express, AutoHotKey, Visual Basic for Applications (VBA), and NaturallySpeaking Advanced Scripting. Other script development utilities can be used to achieve the same ends.
Accelerator keys activated by Alt + an underlined character sometimes conflict. For example, in one program, Alt + T was the shortcut for the "Tools" menu and the "Telephone number" field. When conflicts like these occur, people who rely on keyboard access may be unable to complete a task, or be forced to learn workarounds.
To force keyboard interaction to work as users expect, I use window or application-specific hotkeys to activate the most frequently accessed object.
A call centre employee used keyboard and mouse to drive a custom application. Because of mouse-related injuries, she wanted to learn to drive the program by keyboard. However, much of the program was not keyboard accessible.
I developed hotkey macros to access essential program functions. But after implementing about 30 commands, the employee reported difficulties remembering the hotkeys. Although we started with easy-to-remember key combinations, the large number of commands meant naming conflicts were inevitable; finally, we were forced to opt for less "intuitive" triggers. For example:
To reduce the need to memorize hotkeys, we developed a system based on a single rule: always use the first letter of words. To begin, the employee and I grouped all commands into categories — six in all — and assigned each category a hotkey. Each hotkey incorporated the first letter of the category name: e.g., Sales = Alt + S, Billing = Alt + B, plus four others.
Each hotkey invoked a pop-up menu consisting of four to six commands. These commands were activated by a pressing an accelerator. Because the number of commands was relatively small, we were able to use the first letter of every command as its accelerator.
With the pop-up menus, the employee only needed to think in terms of first letters. For example, to access Sales-related commands, press Alt + S, followed by:
The employee reported the new system was easier to remember than the old system. She likened the process of entering commands to saying her favourite Jean-Luc Picard line from Star Trek: "Tea, Earl Grey, Hot."
Despite the success of the new system, there was a usability trade-off: pop-up menus slightly increased the physical effort. The employee had to press three keystrokes per command instead of two.
In an application with a login screen, the accelerator to navigate to the username field did not work. Rather than merely repair the problem as described above, I scripted a macro that navigated to the login field, entered the user name, navigated to the password field, entered the password, logged in, and moved focus to the first active field.
I scripted a macro for Microsoft Outlook to simplify copying email addresses from the To, CC, and BCC fields. Normally this is an intensive, multi-step process that often fails.
With the macro, clicking on or near an email address locates the email address and determines the best way to select and copy it to the clipboard.
To simplify and automate repetitive tasks for an individual who relies on a tablet PC, I scripted macros activated by touching the stylus to scrollbars, minimize and maximize icons, menus, and other UI elements. Additional scripts were triggered by moving the stylus into the four corners of the tablet screen.
Call centre staff entered data into a mouse-intensive application. An employee with mouse-induced injuries could no longer operate the program efficiently. I developed a set of hotkey macros that move the mouse pointer and click on controls; send key sequences to activate controls; and drill through menus to activate commands.
After entering a word or phrase to train, NaturallySpeaking prompts the user to click "Go" when ready to record; and click "Done" after making the recording. For some users, the two extra steps complicate training.
I developed a smart macro, triggered when the "Train Word" dialog box gains focus, that activates the "Go" button immediately, waits until the user has trained the word (or 10 seconds, whichever comes first), and finally, activates the "Done" button.
For users who are easily distracted, or who need to work hard to close windows, I scripted macros that automatically close pop-ups and nuisance windows when their title bars or controls gain focus.
Similarly, I used macros activated by title bars to automatically resize and reposition windows. For example, for a client who uses screen magnification software, opening an email message moves the message window to a specific position, and sets its height and width to minimize the need for scrolling.
As implied by the title of this paper, many of the macros described are "Band-aid" solutions in the sense that they are repairs necessitated by program features that are difficult or impossible to access. A better solution is for software developers to pay more attention to accessibility and usability.
But even when applications are accessible and usable, macros are an effective way to "sculpt" software to exactly fit the physical, cognitive, productivity, and emotional needs of individuals.