Genera (operating system)

Genera

Company / developer	Symbolics
OS family	Lisp Machine OS
Initial release	1982
Latest stable release	8.5
Supported platforms	various Symbolics Lisp machines, DEC Alpha
Default user interface	Dynamic Windows
License	Proprietary
Official website	symbolics-dks.com

Genera is a commercial operating system and development environment for Lisp machines developed by Symbolics. It is essentially a fork of an earlier operating system originating on the MIT AI Lab's Lisp machines which Symbolics had used in common with LMI and Texas Instruments. Genera is also sold by Symbolics as Open Genera, which runs Genera on computers based on an Alpha processor using Tru64 UNIX. This software is available as proprietary software. However, older versions are available as free software.

Genera is an example of an operating system written in Lisp. It is an object-oriented operating system.

Genera supports incremental and interactive development of complex software using a mix of programming styles with extensive support for object-oriented programming.

MIT's Lisp Machine operating system

The Lisp Machine operating system was written in Lisp Machine Lisp. The Lisp Machine was a one-user workstation initially targeted at software developers for artificial intelligence projects.^[1] The Lisp Machine had a large bitmap screen, a mouse, a keyboard, a network interface, a disk drive and slots for expansion. The operating system was supporting this hardware. The Lisp Machine operating system provided (among others):

• code for a Frontend Processor
• a way to boot the operating system
• virtual memory management
• garbage collection
• drivers for the hardware (mouse, keyboard, screen, disk, …)
• an interpreter and a native code compiler for Lisp Machine Lisp
• an object system (Flavors)
• a window system and a window manager
• a local file system
• support for the CHAOS network
• an Emacs-like Editor named Zmacs
• a mail program named Zmail
• a Lisp listener
• a debugger

This was already a complete operating system and development environment for a Lisp-based one-user operating system.

The MIT Lisp Machine operating system has been developed from the middle 1970s to the early 1980s.

In 2006 the source code for this Lisp Machine operating system from MIT was released as open source.

Genera operating system

Symbolics developed new Lisp Machines and published the operating system under the name Genera. Genera 8.5 is the latest version. Symbolics Genera has been developed from the early 1980s to the early 1990s. In the recent years there were mostly patches developed and very little new functionality.

Symbolics developed Genera based on this foundation of the MIT Lisp machine operating system. It sells the operating system and layered software. Some of the layered software has been integrated into Genera in later releases. Symbolics improved the operating system software from the original MIT Lisp Machine and expanded it. The Genera operating system was only available for Symbolics Lisp Machines and the Open Genera virtual machine.

Symbolics Genera has a large number of features and supported all the versions of various hardware that Symbolics built over its lifetime. Its source code is more than a million lines of code (the number depends on the release and what amount of software is installed). Symbolics Genera was published on tape and CD-ROM. The release of the operating system also provided most of the source code of the operating system and its applications. The user has free access to all parts of the running operating system and can write changes and extensions. The source code of the operating system is divided into systems. These systems bundle sources, binaries and other files. The system construction toolkit (SCT) maintains the dependencies, the components and the versions of all the systems. A system has two numbers: a major and a minor version number. The major version number counts the number of full constructions of a system. The minor version counts the number of patches to that system. A patch is a file that can be loaded to fix problems or provide extensions to a particular version of a system.

Symbolics developed a Genera version, named Open Genera, that included a virtual machine that enabled executing Genera on DEC Alpha based workstations, plus several Genera extensions and applications that were sold separately (like the Symbolics S-Graphics suite). Also, they made a new operating system named Minima for embedded uses, in Common Lisp.

The original Lisp Machine operating system was developed in Lisp Machine Lisp, using the Flavors object-oriented extension to that Lisp. Symbolics provided a successor to Flavors named New Flavors. Later Symbolics also supported Common Lisp and the Common Lisp Object System. Then Symbolics Common Lisp became the default Lisp dialect for writing software with Genera. The software of the operating system was written mostly in Lisp Machine Lisp (named ZetaLisp) and Symbolics Common Lisp. These Lisp dialects are both provided by Genera. Also parts of the software was using either Flavors, New Flavors and Common Lisp Object System. Some of the older parts of the Genera operating system have been rewritten in Symbolics Common Lisp and the Common Lisp Object system. Many parts of the operating systems remained written in ZetaLisp and Flavors (or New Flavors).

User interface

The early versions of Symbolics Genera were built with the original windowing system of the Lisp Machine operating system. Symbolics then developed a radically new windowing system named Dynamic Windows with a presentation-based user interface.^[2] Many of the applications of Genera have then been using Dynamic Windows for their user interface. Eventually there was a move to port parts of the window system to run on other Common Lisp implementations by other vendors as the Common Lisp Interface Manager (CLIM). Versions of CLIM have been available (among others) for Allegro Common Lisp, LispWorks and Macintosh Common Lisp. An open source version is available (McCLIM).

Dynamic Windows uses typed objects for all output to the screen. All displayed information keeps its connection to the objects displayed (output recording). This works for both textual and graphical output. At runtime the applicable operations to these objects are computed based on the class hierarchy and the available operations (commands). Commands are organized in hierarchical command tables with typed parameters. Commands can be entered with the mouse, keystrokes and with a command line interface. All applications share one command line interpreter implementation, which adapts to various types of usage. The graphical capabilities of the window system are based on the PostScript graphics model.

The user interface is mostly in black-and-white (since that was what the hardware console typically provided). But there was also extensive support for color (using color frame buffers or X11 servers with color support). The activities (applications) are using the whole screen with several panes (though windows can also be smaller). The layout of these activity windows adapts to different screen sizes. Activities can also switch between different pane layouts.

Genera provides a system menu for controlling windows, switching applications and for window system operations. Many features of the user interface (switching between activities, creating activities, stopping/starting processes and much more) can also be controlled with keyboard commands.

The Dynamic Lisp Listener is an example of a command line interface with full graphics capabilities and support for mouse-based interaction. It accepts Lisp expressions and commands as input. The output is mouse sensitive. The Lisp listener can display forms to input data for the various built-in commands.

The user interface provides extensive online help and completion of choices in various contexts.

Documentation

Genera supports fully hyperlinked online documentation. The documentation is read with the Document Examiner, an early hypertext browser. The documentation is based on small reusable documentation records that can also be displayed in various contexts with the Editor and the Lisp Listener. The documentation is organized in books and sections. The books were also provided in printed versions with the same contents as the online documentation. The documentation database information is delivered with Genera and can be modified with incremental patches.

The documentation was created with a separate application that was not shipped with Genera: Symbolics Concordia. Concordia provides an extension to the Zmacs editor for editing documentation records, a graphics editor and a page previewer.

The documentation provides user guides, installation guidelines and references of the various Lisp constructs and libraries.

The markup language is based on the Scribe markup language and also usable by the developer.

Genera supports printing to postscript printers, provides a printing queue and also a PostScript interpreter (written in Lisp).

Features

Genera also has support for various network protocols and applications using those. It has extensive support for TCP/IP.

Genera supports one-processor machines with several threads (called processes).

Genera supports several different types of garbage collection: full Garbage Collection, in-place Garbage Collection, Incremental Garbage Collection and Ephemeral Garbage Collection. The Ephemeral Garbage Collector only uses physical memory and uses the memory management unit to get information about changed pages in physical memory. The garbage collector uses generations and the virtual memory is divided into areas. Areas can contain objects of certain types (strings, bitmaps, pathnames, ...) and each area can use different memory management mechanisms.

Genera implements two file systems: the FEP file system for large files and the LMFS (Lisp Machine File System, optimized for many small files). These file systems also maintain different versions of files. If a file is modified, Genera still keeps the old versions. Genera also provides access to other (local and remote) file systems: NFS, FTP, HFS, CDROMs and others. Genera also can read from and write to and tape drives.

Genera supports netbooting.

Genera provides a client for the Statice object-oriented database from Symbolics.

Genera makes extensive use of the condition system (exception handling) to handle all kinds of runtime errors and is able to recover from many of these errors. It allows for example to retry network operations in case a network connection has a failure - the application code will continue to run. In case of errors the user will be presented a menu of restarts (abort, retry, continue options) that are specific to the error signalled.

Genera has extensive debugging tools.

Genera can save versions of the running system to worlds. These worlds can be booted and then will contain all the saved data and code.

Programming languages

Symbolics provided several programming languages for use with Genera:

• ZetaLisp, the Symbolics version of Lisp Machine Lisp
• Common Lisp in several versions: Symbolics Common Lisp, Future Common Lisp (ANSI Common Lisp), CLtL1
• Symbolics Pascal, a version of Pascal written in Lisp
• Symbolics C, a version of C written in Lisp
• Symbolics Fortran, a version of Fortran written in Lisp

Symbolics Common Lisp provides most of the Common Lisp standard with a huge number of extensions (many of those coming from ZetaLisp).

Other languages from Symbolics

• Symbolics Prolog, a version of Prolog written and integrated in Lisp
• Symbolics Ada, a version of Ada written in Lisp

It is remarkable that these programming language implementations inherited some of the dynamic features of the Lisp system (like garbage collection and checked access to data) and supported incremental software development.

Third-party developers provided additional programming languages (like OPS5) and development tools (like the Knowledge Engineering Environment, KEE, from Intellicorp).

Applications

Symbolics Genera comes with several applications. Applications are called activities. Some of the activities:

• Zmacs, an Emacs-like text editor
• Zmail, a mail reader also providing a calendar
• File system browser with tools for file system maintenance
• Lisp Listener with command line interface
• Document Examiner for browsing documentation
• Restore Distribution to install software.
• Distribute Systems, to create software distributions
• Peek to examine system information (processes, windows, network connections, ...)
• Debugger
• Namespace Editor to access informations about objects in the network (users, computers, file systems, ...)
• Converse, a chat client
• Terminal
• Inspector, for browsing Lisp data structures
• Notifications
• Frame-Up, for designing user interfaces
• Flavor Examiner, to examine the classes and methods of the Flavor object-oriented extension to Lisp

The Symbolics Museum from Ralf Möller provides screenshots of those of these activities.

Other applications from Symbolics

Symbolics sold several applications that were running on top of Symbolics Genera.

• Symbolics Concordia, a document production suite
• Symbolics Joshua, an expert system shell
• Symbolics Macsyma, a computer algebra system
• Symbolics NS, a chip design tool
• Symbolics Plexi, a neural network development tool
• Symbolics S-Graphics, a suite of tools: S-Paint, S-Geometry, S-Dynamics, S-Render
• Symbolics S-Utilities: S-Record, S-Compositor, S-Colorize, S-Convert
• Symbolics Scope, Image processing with a Pixar Image Computer
• Symbolics Statice, an object-oriented database

Third-party applications

Several companies developed and sold applications for Symbolics Genera. Some Examples:

• ART (Automated Reasoning Tool), an expert system shell from Inference Corporation
• iCad, 3d parametric CAD system
• Illustrate, graphics editor
• KEE (Knowledge Engineering Environment), an expert system shell, from IntelliCorp
• Knowledge Craft, an expert system shell, from Carnegie Group
• Metal, machine translation system from Siemens

Highlights

• Genera is written completely in Lisp (using Zeta Lisp and Symbolics Common Lisp)
• Even all the low-level system code is written in Lisp (device drivers, garbage collection, process scheduler, network stacks, etc.)
• The source code is more than a million lines of Lisp and available for the user to be inspected and changed. The source is relatively compact, compared to the provided functionality, due to extensive reuse
• The operating system is mostly written in an object-oriented style using Flavors, New Flavors and CLOS
• It has extensive online documentation readable with the Document Examiner
• Dynamic Windows provides a presentation-based user interface
• The user interface can be used locally (on Lisp Machines and MacIvories) and remotely (using X11)
• Groups of developers can work together in a networked environment
• A central Namespace Server provides a directory of machines, users, services, networks, file systems, databases and more

Limitations

• Genera only runs on Symbolics Lisp Machines or the Open Genera emulator.
• Genera supports only one user logged in at any time.
• There is only one Lisp system running at any time. Data and code is shared by applications and the operating system. (Though one can run multiple instances of Open Genera on one DEC Alpha).
• There is mostly no protection against changing the operating system. The whole system is fully accessible and changeable.
• Development effectively stopped in the middle 1990s.

Releases

• 1982 - Release 78
• 1982 - Release 210
• 1983 - Release 4.0
• 1984 - Release 5.0
• 1985 - Release 6.0, introduction of Symbolics Common Lisp, the Ephemeral Object Garbage Collector and the Document Examiner
• 1986 - Genera 7.0
• 1990 - Genera 8.0, introduction of CLOS
• 1991 - Genera 8.1, introduction of CLIM
• 1992 - Genera 8.2
• 1993 - Genera 8.3
• 1993 - Open Genera 1.0
• 1998 - Open Genera 2.0

An experimental version of Open Genera that can run on x86-64 Linux exists.^[3][4]

References

1. ^ "A Lisp Machine". Proceedings of the fifth workshop on Computer architecture for non-numeric processing (Association for Computing Machinery - Special Interest Group on Information Retrieval). 1980. doi:10.1145/800083.802703. 
2. ^ Ciccarelli, Eugene C. (August 1, 1984). "Presentation Based User Interface". DSpace@MIT. http://dspace.mit.edu/handle/1721.1/6946. 
3. ^ Wiegley, John (October 23, 2007). "The Symbolics Lisp Machine on Linux". Advogato. http://www.advogato.org/person/johnw/diary/12.html. 
4. ^ Collison, Patrick (April, 2008). "Lisp Machines". http://collison.ie/blog/2008/04/lisp-machines. 

External links

• Symbolics
  • Symbolics Genera Integrated Development Environment
  • "Symbolics Technical Summary"
  • "Genera Concepts" web copy of Symbolic's introduction to Genera
• Symbolics software documents at bitsavers.org
• A page of screenshots of Genera
• Screenshots of the award-winning Symbolics Document Examiner
• "The Symbolics Virtual Lisp Machine, Or, Using The Dec Alpha As A Programmable Micro-engine"