
	Where results make sense

Topic: MacLisp

Related Topics

Lisp programming language

Macsyma

Osborne

Event horizon

Beedrill

Eastern Kentucky University

Matcha

Cobh, Ireland

Marquess of Hartington

Bachelor Mother

Sir Wilfrid Laurier

Russell Smith

List of libraries

Edward Lear

Mighty Sparrow

In the News (Thu 9 Feb 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	MacLisp
		MacLisp is a dialect of the Lisp programming language.
		MacLisp initially ran on DEC PDP-10 computers, was used to implement the Macsyma[?] symbolic algebra[?] program, and was in widespread use in the artificial intelligence research community through the early 1980s.
		Lisp Machine Lisp is a direct descendant of MacLisp.
	www.ebroadcast.com.au /lookup/encyclopedia/ma/MacLisp.html (64 words)

	[No title]
		Maclisp is descended from the commonly-known Lisp 1.5 dialect; however, many features of the language have been changed or augmented.
		The Maclisp system is structured as an environment, which is essentially a set of names and bindings of those names to data structures and function definitions.
		In ITS Maclisp, newline is carriage return (octal 015), optionally followed by line feed (octal 012.) In dec-10 Maclisp, newline is carriage return followed by line feed.
	zane.brouhaha.com /~healyzh/doc/lisp.doc.txt (17440 words)

	ANSI and GNU Common Lisp Document - History
		The primary dialect of Lisp between 1960 and 1965 was Lisp~1.5.
		MacLisp improved on the Lisp~1.5 notion of special variables and error handling.
		MacLisp also introduced the concept of functions that could take a variable number of arguments, macros, arrays, non-local dynamic exits, fast arithmetic, the first good Lisp compiler, and an emphasis on execution speed.
	www.mathcs.duq.edu /simon/Gcl/gcl_4.html (1394 words)

	Mac Lisp (Site not responding. Last check: 2007-09-10)
		MacLisp was used for a great many amazing things, including the bootstrapping of the SchemeLanguage (which was compiled to MacLisp.) Its name derives from the MAC Project at MIT, and not from the AppleMacintosh computer series (which it predated by almost two decades).
		The relationship between MacLisp to Emacs Lisp is indirect: the author of Emacs and Emacs Lisp, Richard Stallman, developed Emacs at MIT and was associated (in some sense) with Project Mac, but Emacs Lisp itself is a rewrite from scratch, as is the current Emacs (the original Emacs was written in the Teco language).
		The MacLisp compiler also has been optimized to support fast numerical processing.
	c2.com /cgi/wiki?MacLisp (397 words)

	MACLISP info (Site not responding. Last check: 2007-09-10)
		MACLISP is a dialect of Lisp that ran on DEC PDP10 and Honeywell Multics in the 1970's and early 1980's.
		MACLISP had a heavy influence on the design of Zetalisp (Lisp Machine Lisp) and Common Lisp.
		The name "MACLISP" is from MIT's Project MAC, later renamed to the "Laboratory for Computer Science" (LCS).
	maclisp.info (91 words)

	Optimizing Allocation and Garbage Collection of Spaces
		MACLISP, unlike some other implementations of LISP, allocates storage for different types of objects in noncontiguous areas called spaces.
		The question now is: "How can the rate of free storage usage for each data type be measured?" A "cons-counter" could be implemented for each data type, which would count the cells allocated for that data type, but in MACLISP this measurement is better made by the garbage collector.
		Taking the total free storage to be a percentage of the total accessible storage, we can divide up this free space among the spaces based on their differential rates of allocation.
	home.pipeline.com /~hbaker1/OptAlloc.html (1497 words)

	Untitled Document: 7. "Numbers"
		In Maclisp, there are generic numeric functions (like plus) and there are specific numeric functions (like +) which only operate on a certain type, and are much more efficient.
		They work on all types of numbers, automatically performing any required coercions (as opposed to Maclisp, in which generally only the spelled-out versions work for all kinds of numbers, and the "$" versions are needed for flonums).
		The rotation considers x as a 24-bit number (unlike Maclisp, which considers x to be a 36-bit number in both the pdp-10 and Multics implementations).
	www.unlambda.com /lmman/lmman_7.html (4517 words)

	``A FORTRAN->LISP Translator'' by Kent Pitman (June, 1979)
		The lisp code output by the translator is expected to be readable and maintainable by a lisp programmer, while still preserving the basic structure of the source Fortran.
		MacLISP and Fortran are almost completely incompatible when it comes to such issues as argument passing and side-effects.
		The reason is that MacLISP arrays may be relocated by the garbage collector, and so cannot be referenced as offsets from a fixed machine location.
	www.nhplace.com /kent/Papers/Fortran-to-Lisp.html (3545 words)

	[No title]
		The MacLISP function-calling mechanism cannot be used as a target construct for the SCHEME function call, because MacLISP's function calls are not guaranteed to behave tail-recursively.
		While SCHEME variables can sometimes be represented as temporary MacLISP variables using LAMBDA, in general they must be kept 21 in a "consed environment" in the heap; CAR and CDR are used to "index" the environment "stack" (which is not really a stack, but in general tree-like).
		We leave to the MacLISP compiler the task of compiling large expressions involving these; but we are not avoiding the associated difficult issues such as register allocation, for we shall have to deal with them in compiling calls to SCHEME functions.
	www.cs.berkeley.edu /~fateman/264/papers/rabbit600.txt (12385 words)

	MACLISP - Definitions from Dictionary.com (Site not responding. Last check: 2007-09-10)
		MacLisp was later used by Project MAC, Mathlab and Macsyma.
		MacLisp was one of two main branches of LISP (the other being Interlisp).
		In 1981 Common LISP was begun in an effort to combine the best features of both.
	dictionary.reference.com /browse/MACLISP (108 words)

	[No title]
		MacLISP was my LISP of choice until I lost dialup access into the ARPA-Internet in the early 1980's.
		Below is a summary of some of applications I've written myself using UCI-LISP MacLISP PSL or MACL, or helped develop as part of a team using PSL.
		Correlate number of arguments to functions in various files, alerting the user whenever the number of arguments doesn't match, building a database of correct argument-numbers to compare against.
	members.tripod.com /~MaasInfo/SeekJob/Resume.921-LISP.txt (1707 words)

	``Condition Handling in the Lisp Language Family'' c by Kent Pitman (2001)
		In PDP10 Maclisp, error messages were historically all uppercase, since the system's primitive error messages were that way and many users found it aesthetically unpleasant to have some messages in mixed case while others were entirely uppercase.
		The decision made by the Maclisp maintainers of the time was not to yield to such pressure.
		The lesson from this for all of us in the Maclisp community, which became magnified later when we confronted the broader community of international users, was that the identity of an error should not be its name.
	www.nhplace.com /kent/Papers/Condition-Handling-2001.html (6434 words)

	Emergent Technologies Inc. -- LISP Machine Progress Report (Site not responding. Last check: 2007-09-10)
		A Lisp object in Maclisp or Interlisp is represented as an 18 bit pointer, and the datatype of the object is determined from the pointer; each page of memory can only contain objects of a single type.
		This is a general feature of the Maclisp and Lisp machine compilers, that by default variables are local, which means that they are lexically bound, only available to the function in which they are bound, and implemented not with atomic symbols, but simply as slots in the stack.
		On the Lisp machine it runs approximately 3 times as fast as in Maclisp on the KA-10, which in turn is 2 to 4 times as fast as in InterLisp.
	home.comcast.net /~prunesquallor/memo444.htm (10596 words)

	SHRDLU
		SHRDLU was written almost 30 years ago, in a now-obsolete language (MACLISP), to run on a now-obsolete system, and as such has been relegated to the texts of Philosophy and Computer Science, where it provides a remarkable example of "intelligence" through the understanding of natural language.
		As the work progressed, project members saw more and more how complex the system was, but the focus was on a straightforward porting of MACLISP operations to their LISP equivalents.
		It seemed most important to turn the source completely into LISP, even if it was not "correct." Once this was done, testing could provide valuable clues as to how to port more "correctly." Unfortunately, SHRDLU's various components are very "entangled," with each component depending heavily on many of the others.
	web.umr.edu /~shrdlu/project_plan.html (922 words)

	Lisp for the Atari.
		Since the textbook uses Maclisp, a Maclisp emulator was included on the disk to enable you to work the exercises.
		However, several of the functions in the emulator are flawed, so you may have trouble obtaining the results in the textbook.
		The supplied Maclisp emulator makes it possible to use DEFUN forms, except that only one expression is allowed in the body of the function definition.
	www.atarimagazines.com /creative/v9n11/69_Lisp_for_the_Atari.php (1807 words)

	XEmacs Lisp Reference Manual: Introduction
		Many of them were inspired by Maclisp, which was written in the 1960's at MIT's Project MAC.
		Eventually the implementors of the descendants of Maclisp came together and developed a standard for Lisp systems, called Common Lisp.
		XEmacs Lisp is largely inspired by Maclisp, and a little by Common Lisp.
	www.xemacs.org /Documentation/21.5/html/lispref_2.html (2028 words)

	CLSV: Section 1.1
		One of the Interlisp ideas that influenced \clisp\ was an iteration construct implemented by Warren Teitelman that inspired the \macref{loop} macro used both on the Lisp Machines and in MacLisp, and now in \clisp.
		Although the Alto was not a total success as a Lisp machine, a dialect of Interlisp known as Interlisp-D became available on the D-series machines manufactured by Xerox---the Dorado, Dandelion, Dandetiger, and Dove (or Daybreak).
		The primary influences on \clisp\ were Lisp Machine Lisp, MacLisp, NIL, \hbox{S-1}~Lisp, Spice Lisp, and Scheme.
	www.dridus.com /~nyef/clsv/1_a.html (1325 words)

	Function Cells and Value Cells
		MacLisp [Pitman 1983] is a direct descendant of the PDP-6 Lisp and is a Lisp
		MacLisp uses a sophisticated form of link table, which is made possible by the separation of namespaces.
		Vax NIL is a descendant of MacLisp and was intended to be the successor to MacLisp running on the Vax.
	www.dreamsongs.com /Separation.html (6934 words)

	ALU: Lisp History
		MacLisp was developed at MIT and had much influence on the design of Common Lisp.
		The MAC in Maclisp had nothing to do with the Apple Macintosh, which did not come onto the computer scene until later.
		Rather, it referred to Project MAC, a research project at MIT which later became known as the Laboratory for Computer Science.
	www.lisp.org /table/history.htm (496 words)

	9.1. Declaration Syntax (Site not responding. Last check: 2007-09-10)
		The MacLisp compiler recognizes declarations but processes them simply by evaluating the subforms of the declaration in the compilation context.
		It is permissible for a macro call to expand into a declaration and be recognized as such, provided that the macro call appears where a declaration may legitimately appear.
		Declarations that do not concern themselves with variable bindings are pervasive, affecting all code in the body of the special form.
	www-static.cc.gatech.edu /~isbell/references/lisp/clm/node104.html (1854 words)

	SHRDLU resurrection
		He's posted an early release of that project's Common Lisp version of SHRDLU and a MACLISP interpreter written in C for running original SHRDLU source code.
		Greg has ITS running under KLH with MACLISP working, and is now debugging his distribution of SHRDLU (and very grateful for the "massive" help from Kent Pitman and the Lisp community).
		Chris Stacy (cstacy@dtpq.com) reports he is currently running MACLISP on a Unix emulation of the ITS.
	www.semaphorecorp.com /misc/shrdlu.html (1552 words)

	EmacsWiki: MacLisp
		Maclisp is a dialect of Lisp developed at MIT in 1966.
		It added many features that we take for granted in Lisp today: functions with variable numbers of arguments, macros, arrays, and non-local dynamic exits.
		The first Scheme interpreter and the first Emacs with Lisp facilities (see MulticsEmacs) were written in MacLisp.
	www.emacswiki.org /cgi-bin/wiki/MacLisp (186 words)

	History of LISP — Software Collection Committee
		Maclisp is descended from Lisp 1.5, and many recent important dialects (for example Lisp Machine Lisp and NIL) have evolved from Maclisp.
		David Moon's original document on Maclisp, The Maclisp Reference Manual (alias the Moonual) provided in-depth coverage of a number of areas of the Maclisp world.
		In 1976 the MIT version of MacLisp was ported to the WAITS operating system by Richard Gabriel at the Stanford AI Laboratory (SAIL), which was directed at that time by John McCarthy.
	community.computerhistory.org /scc/projects/LISP (8943 words)

	10.1. The Property List
		The value cell was introduced into MacLisp and Interlisp to speed up access to variables; similarly for the print-name cell and function cell (MacLisp does not use a function cell).
		In Common Lisp the notion of ``disembodied property list'' introduced in MacLisp is eliminated.
		It tended to be used for rather kludgy things and in Lisp Machine Lisp is often associated with the use of locatives (to make it ``off by one'' for searching alternating keyword lists).
	www.oopweb.com /LISP/Documents/cltl/Volume/node108.html (1175 words)

	1.1. Purpose
		Common Lisp originated in an attempt to focus the work of several implementation groups, each of which was constructing successor implementations of MacLisp for different computers.
		One implementation of Common Lisp, namely S-1 Lisp, already has a compiler that produces code for numerical computations that is competitive in execution speed to that produced by a Fortran compiler [11].
		Common Lisp is a descendant of MacLisp, which has traditionally placed emphasis on providing system-building tools.
	www.supelec.fr /docs/cltl/clm/node6.html (955 words)

	SHRDLU project extracts
		Date: Sat, 6 Feb 1999 16:15:34 -0600 There is now an HTML table for system calls (Maclisp) made by the user-defined functions in SHRDLU, which should aid a great deal in porting.
		And it's possible to make a stream which behaves exactly like Maclisp including respecting ^W and ^Q and ^R so that the code wouldn't have to change until you knew what was going on.
		I'm not sure exactly what the MACLISP compiler did & didn't do, so I don't know how much of the init routine is actually necessary anymore.
	www.semaphorecorp.com /misc/extracts.html (11178 words)

	MacLisp - OneLook Dictionary Search (Site not responding. Last check: 2007-09-10)
		We found 2 dictionaries with English definitions that include the word MacLisp:
		Tip: Click on the first link on a line below to go directly to a page where "MacLisp" is defined.
		MacLisp : Free On-line Dictionary of Computing [home, info]
	www.onelook.com /cgi-bin/cgiwrap/bware/dofind.cgi?word=MacLisp (77 words)

Try your search on: Qwika (all wikis)