*Lisp

Last updated
*Lisp (StarLisp)
Paradigms Multi-paradigm: functional, procedural, reflective, meta, parallel
Family Lisp
Designed by Cliff Lasser, Steve Omohundro
Developer Thinking Machines Corporation
First appeared1986;37 years ago (1986)
Typing discipline Dynamic, strong
Scope Static, lexical
Implementation language Common Lisp
Platform Connection Machine
OS Connection Machine
Influenced by
Lisp, Common Lisp
Influenced
C*

*Lisp (or StarLisp) is a programming language, a dialect of the language Lisp. [1] It was conceived of in 1985 by two employees of the Thinking Machines Corporation, Cliff Lasser and Steve Omohundro, as a way to provide an efficient yet high-level language for programming the nascent Connection Machine (CM).

Contents

History

Prelude

At the time the Connection Machine was being designed and built, the only language being actively developed for it was an assembly-level language named PARIS (Parallel Instruction Set). It became evident that a better way to program the machine was needed, and quickly. Waiting for the completion of Connection Machine Lisp (CM Lisp), an implementation of the very high-level programming language Lisp with parallel computing extensions) was not an option. CM Lisp had been proposed by Danny Hillis, and development was expected to continue for several more years.

Development

A *Lisp interpreter was initially developed. It became apparent quickly that a *Lisp compiler, translating *Lisp into Lisp and PARIS, would be needed to attain the gigaFLOPS speed that was attainable in theory by a Connection Machine. The *Lisp compiler was written by Jeff Mincy and was first released in 1986. An application achieving more than two gigaFLOPS, a helicopter wake simulator, was developed by Alan Egolf, then an employee of United Technologies, and J. P. Massar, a Thinking Machines employee, in 1987. [2]

A *Lisp Simulator, an emulator meant to run *Lisp code on standard, non-parallel machines, was developed at the same time by J. P. Massar. This simulator still exists, [3] and was ported to American National Standards Institute (ANSI) Common Lisp (CL) in 2001. An older version written in the original CL, exists in the Carnegie Mellon University (CMU) artificial intelligence (AI) repository. [4]

Later versions of *Lisp, involving significant upgrades to its functions and performance, were worked on by Cliff Lasser, Jeff Mincy, and J. P. Massar through 1989. *Lisp was implemented on the Thinking Machines CM5 circa 1990–1991 by J. P. Massar and Mario Bourgoin.

19551960196519701975198019851990199520002005201020152020
 LISP 1, 1.5, LISP 2(abandoned)
  Maclisp
  Interlisp
  MDL
  Lisp Machine Lisp
  Scheme  R5RS R6RS R7RS small
  NIL
  ZIL (Zork Implementation Language)
  Franz Lisp
  Common Lisp  ANSI standard
  Le Lisp
  MIT Scheme
  T
  Chez Scheme
  Emacs Lisp
  AutoLISP
  PicoLisp
  Gambit
  EuLisp
  ISLISP
  OpenLisp
  PLT Scheme   Racket
  GNU Guile
  Visual LISP
  Clojure
  Arc
  LFE
  Hy

Implementation

StarLisp was written on Common Lisp (CL), and thus had the full power of CL behind it. To use a Connection Machine, one needed a host or front-end. To use *Lisp, that front-end had to run CL. Symbolics' machines using Genera and Sun Microsystems workstations running Lucid Inc.'s Lucid Common Lisp were both used to operate *Lisp.

StarLisp operated on Parallel Variables (PVARS). These represented Connection Machine memory, and were essentially vectors: one element per CM processor (or virtual processor).

StarLisp consisted of standard operations on PVARS, like vector addition and multiplication, along with communication primitives that essentially reordered the elements of a PVAR using the CM's communication hardware to optimally route the data.

Related Research Articles

In computing, a compiler is a computer program that translates computer code written in one programming language into another language. The name "compiler" is primarily used for programs that translate source code from a high-level programming language to a low-level programming language to create an executable program.

<span class="mw-page-title-main">Common Lisp</span> Programming language standard

Common Lisp (CL) is a dialect of the Lisp programming language, published in ANSI standard document ANSI INCITS 226-1994 (S20018). The Common Lisp HyperSpec, a hyperlinked HTML version, has been derived from the ANSI Common Lisp standard.

<span class="mw-page-title-main">Lisp (programming language)</span> Programming language family

Lisp is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation. Originally specified in 1960, Lisp is the second-oldest high-level programming language still in common use, after Fortran. Lisp has changed since its early days, and many dialects have existed over its history. Today, the best-known general-purpose Lisp dialects are Common Lisp, Scheme, Racket and Clojure.

Symbolics, Inc., was a privately held American computer manufacturer that acquired the assets of the former company and continues to sell and maintain the Open Genera Lisp system and the Macsyma computer algebra system.

Kent M. Pitman (KMP) is a programmer who has been involved for many years in the design, implementation, and use of systems based on the programming languages Lisp and Scheme. Since 2010, he has been President of HyperMeta, Inc.

<span class="mw-page-title-main">Connection Machine</span>

A Connection Machine (CM) is a member of a series of massively parallel supercomputers that grew out of doctoral research on alternatives to the traditional von Neumann architecture of computers by Danny Hillis at Massachusetts Institute of Technology (MIT) in the early 1980s. Starting with CM-1, the machines were intended originally for applications in artificial intelligence (AI) and symbolic processing, but later versions found greater success in the field of computational science.

Thinking Machines Corporation was a supercomputer manufacturer and artificial intelligence (AI) company, founded in Waltham, Massachusetts, in 1983 by Sheryl Handler and W. Daniel "Danny" Hillis to turn Hillis's doctoral work at the Massachusetts Institute of Technology (MIT) on massively parallel computing architectures into a commercial product named the Connection Machine. The company moved in 1984 from Waltham to Kendall Square in Cambridge, Massachusetts, close to the MIT AI Lab. Thinking Machines made some of the most powerful supercomputers of the time, and by 1993 the four fastest computers in the world were Connection Machines. The firm filed for bankruptcy in 1994; its hardware and parallel computing software divisions were acquired in time by Sun Microsystems.

<span class="mw-page-title-main">Guy L. Steele Jr.</span> American computer scientist (born 1954)

Guy Lewis Steele Jr. is an American computer scientist who has played an important role in designing and documenting several computer programming languages and technical standards.

OPS5 is a rule-based or production system computer language, notable as the first such language to be used in a successful expert system, the R1/XCON system used to configure VAX computers.

<span class="mw-page-title-main">Scott Fahlman</span> American computer scientist

Scott Elliott Fahlman is a computer scientist and Professor Emeritus at Carnegie Mellon University's Language Technologies Institute and Computer Science Department. He is notable for early work on automated planning and scheduling in a blocks world, on semantic networks, on neural networks, on the programming languages Dylan, and Common Lisp, and he was one of the founders of Lucid Inc. During the period when it was standardized, he was recognized as "the leader of Common Lisp." From 2006 to 2015, Fahlman was engaged in developing a knowledge base named Scone, based in part on his thesis work on the NETL Semantic Network. He also is credited with coining the use of the emoticon :-).

CMUCL is a free Common Lisp implementation, originally developed at Carnegie Mellon University.

C* is an object-oriented, data-parallel superset of ANSI C with synchronous semantics.

<span class="mw-page-title-main">Copycat (software)</span>

Copycat is a model of analogy making and human cognition based on the concept of the parallel terraced scan, developed in 1988 by Douglas Hofstadter, Melanie Mitchell, and others at the Center for Research on Concepts and Cognition, Indiana University Bloomington. The original Copycat was written in Common Lisp and is bitrotten ; however, Java and Python ports exist. The latest version in 2018 is a Python3 port by Lucas Saldyt and J. Alan Brogan.

Hemlock is a free Emacs text editor for most POSIX-compliant Unix systems. It follows the tradition of the Lisp Machine editor ZWEI and the ITS/TOPS-20 implementation of Emacs, but differs from XEmacs or GNU Emacs, the most popular Emacs variants, in that it is written in Common Lisp rather than Emacs Lisp and C—although it borrows features from the later editors. Hemlock was originally written by the CMU Spice project in Spice Lisp for the PERQ computer.

Dylan programming language history first introduces the history with a continuous text. The second section gives a timeline overview of the history and present several milestones and watersheds. The third section presents quotations related to the history of the Dylan programming language.

<span class="mw-page-title-main">Common Lisp Interface Manager</span>

The Common Lisp Interface Manager (CLIM) is a Common Lisp-based programming interface for creating user interfaces, i.e., graphical user interfaces (GUIs). It provides an application programming interface (API) to user interface facilities for the programming language Lisp. It is a fully object-oriented programming user interface management system, using the Common Lisp Object System (CLOS) and is based on the mechanism of stream input and output. There are also facilities for output device independence. It is descended from the GUI system Dynamic Windows of Symbolics' Lisp machines between 1988 and 1993.

... you can check out Common Lisp Interface Manager (CLIM). A descendant of the Symbolics Lisp machines GUI framework, CLIM is powerful but complex. Although many commercial Common Lisp implementations actually support it, it doesn't seem to have seen a lot of use. But in the past couple years, an open-source implementation of CLIM, McCLIM – now hosted at Common-Lisp.net – has been picking up steam lately, so we may be on the verge of a CLIM renaissance. – From Practical Common Lisp

CMU Sphinx, also called Sphinx for short, is the general term to describe a group of speech recognition systems developed at Carnegie Mellon University. These include a series of speech recognizers and an acoustic model trainer (SphinxTrain).

<span class="mw-page-title-main">SLIME</span>

SLIME, the Superior Lisp Interaction Mode for Emacs, is an Emacs mode for developing Common Lisp applications. SLIME originates in an Emacs mode called SLIM written by Eric Marsden. It is developed as an open-source public domain software project by Luke Gorrie and Helmut Eller. Over 100 Lisp developers have contributed code to SLIME since the project was started in 2003. SLIME uses a backend called Swank that is loaded into Common Lisp.

Spice Lisp is a programming language, a dialect of Lisp. Its implementation, originally written by Carnegie Mellon University's (CMU) Spice Lisp Group, targeted the microcode of the 16-bit workstation PERQ, and its operating system Accent. It used that workstation's microcode abilities to implement a stack machine architecture to store its data structures as 32-bit objects and to enable run time type-checking. It would later be popular on other workstations.

VAX LISP was an implementation of Common Lisp for VMS and ULTRIX on 32-bit VAXs. It was the first Common Lisp to be written for non-Lisp machines. It was initially boot-strapped from Carnegie Mellon University's Spice Lisp by recompiling its output but for VAX machine instruction and to use the large VAX stack. Some of the original developers came from CMU.

References

  1. McJones, Paul (2015-04-19). "Parallel Lisps: Connection Machine *Lisp (StarLisp)". Computer History Museum. Retrieved 2018-12-29.
  2. Helicopter Free Wake Implementation On Advanced Computer Architectures , International Conference on Basic Rotorcraft Research, 1988.
  3. "Franz Inc". Franz Inc. Archived from the original on 2005-03-06. Retrieved 2005-06-26.
  4. Massar, J. P. (13 February 1995). "STARSIM: Thinking Machines' *Lisp Simulator". Carnegie Mellon University (CMU) Artificial Intelligence Repository. Retrieved 2018-12-29.