From: bbirch@hemel.bull.co.uk (Bill Birch)
Subject: Re: Yet another Lisp Interpreter Available (RefLisp) Long
Organization: Bull HN UK
Date: Thu, 17 Dec 92 20:09:01 GMT

voss@i40s16.ira.uka.de (Stefan Voss) writes:

>Can you shortly describe the features of RefLisp ?
	- RefLisp is not Common Lisp (CL), there are already plenty of 
	  good, free Common Lisps available.

	- RefLisp has reference counting garbage collection, that means
	  memory is reclaimed as soon as it is un-used. It is a "non-stop"
	  system, in that there is never any halt for garbage collection (GC).
	  This means that you can write programs which rely on a deterministic
	  response time. For example there is a demo program: "clock.lsp"
	  which draws an analogue clock-face, and the hands move every
	  clock tick, without stopping. I think if you tried to do this
	  with a GC interpreter, every so often the clock would stop 
	  working while the interpreter cleaned up memory. There
	  is also a very basic flight simulator in Lisp on the RefLisp 
	  distribution, it draws the track an aircraft might make on
	  a radar screen. 

	  Another example is in a
	  drawing program "gob.lsp"; there is Lisp code which does
	  rubber-banding. The line follows the mouse movement. If a 
	  GC system was used, the mouse-following would probably stop 
	  occasionally during GC, leaving the user somewhat bewildered!
	  RefLisp collects garbage on the fly, therefore this never happens, 
	  so you get a responsive User Interface. In theory, one could write 
	  a playable space-invaders game in RefLisp. [I would if I had time.]

	  On a small PC with limited memory, a GC system would 
	  be continually running out of memory resulting in a garbage
	  collection. Since each GC takes some time, my guess is that
	  the interpreter would spend most of its time in the GC.
	  By contrast, RefLisp would only do garbage collection
	  when required, and should therefore be faster.  (I have no proof 
	  for this, just a hunch based on experience with Cambridge Lisp for
	  the Sinclair QL, a 64kbyte home computer). 

	  Reference-counting (as implemented in RefLisp) also makes it
	  relatively easy to convert from Lisp to 'C'. This is because
	  any foreign C program can mark Lisp objects and release them
	  when finished. The reference-count works like a PV semaphore,
	  so any module has access to garbage collection. I think
	  is quite trivial to embed RefLisp into major 'C' programs. 
	  For example there is a RefLisp binding for Tuxedo 
	  (a Transaction Processing Monitor). 
	  
	  So to sum up, RefLisp lets you play around with algorithms which 
	  demand a deterministic response time.

	- RefLisp is shallow binding.

	- it's a "small" Lisp system, ie there is no compiler, nor
	  are there 1000s of in-built functions.

	- RefLisp is just a small portable system for experimenting with 
	  reference-counting garbage collection. 

>How close is it to Common Lisp ? 
	Close enough to run under-graduate type examples from 
	introduction texts to Common Lisp.

	Reflisp does implement: ' ` , ,@ #' &rest &optional
	and a few other important CL features. At present most CL 
	functions are provided in Lisp source form, dolist etc 

What are the differences ?
	
	Without wanting to offend anyone, CL is huge, RefLisp is
	tiny.  RefLisp does not implement even a small fraction of CLtL2.

	RefLisp is shallow binding, ie everything has dynamic scope.

	Reflisp has no Compiler

	RefLisp makes no distinction between symbol-values and function-values,
	a symbol is either but not both.

	A symbol can have an s-expression as it's print name.
	
	There are some optional extensions which are not-standard.

Please, email me for more details.

Best Wishes for the season,

Bill
--
 Bill Birch             	|	B.Birch@uk03.bull.co.uk
 Bull Info. Sys. Ltd.   	|       Bull Tel: 773 4770
 Maxted Road,         		|	Bull Mail: HM14 UK03 
 Hemel Hempstead,        	|	Tel: +44 442 884770
 HERTS, HP2 7DZ, U.K.         	|	Fax: +44 442 884570
                Aviate, Navigate, Communicate...
Newsgroups: comp.lang.lisp