Symbolics Genera

Genera is a commercial operating system and integrated development environment for Lisp machines created 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 was also sold by Symbolics as Open Genera, which runs Genera on computers based on a Digital Equipment Corporation (DEC) Alpha processor using Tru64 UNIX. In 2021 a new version was released as Portable Genera which runs on DEC Alpha Tru64 UNIX, x86_64 and Arm64 Linux, x86_64 and Apple M1 macOS. It is released and licensed 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. 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
* means 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.

Genera operating system

Symbolics developed new Lisp machines and published the operating system under the name ''Genera''. The latest version is 8.5. Symbolics Genera was developed in the early 1980s and early 1990s. In the final years, development entailed mostly patches, with very little new function.

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 many features and supports all the versions of various hardware that Symbolics built over its life. 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 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 latest version is ''Portable Genera'', which has the virtual machine ported to x86_64, Arm64 and Apple M1 processors - additionally to the DEC Alpha processor. The virtual machine then runs under the Linux and macOS, additionally to Tru64 UNIX.

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''. This window system was introduced with Genera 7 in 1986. 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 monochrome (black and white) since that was what the hardware console typically provided. But extensive support exists for color, using color frame buffers or X Window System (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'' to control windows, switch applications, and operate the window system. Many features of the user interface (switching between activities, creating activities, stopping and 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 (GC): full GC, in-place GC, incremental GC, and ephemeral GC. The ephemeral collector uses only physical memory and uses the memory management unit to get information about changed pages in physical memory. The 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 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 (Lisp source is included in Genera distribution)
* Symbolics C, a version of C written in Lisp (Lisp source is included in Genera distribution)
* Symbolics Fortran, a version of Fortran written in Lisp (Lisp source is included in Genera distribution)

Symbolics Common Lisp provides most of the Common Lisp standard with very many extensions, many of them 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 more programming languages, such as OPS5, and development tools, such as 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

Other applications from Symbolics

Symbolics sold several applications that run on 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, digital image processing with a Pixar Image Computer
* Symbolics Statice, an object 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, including all low-level system code, such as device drivers, garbage collection, process scheduler, network stacks, etc.
* The source code is more than a million lines of Lisp, yet relatively compact, compared to the provided functions, due to extensive reuse. It is also available for users to inspect and change.
* 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
* There is little protection against changing the operating system. The whole system is fully accessible and changeable.

Limits

Genera's limits include:
* Only runs on Symbolics Lisp Machines or the Open Genera emulator.
* Only one user can be logged in at once.
* Only one Lisp system can run at once. Data and code is shared by applications and the operating system. However, multiple instances of Open Genera can run on one DEC Alpha.
* 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, introduces Symbolics Common Lisp, the Ephemeral Object Garbage Collector, and Document Examiner
* 1986 – Genera 7.0, introduces Dynamic Windows
* 1990 – Genera 8.0, introduces CLOS
* 1991 – Genera 8.1, introduces CLIM
* 1992 – Genera 8.2
* 1993 – Genera 8.3
* 1993 – Open Genera 1.0, introduces the Virtual Lisp Machine
* 1998 – Open Genera 2.0
* 2021 – Portable Genera 2.0, the Virtual Lisp Machine ported to additional platforms

A stable version of Open Genera that can run on x86-64 or arm64 Linux, and Apple M1 MacOS has been released.

A hacked version of Open Genera that can run on x86-64 Linux exists.

References

External links

*
*
Symbolics Genera Integrated Development Environment
*

*
"Genera Concepts"
web copy of Symbolics' introduction to Genera

Symbolics software documents at bitsavers.org






* ttps://www.youtube.com/watch?v=o4-YnLpLgtk "2013 Video Demonstration by Symbolics programmer Kalman Reti"

{{DEFAULTSORT:Genera (Operating System)
Common Lisp implementations
Common Lisp (programming language) software
Computing platforms
Integrated development environments
Lisp (programming language)-based operating systems
Object-oriented operating systems