CSC128 : Introduction to Linux

Linux GUI Overview

A Short History of Linux User Interfaces

Modern application programs are rarely command-line programs like we've used so far.  They usually take advantage of a Graphical User Interface (as opposed to a Command-Line Interface).  

Early Computers
Originally, operating a computer meant actually moving wires and flipping switches, and then decoding the output of meters and lights.  Later, this became more automated with the introduction of punch cards and punch tape.

Teletypes (tty)
Eventually, as computers started to become more general-purpose, teletypes (tty) were used to communicate with them.  These were essentially typewriters connected to the computer so that the user could type on paper and signals representing the characters being typed would be sent to the computer, which would respond by taking control of the typewriter and typing out a response on the same paper.  This is the era in which Linux was born.

Command Line Interface
At this time, the Command Line Interface became the standard way of controlling a computer-- a big step up from flipping switches and punching cards.  The Command Line Interface mimics a conversation:  the user types text commands, and the computer responds with text.  Linux is full of commands to deal with text, as this was the main data computers worked with.

Terminals
Then came terminals.  These are just monitor/keyboard combinations that mimic ttys and add new features.  Terminals would be connected to the computer in the same way the ttys had been before.  Now programs like vi were written to take advantage of the CRT monitor.

Personal Computers
Now computers have become small enough that terminals are rarely used;  computers small enough to fit on a desk are directly attached to their own keyboards and monitors. Computers have become fast enough that a new user interface was created: the Graphical User Interface (GUI).

Graphical User Interface (GUI)
Rather than using a "conversation" metaphor,  GUIs use a "desktop" metaphor.  Application Programs are arranged on the screen like papers might be on a desktop.  A pointer controlled by a mouse allows the user to interact with their "desktop", pointing to items, moving them around, manipulating them, and giving them commands. This has become the dominant form of user interface, especially for the casual user.

In 1984 the Massachusetts Institute of Technology (MIT) formed Project Athena. The goal was to take the existing assortment of incompatible workstations from different vendors and develop a network of graphical workstations that could be used as teaching aids. The solution was a network that could run local applications while being able to call on remote resources. They thus created the first operating environment that was truly hardware and vendor independent - the X window System.

By 1986 outside organisations were asking for X. In 1988, MIT officially released version 11 release 2. The X Consortium now handles all the development of X and the most recent version is release 6, which was released in September 1995.¹

X-windows makes a natural base for GUIs, handling all the underlying hardware problems, and presenting a very Linux-like interface to the application programmer.  The application programmer does not need to concern herself with the specifics of the hardware for specific machines, but can write the GUI to work on any Linux system with an X-windows client written for it and its graphics system.  

The X-windows server is now maintained by X dot org

X is a fairly low-level interface.  It provides a single way of using different graphics hardware, but it doesn't give the application programmer many helpful tools, like all the pretty icons and buttons and sliders and whatnots that you've come to expect in a graphical environment.  These are known as widgets .

Many vendors and other groups have written entire program libraries to provide whole widget sets that give the application programmer a higher-level way of programming in a graphical environment.  Rather than telling X each and every pixel that needs to be drawn and where, the programmer simply calls a widget, like a button or a scrollbar, and the library program code handles the rest.

The X Consortium wrote its own widget set, Athena, which isn't very popular.  Historically, the Motif widget set has been very popular, although it seems to be moving out of favor today.  The battle is currently raging between GTK+ (GNU's Gnome Toolkit) and QT (by Trolltech), among others.

A window manager is an application that uses widget sets and X to give the user the ability to manipulate the X application windows around the "dekstop", or even to provide many virtual desktops that the user can quickly change between.  

The bar at the top of application windows, with all the little buttons to minimize, maximize, exit, etc. are all drawn by the window manager .  The window manager is responsible for controlling window behavior. Generally, the user still interacts with the computer though commands to a shell in a terminal window.

Another layer on top of the window manager that is becoming popular is the desktop manager.  This application isn't concerned with the way windows are drawn or behave;  instead, it provides graphical means of manipulating the computer; it aims to replace the shell, by giving the user similar functionality.  Instead of typing commands to a shell in a terminal window to view and move files, the user drags icons representing those files around the screen to visual representaions of different places in the filesystem.  For example, dragging an icon representing a file into a little picture of a trashcan might perform the same function as the command rm .

Some window managers are so complex that they border on becoming desktop managers.  Many times, the distinction is vague.

Vendor	Widget Library	Window Manager	Desktop Manger
X Consortium	Athena	twm
AT&T/SUN	OpenLook	olwm
OSF/OpenGroup	Motif	mwm
IBM/SUN/HP	CDE (based on Motif)	dtwm (based on mwm)	cde
SGI	Motif	4dwm
	custom	fvwm (based on twm)
GNU project/FSF	gtk+	enlightenment / sawfish	gnome
KDE	Qt	kdm	kde

There are many other window managers.  A short list includes: 9wm, aewm, AfterStep, aniwm, blackbox, ctwm, evilwm, flwm, icewm, mlvwm, qvwm, sapphire, scwm, swm, vtwm, windowmaker, wm2, wmx, xfce...