Explicit manipulation versus indirect manipulation UIs
One of the broad splits in user interfaces in general is the spectrum between what I'll call explicit manipulation and indirect manipulation. Put simply, in a explicit manipulation interface you see what you're working on and you specify it directly, and in an indirect manipulation interface you don't; you specify it indirectly. The archetypal explicit manipulation interface is the classical GUI mouse-based text selection and operations on it; you directly select the text with the mouse cursor and you can directly see your selection.
(This directness starts to slip away once your selection is large enough that you can no longer see it all on the screen at once.)
An example of an indirect manipulation interface is the common
interactive Unix shell feature of
!-n, for repeating (or getting
access to) the Nth previous command line. You aren't directly
pointing to the command line and you may not even still have it
visible on the screen; instead you're using it indirectly, through
knowledge of what relative command number it is.
A common advantage of indirect manipulation is that indirect
manipulation is compact and powerful, and often fast; you can do
a lot very concisely with indirect manipulation. Typing '
is unquestionably a lot faster than scrolling back up through a
bunch of output to select and then copy/paste a command line. Even
the intermediate version of hitting cursor up a few times until the
desired command appears and then CR is faster than the full scale
GUI text selection.
(Unix shell command line editing features span the spectrum of
strong indirect manipulation through strong explicit manipulation;
!-n notation, cursor up/down, interactive search, and
once you have a command line you can edit it in basically an explicit
manipulation interface where you move the cursor around in the line
to delete or retype or alter various bits.)
Indirect manipulation also scales and automates well; it's generally clear how to logically extend it to some sort of bulk operation that doesn't require any particular interaction. You specify what you want to operate on and what you want to do, and there you go. Abstraction more or less requires the use of indirect manipulation at some level.
The downside of indirect manipulation is that it requires you to
maintain context in order to use it, in contrast to explicit
manipulation where it's visible right in front of you. You can't
!-7' without the context that the command you want is that
one, not -6 or -8 or some other number. You need to construct and
maintain this context in order to really use indirect manipulation
effectively, and if you get the context wrong, bad things happen.
I have accidentally shut down a system by being confidently wrong
about what shell command line a cursor-up would retrieve, for
example, and mistakes about context are a frequent source of
production accidents like 'oops we just mangled the live database,
not the test one' (or 'oops we modified much more of the database
than we thought this operation would apply to').
My guess is that in much the same way that custom interfaces can be a benefit for people who use them a lot, indirect manipulation interfaces work best for frequent and ongoing users, because these are the people who will have the most experience at maintaining the necessary context in their head. Conveniently, these are the people who can often gain the most from using the compact, rapid power of indirect manipulation, simply because they spend so much time doing things with the system. By corollary, people who only infrequently use a thing are not necessarily going to remember context or be good at constructing it in their head and keeping track of it as they work (see also).
(The really great trick is to figure out some way to provide the power and compactness of indirect manipulation along with the low need for context of explicit manipulation. This is generally not easy to pull off, but in my view incremental search shows one path toward it.)
PS: I'm using 'user interface' very broadly here, in a sense that
goes well beyond graphical UIs. Unix shells have a UI, programs
have a UI in their command line arguments,
awk have a
UI in the form of their little languages, programming languages and
APIs have and are UIs, and so on. If people use it, it's in some
sense a user interface.
(I'd like to use the term 'direct manipulation' for what I'm calling 'explicit manipulation' here, but the term has an established, narrower definition. GUI direct manipulation interfaces are a subset of what I'm calling explicit manipulation interfaces.)