Misplaced Pages

#745254

83-708: Lisp machines are general-purpose computers designed to efficiently run Lisp as their main software and programming language , usually via hardware support. They are an example of a high-level language computer architecture . In a sense, they were the first commercial single-user workstations . Despite being modest in number (perhaps 7,000 units total as of 1988) Lisp machines commercially pioneered many now-commonplace technologies, including effective garbage collection , laser printing , windowing systems , computer mice , high-resolution bit-mapped raster graphics , computer graphic rendering, and networking innovations such as Chaosnet . Several firms built and sold Lisp machines in

166-487: A tagged architecture is a type of computer architecture where every word of memory constitutes a tagged union , being divided into a number of bits of data, and a tag section that describes the type of the data: how it is to be interpreted, and, if it is a reference, the type of the object that it points to. Some early systems use tagging of data in memory but do not have all of the characteristics now consider to be part of tagged architectures. The RCA 601 has

249-414: A 24-bit tagged architecture . The machine also did incremental (or Arena ) garbage collection . More specifically, since Lisp variables are typed at runtime rather than compile time, a simple addition of two variables could take five times as long on conventional hardware, due to test and branch instructions. Lisp Machines ran the tests in parallel with the more conventional single instruction additions. If

332-516: A 3-bit tag register and a 3-bit tag for every 24-bit half-word. Every instruction can request a test for equal or unequal tag, and cause a maskable interrupt if the specified match fails. There is no architectural connection between the tag and the contents of the half-word; it is strictly determined by the software. The Burroughs B5000 , B5500 and B5700 have 48-bit words with no appended tag field. However, while there are no tag fields for character, instruction or numeric (floating point) words, all of

415-906: A UK firm, Racal-Norsk, a joint subsidiary of Racal and Norsk Data , attempted to repurpose Norsk Data's ND-500 supermini as a microcoded Lisp machine, running CADR software: the Knowledge Processing System (KPS). There were several attempts by Japanese manufacturers to enter the Lisp machine market: the Fujitsu Facom-alpha mainframe co-processor, NTT's Elis, Toshiba's AI processor (AIP) and NEC's LIME. Several university research efforts produced working prototypes, among them are Kobe University's TAKITAC-7, RIKEN's FLATS, and Osaka University's EVLIS. In France, two Lisp Machine projects arose: M3L at Toulouse Paul Sabatier University and later MAIA. In Germany Siemens designed

498-547: A bright commercial future due to the strength of the Lisp language and the enabling factor of hardware acceleration, proposed to Greenblatt that they commercialize the technology. In a counter-intuitive move for an AI Lab hacker, Greenblatt acquiesced, hoping perhaps that he could recreate the informal and productive atmosphere of the Lab in a real business. These ideas and goals were considerably different from those of Noftsker. The two negotiated at length, but neither would compromise. As

581-550: A commercial venture fund-backed firm had a better chance of surviving and commercializing Lisp machines than Greenblatt's proposed self-sustaining start-up. Greenblatt lost the battle. It was at this juncture that Symbolics , Noftsker's enterprise, slowly came together. While Noftsker was paying his staff a salary, he had no building or any equipment for the hackers to work on. He bargained with Patrick Winston that, in exchange for allowing Symbolics' staff to keep working out of MIT, Symbolics would let MIT use internally and freely all

664-536: A decade earlier than Common Lisp, Scheme is a more minimalist design. It has a much smaller set of standard features but with certain implementation features (such as tail-call optimization and full continuations ) not specified in Common Lisp. A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme. Scheme continues to evolve with

747-407: A flexible and powerful form of dynamic dispatch . It has served as the template for many subsequent Lisp (including Scheme ) object systems, which are often implemented via a metaobject protocol , a reflective meta-circular design in which the object system is defined in terms of itself: Lisp was only the second language after Smalltalk (and is still one of the very few languages) to possess such

830-453: A function that counts the number of elements of a list for which a predicate returns true . The disassembled machine code for above function (for the Ivory microprocessor from Symbolics): The operating system used virtual memory to provide a large address space. Memory management was done with garbage collection. All code shared a single address space . All data objects were stored with

913-624: A great compliment because it transmits the full flavour of liberation: it has assisted a number of our most gifted fellow humans in thinking previously impossible thoughts. Largely because of its resource requirements with respect to early computing hardware (including early microprocessors), Lisp did not become as popular outside of the AI community as Fortran and the ALGOL -descended C language. Because of its suitability to complex and dynamic applications, Lisp enjoyed some resurgence of popular interest in

SECTION 10

#1732781047746

996-460: A language others considered antiquated. New Lisp programmers often describe the language as an eye-opening experience and claim to be substantially more productive than in other languages. This increase in awareness may be contrasted to the " AI winter " and Lisp's brief gain in the mid-1990s. As of 2010 , there were eleven actively maintained Common Lisp implementations. The open source community has created new supporting infrastructure: CLiki

1079-529: A list, so the expression evaluates to the list ( 1 2 foo ) . The "quote" before the foo in the preceding example is a "special operator" which returns its argument without evaluating it. Any unquoted expressions are recursively evaluated before the enclosing expression is evaluated. For example, evaluates to the list ( 1 2 ( 3 4 )) . The third argument is a list; lists can be nested. Arithmetic operators are treated similarly. The expression Tagged architecture In computer science ,

1162-445: A metaobject system. Many years later, Alan Kay suggested that as a result of the confluence of these features, only Smalltalk and Lisp could be regarded as properly conceived object-oriented programming systems. Lisp introduced the concept of automatic garbage collection , in which the system walks the heap looking for unused memory. Progress in modern sophisticated garbage collection algorithms such as generational garbage collection

1245-592: A paper in Communications of the ACM in April 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I". He showed that with a few simple operators and a notation for anonymous functions borrowed from Church, one can build a Turing-complete language for algorithms. Information Processing Language was the first AI language, from 1955 or 1956, and already included many of

1328-764: A series of standards (Revised Report on the Algorithmic Language Scheme) and a series of Scheme Requests for Implementation . Clojure is a dialect of Lisp that targets mainly the Java virtual machine , and the Common Language Runtime (CLR), the Python VM, the Ruby VM YARV , and compiling to JavaScript . It is designed to be a pragmatic general-purpose language. Clojure draws considerable influences from Haskell and places

1411-515: A single language. The new language, Common Lisp , was somewhat compatible with the dialects it replaced (the book Common Lisp the Language notes the compatibility of various constructs). In 1994, ANSI published the Common Lisp standard, "ANSI X3.226-1994 Information Technology Programming Language Common Lisp". Since inception, Lisp was closely connected with the artificial intelligence research community, especially on PDP-10 systems. Lisp

1494-437: A standard data structure—a quality much later dubbed " homoiconicity ". Thus, Lisp functions can be manipulated, altered or even created within a Lisp program without lower-level manipulations. This is generally considered one of the main advantages of the language with regard to its expressive power, and makes the language suitable for syntactic macros and meta-circular evaluation . A conditional using an if–then–else syntax

1577-492: A tag in memory, so that the type could be determined at runtime. Multiple execution threads were supported and termed processes . All processes ran in the one address space. All operating system software was written in Lisp. Xerox used Interlisp. Symbolics, LMI, and TI used Lisp Machine Lisp (descendant of MacLisp). With the appearance of Common Lisp, Common Lisp was supported on the Lisp Machines and some system software

1660-408: A version of Interlisp . It was never marketed. Frustrated, the whole AI group resigned, and were hired mostly by Xerox. So, Xerox Palo Alto Research Center had, simultaneously with Greenblatt's own development at MIT, developed their own Lisp machines which were designed to run InterLisp (and later Common Lisp ). The same hardware was used with different software also as Smalltalk machines and as

1743-427: A very strong emphasis on immutability. Clojure provides access to Java frameworks and libraries, with optional type hints and type inference , so that calls to Java can avoid reflection and enable fast primitive operations. Clojure is not designed to be backwards compatible with other Lisp dialects. Further, Lisp dialects are used as scripting languages in many applications, with the best-known being Emacs Lisp in

SECTION 20

#1732781047746

1826-529: A year's head start , and by severe delays in procuring venture capital. Symbolics still had the major advantage that while 3 or 4 of the AI Lab hackers had gone to work for Greenblatt, a solid 14 other hackers had signed onto Symbolics. Two AI Lab people were not hired by either: Richard Stallman and Marvin Minsky . Stallman, however, blamed Symbolics for the decline of the hacker community that had centered around

1909-834: Is a weekly news service, Weekly Lisp News . Common-lisp.net is a hosting site for open source Common Lisp projects. Quicklisp is a library manager for Common Lisp. Fifty years of Lisp (1958–2008) was celebrated at LISP50@OOPSLA. There are regular local user meetings in Boston, Vancouver, and Hamburg. Other events include the European Common Lisp Meeting, the European Lisp Symposium and an International Lisp Conference. The Scheme community actively maintains over twenty implementations . Several significant new implementations (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) have been developed in

1992-530: Is a wiki that collects Common Lisp related information, the Common Lisp directory lists resources, #lisp is a popular IRC channel and allows the sharing and commenting of code snippets (with support by lisppaste , an IRC bot written in Lisp), Planet Lisp collects the contents of various Lisp-related blogs, on LispForum users discuss Lisp topics, Lispjobs is a service for announcing job offers and there

2075-570: Is implemented in Femtolisp, a dialect of Scheme (Julia is inspired by Scheme, which in turn is a Lisp dialect). In October 2019, Paul Graham released a specification for Bel , "a new dialect of Lisp." Common Lisp and Scheme represent two major streams of Lisp development. These languages embody significantly different design choices. Common Lisp is a successor to Maclisp . The primary influences were Lisp Machine Lisp , Maclisp, NIL , S-1 Lisp , Spice Lisp , and Scheme. It has many of

2158-480: Is intended for reading, not for computing. But he went ahead and did it. That is, he compiled the eval in my paper into IBM 704 machine code, fixing bugs , and then advertised this as a Lisp interpreter, which it certainly was. So at that point Lisp had essentially the form that it has today ... The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, "evaluate Lisp expressions". Two assembly language macros for

2241-517: Is written as s-expressions , or parenthesized lists. A function call or syntactic form is written as a list with the function or operator's name first, and the arguments following; for instance, a function f that takes three arguments would be called as ( f arg1 arg2 arg3 ) . John McCarthy began developing Lisp in 1958 while he was at the Massachusetts Institute of Technology (MIT). McCarthy published its design in

2324-406: Is written with its elements separated by whitespace , and surrounded by parentheses. For example, ( 1 2 foo ) is a list whose elements are the three atoms 1 , 2 , and foo . These values are implicitly typed: they are respectively two integers and a Lisp-specific data type called a "symbol", and do not have to be declared as such. The empty list () is also represented as

2407-709: The Emacs editor, AutoLISP and later Visual Lisp in AutoCAD , Nyquist in Audacity , and Scheme in LilyPond . The potential small size of a useful Scheme interpreter makes it particularly popular for embedded scripting. Examples include SIOD and TinyScheme , both of which have been successfully embedded in the GIMP image processor under the generic name "Script-fu". LIBREP, a Lisp interpreter by John Harper originally based on

2490-547: The Emacs Lisp language, has been embedded in the Sawfish window manager . Lisp has officially standardized dialects: R6RS Scheme , R7RS Scheme , IEEE Scheme, ANSI Common Lisp and ISO ISLISP . Paul Graham identifies nine important aspects of Lisp that distinguished it from existing languages like Fortran : Lisp was the first language where the structure of program code is represented faithfully and directly in

2573-567: The IBM 704 became the primitive operations for decomposing lists: car ( Contents of the Address part of Register number) and cdr ( Contents of the Decrement part of Register number), where "register" refers to registers of the computer's central processing unit (CPU). Lisp dialects still use car and cdr ( / k ɑːr / and / ˈ k ʊ d ər / ) for the operations that return

Lisp machine - Misplaced Pages Continue

2656-547: The LLVM , the Java virtual machine , x86-64, PowerPC, Alpha, ARM, Motorola 68000, and MIPS, and operating systems such as Windows, macOS, Linux, Solaris, FreeBSD, NetBSD, OpenBSD, Dragonfly BSD, and Heroku. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy L. Steele, Jr. and Gerald Jay Sussman . It was designed to have exceptionally clear and simple semantics and few different ways to form expressions. Designed about

2739-717: The TI Explorer . Some of the LMI-LAMBDAs and the TI Explorer were dual systems with both a Lisp and a Unix processor. TI also developed a 32-bit microprocessor version of its Lisp CPU for the TI Explorer. This Lisp chip also was used for the MicroExplorer – a NuBus board for the Apple Macintosh II (NuBus was initially developed at MIT for use in Lisp machines). Symbolics continued to develop

2822-678: The Xerox Star office system. These included the Xerox 1100, Dolphin (1979); the Xerox 1132, Dorado ; the Xerox 1108, Dandelion (1981); the Xerox 1109, Dandetiger ; and the Xerox 1186/6085 , Daybreak . The operating system of the Xerox Lisp machines has also been ported to a virtual machine and is available for several platforms as a product named Medley . The Xerox machine was well known for its advanced development environment (InterLisp-D),

2905-534: The least-significant bit of each 16-bit word as a tag bit: if it was clear then the hardware would accept it as an aligned memory address while if it was set it was treated as a ( shifted ) 15-bit integer. Current Intel documentation mentions that the lower bits of a memory address might be similarly used by some interpreter -based systems. In the Soviet Union, the Elbrus series of supercomputers pioneered

2988-537: The operating system (relatively) simple, these machines would not be shared, but would be dedicated to single users. In 1973, Richard Greenblatt and Thomas Knight , programmers at Massachusetts Institute of Technology (MIT) Artificial Intelligence Laboratory (AI Lab), began what would become the MIT Lisp Machine Project when they first began building a computer hardwired to run certain basic Lisp operations, rather than run them in software, in

3071-516: The self-hosting compiler , and the read–eval–print loop . The name LISP derives from "LISt Processor". Linked lists are one of Lisp's major data structures , and Lisp source code is made of lists. Thus, Lisp programs can manipulate source code as a data structure, giving rise to the macro systems that allow programmers to create new syntax or new domain-specific languages embedded in Lisp. The interchangeability of code and data gives Lisp its instantly recognizable syntax. All program code

3154-488: The 1980s: Symbolics (3600, 3640, XL1200, MacIvory, and other models), Lisp Machines Incorporated (LMI Lambda), Texas Instruments ( Explorer, MicroExplorer ), and Xerox ( Interlisp -D workstations). The operating systems were written in Lisp Machine Lisp , Interlisp (Xerox), and later partly in Common Lisp . Artificial intelligence (AI) computer programs of the 1960s and 1970s intrinsically required what

3237-484: The 2000s (decade). The Revised Report on the Algorithmic Language Scheme standard of Scheme was widely accepted in the Scheme community. The Scheme Requests for Implementation process has created a lot of quasi-standard libraries and extensions for Scheme. User communities of individual Scheme implementations continue to grow. A new language standardization process was started in 2003 and led to

3320-482: The 2010s. Lisp is an expression oriented language . Unlike most other languages, no distinction is made between "expressions" and "statements" ; all code and data are written as expressions. When an expression is evaluated , it produces a value (possibly multiple values), which can then be embedded into other expressions. Each value can be any data type. McCarthy's 1958 paper introduced two types of syntax: Symbolic expressions ( S-expressions , sexps), which mirror

3403-550: The 3600 family and its operating system, Genera , and produced the Ivory, a VLSI implementation of the Symbolics architecture. Starting in 1987, several machines based on the Ivory processor were developed: boards for Suns and Macs, stand-alone workstations and even embedded systems (I-Machine Custom LSI, 32 bit address, Symbolics XL-400, UX-400, MacIvory II; in 1989 available platforms were Symbolics XL-1200, MacIvory III, UX-1200, Zora, NXP1000 "pizza box"). Texas Instruments shrank

Lisp machine - Misplaced Pages Continue

3486-648: The 3600 family of Lisp machines was supposed to ship quickly, but the 3600s were repeatedly delayed, and Symbolics ended up producing ~100 LM-2s, each of which sold for $ 70,000. Both firms developed second-generation products based on the CADR: the Symbolics 3600 and the LMI-LAMBDA (of which LMI managed to sell ~200). The 3600, which shipped a year late, expanded on the CADR by widening the machine word to 36-bits, expanding

3569-602: The AI lab. For two years, from 1982 to the end of 1983, Stallman worked by himself to clone the output of the Symbolics programmers, with the aim of preventing them from gaining a monopoly on the lab's computers. Regardless, after a series of internal battles, Symbolics did get off the ground in 1980/1981, selling the CADR as the LM-2, while Lisp Machines , Inc. sold it as the LMI-CADR. Symbolics did not intend to produce many LM-2s, since

3652-679: The E3 Project (TI Explorer II Emulation), Meroko (TI Explorer I), and Nevermore (TI Explorer I). On 3 October 2005, the MIT released the CADR Lisp Machine source code as open source. In September 2014, Alexander Burger, developer of PicoLisp , announced PilMCU, an implementation of PicoLisp in hardware. The Bitsavers' PDF Document Archive has PDF versions of the extensive documentation for the Symbolics Lisp Machines,

3735-741: The Explorer into silicon as the MicroExplorer which was offered as a card for the Apple Mac II . LMI abandoned the CADR architecture and developed its own K-Machine, but LMI went bankrupt before the machine could be brought to market. Before its demise, LMI was working on a distributed system for the LAMBDA using Moby space. These machines had hardware support for various primitive Lisp operations (data type testing, CDR coding ) and also hardware support for incremental garbage collection . They ran large Lisp programs very efficiently. The Symbolics machine

3818-502: The Extensible Markup Language ( XML ). The reliance on expressions gives the language great flexibility. Because Lisp functions are written as lists, they can be processed exactly like data. This allows easy writing of programs which manipulate other programs ( metaprogramming ). Many Lisp dialects exploit this feature using macro systems, which enables extension of the language almost without limit. A Lisp list

3901-462: The Lisp machines were designed as personal workstations for software development in Lisp. They were used by one person and offered no multi-user mode. The machines provided a large, black and white, bitmap display, keyboard and mouse, network adapter, local hard disks, more than 1 MB RAM, serial interfaces, and a local bus for extension cards. Color graphics cards, tape drives, and laser printers were optional. The processor did not run Lisp directly, but

3984-560: The Lisp model of incremental compilation , in which compiled and interpreted functions can intermix freely. The language used in Hart and Levin's memo is much closer to modern Lisp style than McCarthy's earlier code. Garbage collection routines were developed by MIT graduate student Daniel Edwards , prior to 1962. During the 1980s and 1990s, a great effort was made to unify the work on new Lisp dialects (mostly successors to Maclisp such as ZetaLisp and NIL (New Implementation of Lisp) into

4067-470: The R RS Scheme standard in 2007. Academic use of Scheme for teaching computer science seems to have declined somewhat. Some universities are no longer using Scheme in their computer science introductory courses; MIT now uses Python instead of Scheme for its undergraduate computer science program and MITx massive open online course. There are several new dialects of Lisp: Arc , Hy , Nu , Liskell , and LFE (Lisp Flavored Erlang). The parser for Julia

4150-544: The RISC-based Lisp co-processor COLIBRI. With the onset of the AI winter and the early beginnings of the microcomputer revolution , which would sweep away the minicomputer and workstation makers, cheaper desktop PCs soon could run Lisp programs even faster than Lisp machines, with no use of special purpose hardware. Their high profit margin hardware business eliminated, most Lisp machine makers had gone out of business by

4233-520: The ROOMS window manager, for its early graphical user interface and for novel applications like NoteCards (one of the first hypertext applications). Xerox also worked on a Lisp machine based on reduced instruction set computing (RISC), using the 'Xerox Common Lisp Processor' and planned to bring it to market by 1987, which did not occur. In the mid-1980s, Integrated Inference Machines (IIM) built prototypes of Lisp machines named Inferstar. In 1984–85

SECTION 50

#1732781047746

4316-462: The S-expression syntax is also responsible for much of Lisp's power: the syntax is simple and consistent, which facilitates manipulation by computer. However, the syntax of Lisp is not limited to traditional parentheses notation. It can be extended to include alternative notations. For example, XMLisp is a Common Lisp extension that employs the metaobject protocol to integrate S-expressions with

4399-599: The TI Explorer and MicroExplorer Lisp Machines and the Xerox Interlisp-D Lisp Machines. Domains using the Lisp machines were mostly in the wide field of artificial intelligence applications, but also in computer graphics, medical image processing, and many others. The main commercial expert systems of the 80s were available: Intellicorp's Knowledge Engineering Environment (KEE), Knowledge Craft, from The Carnegie Group Inc., and ART ( Automated Reasoning Tool ) from Inference Corporation. Initially

4482-403: The address space to 28-bits, and adding hardware to accelerate certain common functions that were implemented in microcode on the CADR. The LMI-LAMBDA, which came out a year after the 3600, in 1983, was compatible with the CADR (it could run CADR microcode), but hardware differences existed. Texas Instruments (TI) joined the fray when it licensed the LMI-LAMBDA design and produced its own variant,

4565-602: The concepts, such as list-processing and recursion, which came to be used in Lisp. McCarthy's original notation used bracketed " M-expressions " that would be translated into S-expressions . As an example, the M-expression car[cons[A,B]] is equivalent to the S-expression ( car ( cons A B )) . Once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned. M-expressions surfaced again with short-lived attempts of MLisp by Horace Enea and CGOL by Vaughan Pratt . Lisp

4648-538: The control word formats include a 3-bit tag. However, the replacement architecture, starting with the B6500, does have a tag for every word. In contrast, program and data memory are indistinguishable in the von Neumann architecture , making the way the memory is referenced critical to interpret the correct meaning. Notable examples of American tagged architectures were the Lisp machines , which had tagged pointer support at

4731-418: The core theme of an S-expression language. Moreover, each given dialect may have several implementations—for instance, there are more than a dozen implementations of Common Lisp . Differences between dialects may be quite visible—for instance, Common Lisp uses the keyword defun to name a function, but Scheme uses define . Within a dialect that is standardized, however, conforming implementations support

4814-618: The early 90s, leaving only software based firms like Lucid Inc. or hardware makers who had switched to software and services to avoid the crash. As of January 2015, besides Xerox and TI, Symbolics is the only Lisp machine firm still operating, selling the Open Genera Lisp machine software environment and the Macsyma computer algebra system. Several attempts to write open-source emulators for various Lisp Machines have been made: CADR Emulation, Symbolics L Lisp Machine Emulation,

4897-596: The features of Lisp Machine Lisp (a large Lisp dialect used to program Lisp Machines ), but was designed to be efficiently implementable on any personal computer or workstation. Common Lisp is a general-purpose programming language and thus has a large language standard including many built-in data types, functions, macros and other language elements, and an object system ( Common Lisp Object System ). Common Lisp also borrowed certain features from Scheme such as lexical scoping and lexical closures . Common Lisp implementations are available for targeting different platforms such as

4980-415: The first item in a list and the rest of the list, respectively. The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT, and could be compiled by simply having an existing LISP interpreter interpret the compiler code, producing machine code output able to be executed at a 40-fold improvement in speed over that of the interpreter. This compiler introduced

5063-566: The hardware and opcode level, the Burroughs B6500 and successors , which have a data-driven tagged and descriptor-based architecture, and the non-commercial Rice Computer . Both the Burroughs and Lisp machine are examples of high-level language computer architectures , where the tagging is used to support types from a high-level language at the hardware level. In addition to this, the original Xerox Smalltalk implementation used

SECTION 60

#1732781047746

5146-504: The internal representation of code and data; and Meta expressions ( M-expressions ), which express functions of S-expressions. M-expressions never found favor, and almost all Lisps today use S-expressions to manipulate both code and data. The use of parentheses is Lisp's most immediately obvious difference from other programming language families. As a result, students have long given Lisp nicknames such as Lost In Stupid Parentheses , or Lots of Irritating Superfluous Parentheses . However,

5229-508: The only way Greenblatt was going to start the firm and build the Lisp machines that Jacobson desperately needed was if Jacobson pushed and otherwise helped Greenblatt launch the firm. Jacobson pulled together business plans, a board, a partner for Greenblatt (one F. Stephen Wyle). The newfound firm was named LISP Machine, Inc. (LMI), and was funded by CDC orders, via Jacobson. Around this time Symbolics (Noftsker's firm) began operating. It had been hindered by Noftsker's promise to give Greenblatt

5312-403: The proposed firm could succeed only with the full and undivided assistance of the AI Lab hackers as a group, Noftsker and Greenblatt decided that the fate of the enterprise was up to them, and so the choice should be left to the hackers. The ensuing discussions of the choice divided the lab into two factions. In February 1979, matters came to a head. The hackers sided with Noftsker, believing that

5395-522: The same architecture. About 25 of what were essentially prototype CADRs were sold within and without MIT for ~$ 50,000; it quickly became the favorite machine for hacking – many of the most favored software tools were quickly ported to it (e.g. Emacs was ported from ITS in 1975). It was so well received at an AI conference held at MIT in 1978 that Defense Advanced Research Projects Agency (DARPA) began funding its development. In 1979, Russell Noftsker , being convinced that Lisp machines had

5478-474: The same core language, but with different extensions and libraries. After having declined somewhat in the 1990s, Lisp has experienced a resurgence of interest after 2000. Most new activity has been focused around implementations of Common Lisp , Scheme , Emacs Lisp , Clojure , and Racket , and includes development of new portable libraries and applications. Many new Lisp programmers were inspired by writers such as Paul Graham and Eric S. Raymond to pursue

5561-422: The simultaneous tests failed, then the result was discarded and recomputed; this meant in many cases a speed increase by several factors. This simultaneous checking approach was used as well in testing the bounds of arrays when referenced, and other memory management necessities (not merely garbage collection or arrays). Type checking was further improved and automated when the conventional byte word of 32 bits

5644-498: The size and cost of computers in the 1960s and early 1970s, and the memory needs of AI programs began to exceed the address space of the most common research computer, the Digital Equipment Corporation (DEC) PDP-10 , researchers considered a new approach: a computer designed specifically to develop and run large artificial intelligence programs, and tailored to the semantics of the Lisp language. To keep

5727-445: The software Symbolics developed. A consultant from CDC , who was trying to put together a natural language computer application with a group of West-coast programmers, came to Greenblatt, seeking a Lisp machine for his group to work with, about eight months after the disastrous conference with Noftsker. Greenblatt had decided to start his own rival Lisp machine firm, but he had done nothing. The consultant, Alexander Jacobson, decided that

5810-455: The space), aiding garbage collection by reportedly an order of magnitude. A further improvement was two microcode instructions which specifically supported Lisp functions , reducing the cost of calling a function to as little as 20 clock cycles, in some Symbolics implementations. The first machine was called the CONS machine (named after the list construction operator cons in Lisp). Often it

5893-406: The special atom nil . This is the only entity in Lisp which is both an atom and a list. Expressions are written as lists, using prefix notation . The first element in the list is the name of a function, the name of a macro, a lambda expression or the name of a "special operator" (see below). The remainder of the list are the arguments. For example, the function list returns its arguments as

5976-454: Was a stack machine with instructions optimized for compiled Lisp. The early Lisp machines used microcode to provide the instruction set. For several operations, type checking and dispatching was done in hardware at runtime. For example, only one addition operation could be used with various numeric types (integer, float, rational, and complex numbers). The result was a very compact compiled representation of Lisp code. The following example uses

6059-453: Was affectionately referred to as the Knight machine , perhaps since Knight wrote his master's thesis on the subject; it was extremely well received. It was subsequently improved into a version called CADR (a pun; in Lisp, the cadr function, which returns the second item of a list, is pronounced /ˈkeɪ.dəɹ/ or /ˈkɑ.dəɹ/ , as some pronounce the word "cadre") which was based on essentially

6142-685: Was competitive against many commercial super minicomputers , but was never adapted for conventional purposes. The Symbolics Lisp Machines were also sold to some non-AI markets like computer graphics , modeling, and animation. The MIT-derived Lisp machines ran a Lisp dialect named Lisp Machine Lisp , descended from MIT's Maclisp . The operating systems were written from the ground up in Lisp, often using object-oriented extensions. Later, these Lisp machines also supported various versions of Common Lisp (with Flavors , New Flavors , and Common Lisp Object System (CLOS)). Bolt, Beranek and Newman (BBN) developed its own Lisp machine, named Jericho, which ran

6225-404: Was first implemented by Steve Russell on an IBM 704 computer using punched cards . Russell had read McCarthy's paper and realized (to McCarthy's surprise) that the Lisp eval function could be implemented in machine code . According to McCarthy Steve Russell said, look, why don't I program this eval  ... and I said to him, ho, ho, you're confusing theory with practice, this eval

6308-420: Was influenced by Smalltalk, with later dialects adopting object-oriented programming features (inheritance classes, encapsulating instances, message passing, etc.) in the 1970s. The Flavors object system introduced the concept of multiple inheritance and the mixin . The Common Lisp Object System provides multiple inheritance, multimethods with multiple dispatch , and first-class generic functions , yielding

6391-511: Was invented by McCarthy for a chess program written in Fortran . He proposed its inclusion in ALGOL , but it was not made part of the Algol 58 specification. For Lisp, McCarthy used the more general cond -structure. Algol 60 took up if–then–else and popularized it. Lisp deeply influenced Alan Kay , the leader of the research team that developed Smalltalk at Xerox PARC ; and in turn Lisp

6474-452: Was lengthened to 36 bits for Symbolics 3600-model Lisp machines and eventually to 40 bits or more (usually, the excess bits not accounted for by the following were used for error-correcting codes ). The first group of extra bits were used to hold type data, making the machine a tagged architecture , and the remaining bits were used to implement CDR coding (wherein the usual linked list elements are compressed to occupy roughly half

6557-520: Was originally created as a practical mathematical notation for computer programs , influenced by (though not originally derived from) the notation of Alonzo Church 's lambda calculus . It quickly became a favored programming language for artificial intelligence (AI) research. As one of the earliest programming languages, Lisp pioneered many ideas in computer science , including tree data structures , automatic storage management , dynamic typing , conditionals , higher-order functions , recursion ,

6640-828: Was ported to Common Lisp or later written in Common Lisp. Some later Lisp machines (like the TI MicroExplorer, the Symbolics MacIvory or the Symbolics UX400/1200) were no longer complete workstations, but boards designed to be embedded in host computers: Apple Macintosh II and Sun-3 or Sun-4 . Some Lisp machines, such as the Symbolics XL1200, had extensive graphics abilities using special graphics boards. These machines were used in domains like medical image processing, 3D animation, and CAD. Lisp (programming language) Lisp

6723-433: Was stimulated by its use in Lisp. Edsger W. Dijkstra in his 1972 Turing Award lecture said, With a few very basic principles at its foundation, it [LISP] has shown a remarkable stability. Besides that, LISP has been the carrier for a considerable number of in a sense our most sophisticated computer applications. LISP has jokingly been described as "the most intelligent way to misuse a computer". I think that description

6806-444: Was then considered a huge amount of computer power, as measured in processor time and memory space. The power requirements of AI research were exacerbated by the Lisp symbolic programming language, when commercial hardware was designed and optimized for assembly - and Fortran -like programming languages. At first, the cost of such computer hardware meant that it had to be shared among many users. As integrated circuit technology shrank

6889-454: Was used as the implementation of the language Micro Planner , which was used in the famous AI system SHRDLU . In the 1970s, as AI research spawned commercial offshoots, the performance of existing Lisp systems became a growing issue, as programmers needed to be familiar with the performance ramifications of the various techniques and choices involved in the implementation of Lisp. Over its sixty-year history, Lisp has spawned many variations on

#745254