Maclisp

From Wikipedia, the free encyclopedia
  (Redirected from MACLISP)
Jump to: navigation, search

MACLISP (or Maclisp, sometimes styled MacLisp or MacLISP) is a dialect of the Lisp programming language. It originated at MIT's Project MAC[1] (from which it derived its prefix) in the late 1960s and was based on Lisp 1.5.[2] Richard Greenblatt was the main developer of the original codebase for the PDP-6;[1] Jon L. White was responsible for its later maintenance and development. The name 'Maclisp' started being used in the early 1970s to distinguish it from other forks of PDP-6 Lisp, notably BBN Lisp.

History[edit]

Maclisp is a descendant of Lisp 1.5.[3] Maclisp departs from Lisp 1.5 by using a "value cell" to access and store the dynamic values of variables;[4] Lisp 1.5 used a linear search of an association list to determine a variable's value.[5] The Maclisp variable evaluation is faster but has different variable semantics. Maclisp also employed reader macros to make more readable input and output. Instead of entering (QUOTE A), one could enter 'A to get the same s-expression. Although both implementations put functions on the property list, Maclisp uses different syntax to define functions.[6] Maclisp also has a load-on-demand feature.[7]

Maclisp started on Digital Equipment Corporation PDP-6 and PDP-10 computers running the Incompatible Timesharing System (ITS); later it was ported to all other PDP-10 operating systems, for example, TOPS-10 and TOPS-20. The original implementation was in assembly language, but a later implemented on Multics used PL/I. Maclisp developed considerably in its lifetime. Major features[which?] were added which in other language systems would typically correspond to major release numbers.[dubious ]

Maclisp was used to implement the Macsyma symbolic algebra program; Macsyma's development also drove a number of features[which?] in Maclisp. The SHRDLU blocks-world program was written in Maclisp, and so the language was in widespread use in the artificial intelligence research community through the early 1980s. It was also used to implement other programming languages, such as Planner and Scheme. Multics Maclisp was used to implement the first Lisp-based Emacs.

Maclisp was an influential Lisp implementation, but is no longer actively maintained. It now runs on PDP-10 emulators and can be used for experimenting with early AI programs.

Characteristics[edit]

Maclisp started with a small, fixed number of data types: cons cell, atom (later called "symbol"), integer, and floating-point number. Later additions included: arrays, which were however never first-class data-types; arbitrary-precision integers (bignums); strings; and tuples. All objects (except inums) were implemented as pointers, and their data type was determined by the block of memory into which it pointed, with a special case for small numbers (inums).

Programs could be interpreted or compiled. Compiled behavior was the same as interpreted except that local variables were lexical by default in compiled code, and no error checking was done for inline operations such as CAR and CDR. The Ncomplr compiler (mid-1970s) introduced fast numeric support to the Lisp world, generating machine instructions for arithmetic rather than calling interpretive routines which dispatched on data type. This made Lisp arithmetic comparable in speed to Fortran for scalar operations (though Fortran array and loop implementation remained much better).

The original version was limited by the 18-bit word address of the PDP-10, and considerable effort was expended in keeping the implementation lean and simple. Multics Maclisp had a far larger address space, but was expensive to use. When the memory and processing power of the PDP-10 were exceeded, the Lisp Machine was invented: Lisp Machine Lisp is the direct descendant of Maclisp. Several other Lisp dialects were also in use, and the need to unify the community resulted in the modern Common Lisp language.

Name[edit]

MACLISP was named for Project MAC, and is unrelated to Apple's Macintosh ("Mac") computer, which it predates by decades. The various Lisp systems for the Macintosh have no particular similarity to Maclisp.[citation needed]

References[edit]

  1. ^ a b Levy, Steven (1984). Hackers: Heroes of the Computer Revolution. Doubleday. ISBN 0-385-19195-2. 
  2. ^ Project MAC Progress Report IV: July 1966 to July 1967 (PDF) (Report). n.d. p. 19. The higher-level language used for most of the vision laboratory program is the PDP-6 LISP System. This system is based chiefly on the LISP 1.5 programming language, but has been extensively modified in a number of ways. These include many new functions and services, including facilities for linking with programs written in other languages. 
  3. ^ Moon 1974 page 1
  4. ^ Moon 1974 page 47
  5. ^ Lisp 1.5 p. 13, evaluating an atom e in the environment a is done with (cdr (assoc e a)). That involves a linear search of the association list a. A more involved description with global constants and errors is given on p. 71; it does a linear search of the property list before searching the association list.
  6. ^ Maclisp uses defun; Lisp 1.5 uses define.
  7. ^ Moon 1974 p. 107; the autoload property.

External links[edit]


Timeline of Lisp dialects(edit)
1955 1960 1965 1970 1975 1980 1985 1990 1995 2000 2005 2010 2015
Lisp 1.5 Lisp 1.5
Maclisp Maclisp
Interlisp Interlisp
ZetaLisp Lisp Machine Lisp
Scheme Scheme
NIL NIL
Common Lisp Common Lisp
T T
Emacs Lisp Emacs Lisp
AutoLISP AutoLISP
ISLISP ISLISP
EuLisp EuLisp
Racket Racket
Arc Arc
Clojure Clojure
LFE LFE
Hy Hy