GreyWyvern wrote:

Soon (real soon now) we'll be progressing to voice-controlled systems. "Copy Document to desktop", "Empty trash", "Open Slashdot".

This is precisely an argument for the command-line paradigm! What you are describing is a command-line, with the keyboard simply being replaced with a microphone.

Experiment: take someone who is accustomed to using such a voice-driven
interface and then put them in front of a command line. In advance, set up
a bunch of aliases and wrapper scripts. e.g.:

/bin/copy


#!/usr/bin/perl
$src = shift @ARGV || die "Copy what?\n";
$dest = shift @ARGV || die "Where should I copy it?\n";
if ($dest eq 'to')
{
  $dest = shift @ARGV || die "Where should I copy it?\n";
}
$dest = '~/Desktop/' if ($dest eq 'Desktop');
$dest = '~/.Trash/' if ($dest eq 'Trash');
$dest = '~' if ($dest eq 'Home');
$dest = '~/public_html/' if ($dest eq 'Shared');
system("cp '$src' '$dest'");
# you'd probably want to do better error handling.

/bin/open


#!/usr/bin/perl
die "Open which site?\n";
$url = 'http://www.google.co.uk' if ($dest eq 'Google');
$url = 'http://www.ebay.com' if ($dest eq 'Ebay');
$url = 'http://www.bbc.co.uk' if ($dest eq 'BBC');
$url = 'http://news.bbc.co.uk' if ($dest eq 'News');
system("opera '$url'");

Sit them at this command line and tell them to type everything they'd normally say with their voice-controlled interface.

Straight away they type "Copy document to Desktop" and it would work. Similarly, if you set up the right aliases and scripts, any command they used to use under the voice control would work by keyboard. They'd say "This is great! Now I can give my computer all my usual commands when I'm in a quiet place, like a library!" You can point out SSH and they'd say "Even better! I can give my computer all my usual commands from anywhere in the world!"

They wouldn't see the command line as being "hard" at all. This is because voice commands and the CLI share the same paradigm -- you give the computer a command and the computer responds.

Perhaps much of people's disagreement with me in this thread is down to a misunderstanding of what I mean by CLI and GUI.

I see CLI as being a mode of interaction with the computer not defined necessarily by use of the keyboard or by display on a 80×24-cell 16-colour text terminal, but by the way in which people interact with it -- they give a command, the computer gives a response.

I see GUI as being nested menus, fill-in forms, toolbars, icons, etc -- not defined in terms of its richer resolution or colour depth, but in the way people interact with it. Such a GUI could conceivably be implemented in ASCII art, but still be a GUI all the same.

The GUI is the reason most computer users find computing hard. It doesn't feel like we're giving commands and the computer is responding -- instead, we're confronted by rows of buttons, lists, icons and drop down menus, and all we have to tame them with is a single pointer with, generally 2 or 3 buttons on it.

This overwhelms and confuses the newbie. You or I are different -- we are able to abstract the GUI and think of it in almost command-driven terms. We don't think "I'll put the mouse at the beginning of the text, hold down the left button, move the mouse to the end, release the button, move the mouse over the B button on the toolbar and click the left mouse button". We think "Computer, make this text bold!" -- an abstracted command-driven thought process.

For a newbie, not able to make this abstraction, a command-driven interface is less confusing -- they can focus on one thing at a time. They tell the computer to do something and the computer either says it doesn't understand or needs more information; or the computer does what it was asked and displays some result if appropriate. They feel in control.

That is why I say that the command-line interface still has a future. That's not to say, it doesn't need some improvements. A shell with a slightly nicer and more forgiving syntax could win hearts and minds -- there's no reason not to apply what we've learnt in recent years about natural-language processing to the command line.