Fdtxjr

Genera

Developer	Symbolics
Written in	Lisp
OS family	Lisp machine OS
Working state	Discontinued
Source model	Closed-source, open-source
Initial release	1982; 37 years ago (1982)
Final release	Open Genera 2.0 / 1998; 21 years ago (1998)
Available in	English
Platforms	various Symbolics Lisp machines, DEC Alpha
Default user interface	Dynamic Windows GUI
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 Massachusetts Institute of Technology (MIT) AI Lab's Lisp machines which Symbolics had used in common with Lisp Machines, Inc. (LMI), and Texas Instruments (TI). Genera is also sold by Symbolics as Open Genera, which runs Genera on computers based on an Alpha processor using Tru64 UNIX. It is available as proprietary software.

Genera is an example of an object-oriented operating system based on the programming language Lisp.

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. It was a one-user workstation initially targeted at software developers for artificial intelligence (AI) projects.^[1] The system 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 and it provided (among others):

• code for a frontend processor


• a way to boot the operating system


• virtual memory management


• garbage collection


• interface to various hardware: mouse, keyboard, bitmap frame buffer, disk, printer, network interface


• an interpreter and a native code compiler for Lisp Machine Lisp


• an object system: Flavors
  


• a graphical user interface (GUI) window system and window manager
  


• a local file system
  


• support for the Chaosnet (CHAOS) network


• an Emacs-like Editor named Zmacs
  


• a mail program named Zmail


• a Lisp listener


• a debugger
  

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

The MIT Lisp machine operating system was 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 free and open-source software.^[2]

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 was developed in the early 1980s and early 1990s. In the final years, development entailed mostly patches, with 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 (the number depends on the release and what amount of software is installed). Symbolics Genera was published on magnetic 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 (CLOS). 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 graphical user interface (GUI) 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.^[3] This window system was introduced with Genera 7 in 1986.^[4] 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 (making extensive use of mouse chording), keystrokes, and with a command line interface. All applications share one command line interpreter implementation, which adapts to various types of usage. The graphical abilities 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) use 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 abilities 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 context sensitive help, 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 Lisp Machine File System (LMFS) optimized for many small files. These systems also maintain different versions of files. If a file is modified, Genera still keeps the old versions. Genera also provides access to, can read from and write to, other, local and remote, file systems including: NFS, FTP, HFS, CD-ROMs, 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. For example, it allows retrying network operations if a network connection has a failure – the application code will keep running. When errors occur, users are 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^{[citation needed]}


• Symbolics C, a version of C written in Lisp^{[citation needed]}


• Symbolics Fortran, a version of Fortran written in Lisp^{[citation needed]}

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 information 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:

• Automated Reasoning Tool (ART), an expert system shell from Inference Corporation


• 
  ICAD, 3d parametric CAD system


• Illustrate, graphics editor


• 
  Knowledge Engineering Environment (KEE), 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 fully in Lisp, using ZetaLisp 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 users to inspect and change. 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

Limits

• 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, introduce Symbolics Common Lisp, the Ephemeral Object Garbage Collector, and Document Examiner


• 1986 – Genera 7.0, introduce Dynamic Windows


• 1990 – Genera 8.0, introduce CLOS


• 1991 – Genera 8.1, introduce 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.^[5][6]

References

External links

• 
  Official website
  • Symbolics Genera Integrated Development Environment
  
  
  • "Symbolics Technical Summary"
  
  
  • 
    "Genera Concepts" web copy of Symbolics' 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"


• "2013 Video Demonstration by Symbolics programmer Kalman Reti"