Unix predates the modern graphics-intensive style of software
interface design. For over a decade after the first Unix in 1969,
command-line interfaces (CLIs) on teletypes and dumb text-mode
terminals were the norm. Most of the basic Unix toolset (programs like
ls(1),
cat(1),
and
grep(1))
still reflect this heritage.
Gradually, after 1980, Unix evolved support for screen-painting
on character-cell terminals. Programs began to mix command-line and
visual interfaces, with common commands often bound to keystrokes that
would not be echoed to the screen. Some of the early programs written
in this style (often called ‘curses’ programs, after the
screen-painting cursor-control library normally used to implement
them, or ‘roguelike’ after the first application to use
curses) are still used today; notable examples include the
dungeon-crawling game
rogue(1),
the
vi(1)
text editor, and (from a few years later) the
elm(1)
mailer and its modern descendant
mutt(1).
A few years later in the mid-1980s, the computing world as a
whole began to assimilate the results of the pioneering work on
graphical user interfaces (GUIs) that had been going on at Xerox's
Palo Alto Research Center since the early 1970s. On personal
computers, the Xerox PARC work inspired the Apple Macintosh interface
and through that the design of Microsoft
Windows. Unix's adaptation of these ideas took a
rather more complicated path.
Around 1987 the X windowing system outcompeted several early contenders and
prototype efforts to become the standard graphical-interface facility
for Unix. Whether this was a good or a bad thing has remained a topic
of debate ever since; some of the other contenders (notably Sun's
Network Window System or NeWS) were arguably rather more powerful
and elegant. X, however, had one overriding virtue; it was open
source. The code had been developed at MIT by a research group more
interested in exploring the problem space than in creating a product,
and it remained freely redistributable and modifiable. It was thus
able to attract support from a wide range of developers and sponsoring
corporations who would have been reluctant to line up behind a single
vendor's closed product. (This, of course, prefigured an important
theme in the breakout of the Linux operating
system ten years later.)
The designers of X decided early on that X would support
“mechanism, not policy”. Their objective was to make X as
flexible and portable across platforms as possible, while putting as
few constraints on the look and feel of X programs as they could
manage. Look and feel, they decided, would be handled by
‘toolkits’ — libraries calling X services linked to
user programs. X would also be designed to support multiple window
managers,[106] and would not require a
window manager to have any special privileges or uniquely close
integration with X's machinery.
This approach was the polar opposite of that taken by the
Macintosh and Windows commercial products, which enforced
particular look-and-feel policies by designing them right into the
system. The difference in approach ensured that X would have a
long-run evolutionary advantage by remaining adaptable as new
discoveries were made about the human factors in interface design
— but it also ensured that the X world would be divided by
multiple toolkits, a profusion of window managers, and many
experiments in look and feel.
Since the mid-1990s X has become ubiquitous even on the
lowest-end personal Unix machines. Use of Unix from text-mode
terminals, as opposed to graphics-capable computer consoles, has
sharply declined and seems headed for extinction. Accordingly, the
use of curses-style interfaces for new applications is also in
decline; most new applications that would formerly have been
designed in that style now use an X toolkit. It is instructive to
note that Unix's older CLI design tradition is still
quite vigorous and successfully competes with X in many areas.
It is also instructive to note that there are a few
specific application areas in which curses-style (or
‘roguelike’) character-cell interfaces remain the norm
— especially text editors and interactive communications
programs such as mailers, newsreaders, and chat clients.
For historical reasons, then, there is a wide range of
interface styles in Unix programs. Line-oriented, character-cell
screen-oriented, and X-based — with the X-based world somewhat
balkanized by the competition between multiple X toolkits and
window managers (though this is less an issue in 2003 than
was the case five or even three years ago).