Personal Distributed Computing: The Alto and Ethernet Software

6.2.Illustrators

The Alto system has a number of different illustrators for different kinds of pictures: pure bit-maps (Markup), spline curves (Draw), logic diagrams and other images involving only straight lines (SIL), and font characters (Fred). They all handle multi-font text as well, and all pro­duce Press output for printing; most can show a screen image that exactly matches the printed image. Usually they work on only one pic­ture at a time. None is integrated with a text editor; however, there is a separate batch program called PressEdit (written by William New­man), that can combine images from several Press files into a single file. PressEdit is used to assemble complete documents with text and figures; it has the drawback that the assembled document cannot be edited interactively. Several designs for integrated text and graphics editors stumbled over the limited size of the Alto.

William Newman’s Markup was the first illustrator for the Alto [25]. It edits multi-page Press files, one page at a time, but it can only handle text and bitmap images, not lines or curves. Markup provides an assortment of brushes for painting into the bitmap, as well as opera­tions for erasing and for moving or copying a rectangular region of the image. There are separate facilities for text strings, so that these can be printed at full resolution, since screen-resolution text looks terrible in hard-copy. Figure 4 is an example of the kind of picture that can be made. The Apple Macintosh’s MacPaint is quite similar to Markup.

There are two very different illustrators that deal with synthetic graphics, in which the picture is derived from a set of mathematically defined curves. Draw, written by Patrick Baudelaire, builds up the picture from arbitrary lines and spline curves [25]. It has facilities for copying parts of the image and for applying arbitrary linear transfor­mations. Curves can be of various widths, dashed, and fitted with var­ious arrowheads. Thus very pretty results can be obtained; Figure 5 shows some examples. The great variety of possible curves makes it difficult to use Draw for simple pictures, however, and it runs out of space fairly quickly, since it needs a full-screen bitmap (60 KBytes) and code for real arithmetic and spline curves, as well as the usual font-handling code, space for the fonts, the user interface, and so on. All of this must fit in the 128 KBytes of the Alto. Draw does not use the software virtual memory or overlaying techniques that allow Bravo to fit; these would have made the program quite a bit more complicated.

Figure 5: Typical Draw pictures (not a screen shot, but a faithful representation rendered at high resolution)

Chuck Thacker built SIL for making logic drawings [57]. Thus the main requirements were capacity for a complex drawing, a user interface well suited to experts who spend tens or hundreds of hours with the program, and a library facility for handling the images of logic components. SIL allows only characters and horizontal and vertical lines, which are easily handled by all the raster printers. There is a special font of bitmaps that represent and-gates, or-gates, resistors, and a few other specialized shapes, and a macro facility allows draw­ings of complex components to be built up from these. Since SIL draw­ings can be rather complex (see Figure 6 for an example), redrawing the picture must be avoided. Instead, SIL draws a picture element with white ink to erase it, and in background redraws every element that intersects the bounding box of the erased element. This simple heuris­tic works very well. Somewhat to everyone’s surprise, SIL is the illus­trator of choice when curves are not absolutely required, because of its speed, capacity, and convenience.

Figure 6: A logic drawing done in SIL

For designing font characters with spline outlines Patrick Baude­laire built Fred. An Alto interfaced to a television camera captures an image of the character, and the user then fits splines around it. The resulting shapes can be scan-converted at various resolutions to pro­duce different sizes and orientations of the character for printing.

SIL and Fred are illustrators associated with batch-processing pro­grams: a design-rule checker and wire-list generator for logic drawings made in SIL, and a battery of scan-conversion, font-editing, and man­agement software for Fred.

6.3.Filing

From its earliest days the Alto system has had the usual operating sys­tem facilities for managing stored information: Directories can be listed and files renamed or deleted. This is quite clumsy, however, and many attempts have been made to provide a better interface. Most of these involve listing the contents of a directory as a text document. Lines of the listing can be selected and edited; deletion means deleting the file, changing the name renames the file, and so forth. Gypsy was the first system to use this scheme; it was followed by the Descriptive Directory System (DDS) built by Peter Deutsch [25], by Neptune built by Keith Knox, and later by Star’s file folders. DDS and Neptune allow the user to control what is displayed by writing filters such as “memo and not report”, which are applied to the file names. Star has a standard hier­archical directory system, which it manifests by allowing folders to ap­pear in other folders.

Some other experiments with filing were more interesting. The Smalltalk browser is described in section 5.3 and illustrated in Figure 1; it has been very successful. Cedar has a facility called Whiteboards, illustrated in Figure 3, which deals with a collection of pages, each containing text and simple figures. A picture on one page can be a reference to another page; when the reference picture is clicked with the mouse, the page it points to is displayed. This is a convenient way to organize a modest amount of information. Finally, the electronic mail systems are heavily used for filing.

6.4.Electronic mail

The Alto system certainly did not introduce electronic mail, and in its early days Tenex provided the mail service. One of the most successful applications, however, was the Laurel user mail system built by Doug Brotz, Roy Levin, Mike Schroeder, and Ben Wegbreit [5]. Lau­rel provides facilities for reading, filing, and Grapevine or some other transport mechanism handles composing electronic mes­sages, actual transport and delivery.

Laurel uses a fixed arrangement of three windows in a single col­umn (see Figure 7). The top window is a message directory, with one line for each message in the current folder. The other two windows hold the text of a message being read and the text of a message being com­posed; the latter can be edited, and text can be copied from the middle window to the bottom. Above each window is a line of menu buttons relevant to that window; some of them have associated blanks that can be filled in with text when that button is clicked. A set of messages can be selected in the directory by clicking, and deleted, moved, or copied as a unit. Deleted messages are marked by being struck out in the directory; the actual deletion is only done when exiting Laurel, and can be undone until then.

Figure 7: A Laurel screen (not a screen shot, but a faithful representation rendered at high resolution)

Laurel can handle any number of message folders, and allows a message to be moved or copied from one folder to another. It also pro­vides commands to forward or answer a message; these set up the composition window in a plausible way, but it is easy for the user to edit it appropriately. Message bodies are copied to the user’s Alto from a mail server when the message is first retrieved. A message folder is represented as two Alto files, a text file for the messages and a table ­of contents file; there is a scavenger that reconstructs the latter from the former in case of trouble.

This apparently simple user interface is the result of about a man-year of design, and shows its value in the fact that most users never refer to the manual. This friendliness, together with the transparent view of the state provided by the message directory and the high relia­bility of message retrieval and storage, made Laurel very popular.

A variant of Laurel called Cholla is used as the backbone of a control system for an integrated circuit fabrication line. Special messages called recipes contain instructions for the operator and the computer-con­trolled equipment, and messages are sent to the next station and to administrators and logging files as a job progresses through the sys­tem. The beauty of this system is that everything is immediately acces­sible to a person trying to determine the state or track down an error and that the high reliability of the Grapevine transport mechanism makes lost data extremely unlikely.

Cedar has a mail facility called Walnut, patterned on Laurel, but using the standard Viewers windows and menus; it was built by Willie-Sue Haugeland and Jim Donahue. Walnut uses the Cedar entity-relationship database built by Rick Cattell to store messages; this turned out to be relatively unsuccessful, much to our surprise. It seems that a database system does not have much to contribute to a mail system.

7. Conclusion

During the 1970s the Computer Science Laboratory and Learning Re­search Group at Xerox PARC built a complete personal distributed computing system: computers, display, local network, operating sys­tems, programming environments, communication software, printing, servers, windows, user interfaces, raster graphics, editors, illustrators, mail systems, and a host of other elements. This Alto system did not have a detailed plan, but it was built in pursuit of a clear goal: to make computers better tools for people to think and communicate.

The Alto system has spawned a great variety of offspring. The Dorado system and the Xerox Star are the most direct line. Table 2 lists a number of commercial systems derived from the Alto. There have also been many in universities and research laboratories.

A dozen years of work have made it clear that these systems only begin to exploit the possibilities of personal distributed computing. Continuing progress in devices ensures that processors and networks will get faster, storage devices larger, displays clearer and more color­ful, and prices lower. Compact discs, for example, allow half a gigabyte to be reproduced for a few dollars and to be on-line for a few hundred dollars; the impact will surely be profound.

These improvements and, even more important, a better under­standing of the problems will lead to systems that are easier to program and use, provide access to far more information, present that informa­tion much more clearly, and compute effectively with it.

Engineering	Perq; Apollo; Sun; Tektronix; DEC workstations
AI workstations	MIT Lisp machine; Xerox 1100/1108/1132; Symbolics; LMI
Personal computers	Apple Lisa, Macintosh; Xerox 8065
Office workstations	Convergent NGen; Xerox 8010; Apple Macintosh; Grid
Graphics terminals	BBN Bitgraph; Bell Labs Blit
Local area networks	Ethernet/IEEE 802.3
Network protocols	ARPA IP/TCP; Xerox Network Services, Clearinghouse
Laser printers	Xerox 9700, 5700, 8044; Imagen; Apple Laserwriter
Printing interfaces	Xerox Interpress; Adobe Postscript
Servers	3Com file server, Xerox 8044 and Apple Laserwriter print servers
User interfaces	Xerox 8010; Apple Macintosh; Microsoft Windows
Editors	Apple MacWrite; Microsoft Word
Illustrators	Xerox 8010; Apple MacPaint, MacDraw

Table 2: Commercial systems descended from the Alto (as of 1986; partial)

7.1.Acknowledgments

I am grateful to Bob Sproull, Peter Deutsch, David Boggs, Carol Peters, and Cynthia Hibbard for comments on earlier versions of this paper, and to Ed McCreight and Adele Goldberg for supplying some of the figures.

7.2.References

[1] A. D. Birrell et al. Grapevine: An exercise in distributed computing. Communications of the ACM, 25(4):260-274, April 1982.

[2] A. D. Birrell and B. I. Nelson. Implementing remote procedure calls. ACM Transactions on Computer Systems, 2(1):39-59, February 1984.

[3] D. G. Bobrow et al. Tenex: A paged time-sharing system for the PDP­-10. Communications of the ACM, 15(3):135-143, March 1972.

[4] D. R. Boggs et al. Pup: An Internetwork architecture. IEEE Transactions on Communications, 28(4):612-624, April 1980.

[5] D. K. Brotz. Laurel Manual. Technical Report CSL-81-6, Xerox Palo Alto Research Center, 1981.

[6] M. R. Brown et al. The Alpine file system. ACM Transactions on Computer Systems, 3(2), November 1985.

[7] R. R. Burton et al. Interlisp-D: Overview and status. In Proc. Lisp Confer­ence, Stanford, 1980.

[8] P. A. Crisman, editor. The Compatible Time-sharing System: A Program­mer's Guide. MIT Press, 2nd edition, 1965.

[9] L. P. Deutsch. Experience with a microprogrammed Interlisp system. IEEE Transactions on Computers, C-28(10), October 1979.

[10] L. P. Deutsch. A Lisp machine with very compact programs. In Proc. 3rd International Joint Conference on Artificial Intelligence, Stanford, 1973.

[11] L. P. Deutsch and E. A. Taft. Requirements for an experimental programming environment. Technical Report CSL-80-10, Xerox Palo Alto Research Center, June 1980.

[12] D. C. Engelbart. The augmented knowledge workshop. In Proc. ACM Conference on the History of Personal Workstations, January 1986.

[13] D. C. Engelbart and W. K. English. A research center for augmenting human intellect. In Proc. AFIPS Conference, pages 395-410, 1968.

[14] E. R. Fiala. The MAXC systems. IEEE Computer, 11(5):57-67, May 1978.

[15] C. M. Geschke et al. Early experience with Mesa. Communications of the ACM, 20(8):540-553, August 1977.

[16] A. Goldberg and D. Robson. Smalltalk-80: The Language and its implemen­tation. Addison-Wesley, 1983.

[17] J. Gray et al. The recovery manager of the System R database manager. ACM Computing Surveys, 13(2):223-242, June 1981.

[18] D. Ingalls. The Smalltalk graphics kernel. Byte, 6(8):168-194, August 1981.

[19] D. H. Ingalls. The Smalltalk-76 programming system: Design and imple­mentation. In Proc. 5th ACM Symposium on Principles of Programming Languages pages 9-16, January 1978.

[20] R. K. Johnsson and J. D. Wick. An overview of the Mesa processor archi­tecture. ACM SigPlan Notices, 17(4):20-29, April 1982.

[21] A. C. Kay. The Reactive Engine. Ph.D. thesis, University of Utah, 1969.

[22] A. C. Kay and A. Goldberg. Personal dynamic media. IEEE Computer, 10(3), March 1977.

[23] B. W. Kernighan and R. Pike. The Unix Programming Environment. Prenti­ce-Hall, 1983.

[24] D. E. Knuth. TeX and Metafont: New Directions in Typesetting. Digital Press and American Mathematical Society, 1979.

[25] B. W. Lampson, editor. Alto User’s Handbook. Xerox Palo Alto Research Center, 1976.

[26] B. W. Lampson et al. A user machine in a time-sharing system. Proc. IEEE, 54(12):1744-1766, December 1966.

[27] B. W. Lampson and K. A. Pier. A processor for a high-performance personal computer. In Proc. 7th Symposium on Computer Architecture, pages 146-160, ACM SigArch/IEEE, May 1980.

[28] B. W. Lampson and D. D. Redell. Experience with processes and moni­tors in Mesa. Communications of the ACM, 23(2):105-117, February 1980.

[29] B. W. Lampson and R. F. Sproull. An open operating system for a sin­gle-user machine. ACM Operating Systems Review, 13(5), November 1979.

[30] H. C. Lauer and E. H. Satterthwaite. The impact of Mesa on system design. In Proc. 4th international Conference on Software Engineering, pages 174-182, September 1979.

[31] P. J. Leach et al. The architecture of an integrated local network. IEEE Journal on Selected Areas of Communication, SAC-1(5):842-856, November 1983.

[32] J. Licklider. Man-computer symbiosis. IRE Trans. Human Factors in Elec­tronics, HFE-1:4-11, March 1960.

[33] J. M. McQuillan and D. C. Walden. The Arpanet design decisions. Com­puter Networks, 1(5):243-289, September 1977.

[34] J. G. Mitchell and J. Dion. A comparison of two network-based file serv­ers. Communications of the ACM, 25(4):233-245, April 1982.

[35] J. S. Moore. The TXDT Package—Interlisp Text Editing Primitives. Technical Report CSL-81-2, Xerox Palo Alto Research Center, January 1981.

[36] R. M. Needham and A. J. Herbert. The Cambridge Distributed Computing System. Addison-Wesley, 1982.

[37] W. M. Newman and R. F. Sproull. Principles of Interactive Computer Graphics. McGraw-Hill, 2nd edition, 1979.

[38] D. D. Redell et al. Pilot: An operating system for a personal computer. Communications of the ACM, 23(2):81-92, February 1980.

[39] H. Rheingold. Tools for Thought. Simon and Schuster, 1985.

[40] M. Richards. bcpl: A tool for compiler writing and system program­ming. In Proc. AFIPS Conference, pages 557-566, 1969.

[41] M. D. Schroeder et al. A caching file system for a programmer’s work­station. ACM Operating Systems Review, 19(5), December 1985.

[42] J. F. Shoch and J. A. Hupp. Notes on the “worm” programs—some early experiences with a distributed computation. Communications of the ACM, 25(3):172-180, March 1982.

[43] D. C. Smith et al. The Star user interface: An overview. In Proc. AFIPS Conf., pages 515-528, 1982.

[44] R. F. Sproull. Introduction to Interpress. Xerox Printing Systems Division, 1984.

[45] R. F. Sproull. Raster graphics for interactive programming environ­ments. Computer Graphics, 3(3), July 1979.

[46] R. M. Stallman. EMACS: the extensible, customizable self-documenting display editor. In ACM SigPlan Notices, pages 147-156, June 1981.

[47] J. E. Stoy and C. Strachey. OS6—An experimental operating system for a small computer. Computer Journal, 15(2 and 3), May and August 1972.

[48] I. Sutherland. Sketchpad, a man-machine graphical communication system. In Proc. AFIPS Conference, pages 329-346, 1963.

[49] R. E. Sweet. The Mesa programming environment. SigPlan Notices, 20(7):216-229, July 1985.

[50] D. Swinehart et al. WFS: A simple shared file system for a distributed environment. ACM Operating Systems Review, 13(5), November 1979.

[51] D. C. Swinehart et al. The structure of Cedar. SigPlan Notices, 20(7):230-244, July 1985.

[52] W. Teitelman. A display-oriented programmer’s assistant. In Proc. 5th International Joint Conference on Artificial Intelligence, pages 905-917, 1977.

[53] W. Teitelman. A tour through Cedar. IEEE Software, 1(4), April 1984.

[54] W. Teitelman et al. Interlisp Reference Manual. Technical Report, Xerox Palo Alto Research Center, 1978.

[55] W. Teitelman and L. Masinter. The Interlisp programming environment. IEEE Computer, 14(4):25-34, April 1981.

[56] C. P. Thacker. Personal distributed computing; The Alto and Ethernet hardware. In ACM Conference on the History of Personal Workstations, January 1986.

[57] C. P. Thacker. SIL—A simple illustrator for CAD. In S. Chang, editor, Fundamentals Handbook of Electrical and Computer Engineering, Volume 3, pages 477-489, Wiley, 1983.

[58] C. P. Thacker et al. Alto: A personal computer. In Siewiorek et al., edi­tors, Computer Structures: Principles and Examples, chapter 33, McGraw-Hill, 1982. Also CSL-79-11, Xerox Palo Alto Research Center (1979).

[59] J. Warnock and D. K. Wyatt. A device independent graphics imaging model for use with raster devices. Computer Graphics, 6(3), July 1982.

[60] J. E. White and Y. K. Dalal. Higher-level protocols enhance Ethernet. Electronic Design, 30(8):31-41, April 1982.

1 This paper was presented at the ACM Conference on the History of Personal Workstations, Palo Alto, Jan. 1986. It appears in A History of Personal Workstations, ed. A. Goldberg, Addison-Wesley, 1988, pages 291-344. This version was made from the published version by scanning and OCR; it may have errors, and some slight changes have been made. Figures 2, 5 and 7 have been redrawn for clarity; the others are scanned. The 1972 memo describing the Alto project is at http://research.microsoft.com/lampson/38a-WhyAlto/Abstract.html.

Personal Distributed Computing: The Alto and Ethernet Software