Personal Distributed Computing: The Alto and Ethernet Software

4.2.Storage

Although not quite as exciting as printing, shared storage services are even more necessary to a community of computer users, since they enable members of the community to share information. No less than five file servers were developed for the Alto and Dorado systems.

For its first three years, the Alto system used CSL’s mainframe [14], running the Tenex operating system [3], as its file server. A Pup version of the Arpanet file transfer program, written by Ed Taft, pro­vides access to the Tenex file system. Both Alto and Tenex have user and server ends of this program, so either machine can take the active role, and files can also be transferred between two Altos.

The second file server, called WFS and written by David Boggs [50], is near the opposite extreme of possible designs. It uses a connec­tionless single-datagram request-response protocol, transfers one page of 512 bytes at a time, and implements only files; directories are the responsibility of the client. There is a very simple locking mechanism. This extreme simplicity allowed WFS to be implemented in two months on a Data General Nova; it was later ported to the Alto. Of course, only clients that provided their own naming for data were possible, since WFS had none. These included an experimental office system called Woodstock, the Officetalk forms-handling system, Smalltalk, and a telephone directory system.

As the Alto system grew, the file service load on Tenex became too great. Since the Alto has a disk controller for 300 MByte disks, it is possible to configure an Alto with several GBytes of storage. David Boggs and Ed Taft assembled existing Alto packages for files (from the OS), file transfer (from FTP), and directories (a B-Tree package written by Ed McCreight) to form the Interim File System (IFS). A considerable amount of tuning was needed to fit the whole thing into a 128 KByte Alto memory, and a new Scavenger had to be written to handle large disks, as well as an incremental backup system. IFS served as the main file server throughout the Alto system for at least seven years and doz­ens of IFS servers were installed.

IFS supports multiple versions of files, write locking, and a clumsy form of subdirectories. Over time it acquired single-packet protocols to report the existence of a file to support CFS (see section 2.1), a WFS-style file server, an interim mail server, and access to Grapevine (see the next section) for access control.

Concurrent with the development of WFS and IFS was a research project to build a random-access multi-machine file server that sup­ports transactions and fine-grained locking. This became the Juniper system, designed and developed by Howard Sturgis, Jim Mitchell, Jim Morris, Jay Israel, and others [34]. It was the first server written in Mesa, the first to use an RPC-like protocol (see section 3), and the first to attempt multi-machine computation. Juniper was put into service in 1977, but performance on the Alto was mar­ginal. Later it was moved to the Dorado. The goals proved to be too ambitious for this initial design, however, and it was never widely used.

Cedar includes a second-generation file server supporting transac­tions. Called Alpine, it was built by Mark Brown, Ed Taft, and Karen Kolling [6]. Alpine uses Cedar RPC and garbage-collected storage; it also supports multi-machine transactions and fine-grained locks, using newer algorithms that benefit from the experience of Juniper and Sys­tem R [17]. It is widely used in Cedar, especially to store databases,

4.3.Naming and mail transport

The Alto system initially relied on Pup host names to locate machines and on the Tenex mail system for electronic mail. These worked well until the system grew to hundreds of machines, when it began to break down. It was replaced by Grapevine, designed and implemented by Andrew Birrell, Roy Levin, Roger Needham, and Mike Schroeder. Grapevine provides naming and mail transport services in a highly available way [1]. It also handles distribution lists and access control lists, both essential for a widespread community.

Grapevine was the second Mesa server. It was put into service in 1980 and has been highly successful; dozens of servers support a community of about two thousand machines and seven thousand reg­istered users. All the machines in the Alto and Dorado systems use it for password checking and access control, as well as for resource loca­tion and mail transport. It is also used to register exporters of RPC interfaces such as Alpine file service. The database is replicated; in other words, each item is stored on several servers; as a result it is so reliable that it can be depended on by all the other components of the distributed system.

5. User Interfaces

Perhaps the most influential aspects of the Alto system have been its user interfaces. These of course depend critically on the fact that the screen can display a complex image, and the machine is fast enough to change the image rapidly in response to user actions. Exploiting these capabilities turned out to be a complex and subtle matter; more than ten years later there is still a lot to be learned. The ensuing de­scription is organized around four problems, and the Alto system’s various solutions to them:

• 
  organizing the screen,
  
• 
  handling user input,
  
• 
  viewing a complex data structure, and
  
• 
  integrating many applications.
  

A final subsection describes the facilities for making images.

5.1.Windows

As soon as the limited display area of the screen is used to show more than one image, some scheme is needed for multiplexing it among competing demands. There are two basic methods:

• 
  switching, or time-multiplexing—show one image at a time, and switch quickly among the images; and
  
• 
  splitting, or space-multiplexing—give each image some screen space of its own.
  

Various approaches were tried, usually combining the two methods. All of them organize the major images competing for space, typically text documents or pictures of some kind, into rectangular regions called windows. All allow the user some control over the position and size of the windows. The windows either overlap or they tile the screen, arranged in one or two columns and taking up the available space without overlapping. Thus overlapping is a combination of splitting and switching; when two windows overlap, some of the screen space is switched between them, since only the one on top can be seen at any instant. Where windows don’t overlap, the screen is split. Tiling, by contrast, is a pure splitting scheme.

With overlapping, the size of one window can be chosen indepen­dently of the size or position of others, either by the system or by the user. With tiling, this is obviously not the case, since when one window grows, its neighbor must shrink. As a practical matter, this means that a tiled system does more of the screen layout automatically.

An overlapped system can have any number of windows on the screen and still show the topmost ones completely, perhaps at the cost of completely obscuring some others so that the user loses track of them. In a tiled system, as more windows appear the average size must become smaller. In practice, four or five windows in each of one or two columns is the limit. Either system can handle more windows by providing a tiny representation, or icon, as an alternative to the full-sized window. This is another form of switching.

A minor image, usually a menu of some kind, either occupies a sub-region of a window (splitting), or is shown in a pop-up window that appears under the cursor (switching). The pop-up temporarily ob­scures whatever is underneath, but only for a short time, while a mouse button is down or while the user fills in a blank. Thus it has an entirely different feeling from a more static overlapped window.

Figures 1-3 are typical screen arrangements from three systems. Smalltalk (Figure 1) uses overlapping windows without icons, and the position of a window is independent of its function (unless the user manually arranges the windows according to some rule). Smalltalk was the first system to use overlapping windows and pop-up menus. The Bravo editor (Figure 2) uses one column of tiled windows, with a control window at the top, a message window at the bottom, and a main window for each document being edited, which may be subdi­vided to look at different parts. Cedar (Figure 3) uses two tiled columns and rows of icons at the bottom (which can be covered up). This win­dow system is called Viewers; much of its design was derived from Star. The top line or two of a window is a menu. Cedar also allows the entire screen image, called a desktop, to be saved away and replaced by another one; this is switching on a large scale. Markup has a pop-up menu scheme like Smalltalk’s, but considerably more elaborate (Figure 4).