HDTenEightyP/NetNews huggingface dataset:
From: jaffer@zurich.ai.mit.edu (Aubrey Jaffer)
Subject: Re: Now scm4b2 was Re: Scheme release scm4b1 available.
Organization: M.I.T. Artificial Intelligence Lab.
	<JAFFER.93Jan18013239@camelot.ai.mit.edu>
Date: Thu, 21 Jan 1993 17:58:33 GMT

This message announces the availability of Scheme release scm4b3.

Several bugs have been fixed.  ASH, LOGCOUNT, INTEGER-LENGTH, and
LOGNOT now work for bignums.  CLOSE-PORT will now close pipes as well.

Scm conforms to Revised^4 Report on the Algorithmic Language Scheme
and the IEEE P1178 specification.  Scm is written in C and runs under
Amiga, Atari-ST, MacOS, MS-DOS, OS/2, NOS/VE, VMS, Unix and similar
systems.  ASCII and EBCDIC are supported.

Documentation is included explaining the many Scheme Language
extensions in scm, the internal representation and how to extend or
include scm in other programs.

SCM can be obtained via FTP (detailed instructions follow) from:
altdorf.ai.mit.edu:archive/scm/scm4b3.tar.Z
prep.ai.mit.edu:pub/gnu/jacal/scm4b3.tar.Z
nexus.yorku.ca:pub/scheme/new/scm4b3.tar.Z

SLIB is a portable Scheme library which SCM uses:
altdorf.ai.mit.edu:archive/scm/slib1c4.tar.Z
prep.ai.mit.edu:pub/gnu/jacal/slib1c4.tar.Z
nexus.yorku.ca:pub/scheme/new/slib1c4.tar.Z

JACAL is a symbolic math system written in Scheme:
altdorf.ai.mit.edu:archive/scm/jacal1a0.tar.Z
prep.ai.mit.edu:pub/gnu/jacal/jacal1a0.tar.Z
nexus.yorku.ca:pub/scheme/new/jacal1a0.tar.Z

SMG-SCM is an SMG interface package which works with SCM on VMS.
altdorf.ai.mit.edu:archive/scm/smg-scm.com
prep.ai.mit.edu:pub/gnu/jacal/smg-scm.com

TURTLSCM is a turtle graphics package which works with SCM on MSDOS
machines:
altdorf.ai.mit.edu:archive/scm/turtlscm4a10.lzh
prep.ai.mit.edu:pub/gnu/jacal/turtlscm4a10.lzh

XSCM is a X windows interface package which works with SCM:
altdorf.ai.mit.edu:archive/scm/xscm1.05.tar.Z
prep.ai.mit.edu:pub/gnu/jacal/xscm1.05.tar.Z

  ftp altdorf.ai.mit.edu [18.43.0.246] (anonymous)
  bin
  cd archive/scm
  get scm4b3.tar.Z
  get slib1c4.tar.Z
or
  ftp prep.ai.mit.edu (anonymous)
  bin
  cd pub/gnu/jacal
  get scm4b3.tar.Z
  get slib1c4.tar.Z

`scm4b3.tar.Z' is a compressed tar file of the C code distribution.
`slib1c4.tar.Z' is a compressed tar file of a Scheme Library.

Remember to use binary mode when transferring the files.
Be sure to get and read the GNU General Public License (COPYING).
It is included in scm4b3.tar.Z.

To receive an IBM PC floppy disk with the source files and MSDOS
and i386 MSDOS executables send $99.00 to:
   Aubrey Jaffer, 84 Pleasant St. Wakefield MA 01880, USA.

If you like scm you can support the developement and maintainence of
it by buying a disk from me or by sending money to the above address.
From: gjr@zurich.ai.mit.edu (Guillermo J. Rozas)
Newsgroups: comp.lang.scheme.c
Subject: Re: SPARC native code compiler
Date: 22 Jan 93 17:06:13 GMT
Reply-To: gjr@zurich.ai.mit.edu
Distribution: inet
Organization: M.I.T. Artificial Intelligence Lab.
NNTP-Posting-Host: chamartin.ai.mit.edu
In-reply-to: xjam@cork.CS.Berkeley.EDU's message of 21 Jan 93 20:09:05

In article <XJAM.93Jan21200905@cork.CS.Berkeley.EDU> xjam@cork.CS.Berkeley.EDU (The Crossjammer) writes:

|   From: xjam@cork.CS.Berkeley.EDU (The Crossjammer)
|   Newsgroups: comp.lang.scheme.c
|   Date: 21 Jan 93 20:09:05
|
|   I'm interested in porting the native code compiler to the SPARC
|   architecture if it hasn't been done already. Who should I contact?

To our knowledge, there is no back end for the Sparc architecture.

Depending on how much time you have, there are two possibilities.


Option A: Write a full native port.  To find out how to do this, ftp the
compiler porting guide from

altdorf.ai.mit.edu:archive/scheme-7.2/compdoc.tar.Z

It is very slightly out of date, but the differences should not be
important.

This will take a considerable amount of time (~3 weeks for an expert).


Option B: We have a back end that generates C almost finished.  It is
up enough to compile most of the runtime system (all but three files).
The output is both larger and slower than the native version, but much
faster than the interpreter.  Besides some debugging and cleaning up
of rough edges, one of the things that is missing is the ability to
load compiled files dynamically -- right now it is all done
statically, when the "microcode" is generated.  You could have a
working system much faster if you took this approach.


Even if you decide to go with option A, you may be interested in
option B as a reference.  The RTL rules expand into macroized-C
fragments rather than any individual architecture, so they may be
easier to understand.
From: gjr@zurich.ai.mit.edu (Guillermo J. Rozas)
Newsgroups: comp.lang.scheme.c
Subject: Re: unbound variable detection
Date: 22 Jan 93 16:57:48 GMT
Reply-To: gjr@zurich.ai.mit.edu
Distribution: inet
Organization: M.I.T. Artificial Intelligence Lab.
NNTP-Posting-Host: chamartin.ai.mit.edu
In-reply-to: kardank@ERE.UMontreal.CA's message of 22 Jan 93 04:46:23 GMT

In article <1993Jan22.044623.19581@cc.umontreal.ca> kardank@ERE.UMontreal.CA (Kardan Kaveh) writes:

|   From: kardank@ERE.UMontreal.CA (Kardan Kaveh)
|   Newsgroups: comp.lang.scheme.c
|   Date: 22 Jan 93 04:46:23 GMT
|
|   Is it possible to tell if a given variable is undefined?
|
|   For example, something along the lines of:
|
|   (define x 3)
|
|   (bound? x) --> #t
|
|   (bound? y) --> #f

(define-macro (bound? name)
  `(not (lexical-unbound? (the-environment) ',name)))

or

(define-macro (bound? name)
  `(not (lexical-unbound? user-initial-environment ',name)))

depending on exactly what you want.
From: kardank@ERE.UMontreal.CA (Kardan Kaveh)
Newsgroups: comp.lang.scheme.c
Subject: X graphics questions
Date: 24 Jan 93 03:14:47 GMT
Organization: Universite de Montreal

Two questions regarding X graphics:

(1) According to the source, the function x-graphics-fill-polygon is defined,
    yet it neither appears in the info files, nor is accepted by the
    interpreter.

(2) Is there an interface to the event-handling code in X, so that one can
    write an interactive application in MIT Scheme?

Thanks,

Kaveh

-- 
------------
Kaveh Kardan                                       kaveh@taarna.UUCP
Systeme Taarna                                     kardank@eole.umontreal.qc.ca
Montreal Quebec Canada                             (514)844-8448
From: kardank@ERE.UMontreal.CA (Kardan Kaveh)
Newsgroups: comp.lang.scheme.c
Subject: unbound variable detection
Date: 22 Jan 93 04:46:23 GMT
Organization: Universite de Montreal

Is it possible to tell if a given variable is undefined?

For example, something along the lines of:

(define x 3)

(bound? x) --> #t

(bound? y) --> #f

Thanks,

Kaveh


-- 
------------
Kaveh Kardan                                       kaveh@taarna.UUCP
Systeme Taarna                                     kardank@eole.umontreal.qc.ca
Montreal Quebec Canada                             (514)844-8448
From: xjam@cork.CS.Berkeley.EDU (The Crossjammer)
Newsgroups: comp.lang.scheme.c
Subject: SPARC native code compiler
Date: 21 Jan 93 20:09:05
Organization: University of California, Berserkeley
Distribution: inet
NNTP-Posting-Host: cork.cs.berkeley.edu

I'm interested in porting the native code compiler to the SPARC
architecture if it hasn't been done already. Who should I contact?
--
xjam@cork.Berkeley.EDU  	Fiiiive Thousand Boomin Watts...... -The JBeez

They can't come on and play me in prime time, 	    | Free Millipede coin op
Cause I know the time, cause I'm gettin' mine.	    | and House music at my
I get on the mix late in the night... -Public Enemy | place! Drop by sometime.
From: kardank@ERE.UMontreal.CA (Kardan Kaveh)
Newsgroups: comp.lang.scheme.c
Subject: macro problem
Date: 22 Jan 93 08:21:18 GMT
Organization: Universite de Montreal

What's wrong with the following?  MIT Scheme 7.2 complains f1 is unbound.

(define (f1 x) (* x x))

(define-macro (m1 y) `(+ 2 ,(f1 y)))

(m1 3)

;Unbound variable: f1

Also, I can't seem to find any documentation on macros in the info files.

Thanks,

Kaveh



-- 
------------
Kaveh Kardan                                       kaveh@taarna.UUCP
Systeme Taarna                                     kardank@eole.umontreal.qc.ca
Montreal Quebec Canada                             (514)844-8448
From: kardank@ERE.UMontreal.CA (Kardan Kaveh)
Newsgroups: comp.lang.scheme.c
Subject: macro question
Date: 24 Jan 93 05:10:36 GMT
Organization: Universite de Montreal

In an effort to have my macro definitions exist in all my source files,
I have placed the following code in my init file:

(define-macro (define-macro-both pattern . body)
  `(begin
     (define-macro ,pattern ,@body)
     (syntax-table-define system-global-syntax-table ',(car pattern)
       (macro ,(cdr pattern)
         ,@body))))
 
(syntax-table-define user-initial-syntax-table 'define-macro-both
  (macro (pattern . body)
    `(begin
       (define-macro ,pattern ,@body)
       (syntax-table-define system-global-syntax-table ',(car pattern)
         (macro ,(cdr pattern)
           ,@body)))))
 
(set! syntaxer/default-environment user-initial-environment)

The first two forms are from the macros.txt documentation file.

These have the desired effect when the code is interpreted, but when I compile
a file containing a macro which refers to a function defined in the same file,
or a file refering to a macro defined elsewhere, the interpreter complains
about unbound variables.

What do I need to do to make macros behave, in compiled code, the same
as in interpreted code?

Thanks,

Kaveh


-- 
------------
Kaveh Kardan                                       kaveh@taarna.UUCP
Systeme Taarna                                     kardank@eole.umontreal.qc.ca
Montreal Quebec Canada                             (514)844-8448
From: gjr@zurich.ai.mit.edu (Guillermo J. Rozas)
Newsgroups: comp.lang.scheme.c
Subject: Re: macro problem
Date: 22 Jan 93 16:55:38 GMT
Reply-To: gjr@zurich.ai.mit.edu
Distribution: inet
Organization: M.I.T. Artificial Intelligence Lab.
NNTP-Posting-Host: chamartin.ai.mit.edu
In-reply-to: kardank@ERE.UMontreal.CA's message of 22 Jan 93 08:21:18 GMT

In article <1993Jan22.082118.21781@cc.umontreal.ca> kardank@ERE.UMontreal.CA (Kardan Kaveh) writes:

|
|   From: kardank@ERE.UMontreal.CA (Kardan Kaveh)
|   Newsgroups: comp.lang.scheme.c
|   Date: 22 Jan 93 08:21:18 GMT
|
|   What's wrong with the following?  MIT Scheme 7.2 complains f1 is unbound.
|
|   (define (f1 x) (* x x))
|
|   (define-macro (m1 y) `(+ 2 ,(f1 y)))
|
|   (m1 3)
|
|   ;Unbound variable: f1
|

The environment where the macro expander procedure 
 (i.e. (lambda (y) `(+ ... )) ) is closed is _not_ the top level
environment where F1 is bound.  It is a separate environment.

This may seem like a strange decision, but imagine that F1, M1, and a
use of M1 are in some file that is to be compiled.  At the time of
compilation, M1 needs to be expanded, but the expansion requires the
binding for F1 that will not exist until run time.  Since clearly,
when compiling, the macro expander cannot be closed in the runtime
environment, we decided to make a special environment for macro
expanders to be closed, and this is done consistently when compiling
and simply interacting.

The environment where macro expanders is closed is the value of the
global variable SYNTAXER/DEFAULT-ENVIRONMENT.
In your init file, you can include

    (set! syntaxer/default-environment user-initial-environment)

or some such, and then it will have the behavior that you want when
interacting.

|
|   Also, I can't seem to find any documentation on macros in the info files.
|

Correct.  There is a very short document giving an overview (and
pointing out some gotchas) but it is not integrated into the info
structure.

You can get it from altdorf.ai.mit.edu:archive/scheme-7.2/macros.txt
by anonymous ftp.
From: bh@anarres.CS.Berkeley.EDU (Brian Harvey)
Newsgroups: comp.lang.scheme
Subject: Re: Unspecified values in R4RS
Date: 24 Jan 1993 15:19:14 GMT
Organization: University of California, Berkeley
NNTP-Posting-Host: anarres.cs.berkeley.edu

blume@kastle.Princeton.EDU (Matthias Blume) writes:
>To invent ``unspecified values'' is just the same as re-inventing
>the distinction between commands and expressions.

It is not I who want to invent unspecified values.  That's already in the
standard.  I am trying to un-invent this bad idea, and replace it with
a specified value!

As for commands vs. expressions, I think that's the reality anyway.  If
you write a program that says

(begin
  (display foo)
  (display baz)
  (display garply))

you can hardly pretend you're doing functional programming; and you're
not restored to grace just because this "expression" has the "value" #f
instead of the-nonprinting-object.
From: max@Kolmogorov.gac.edu (Max Hailperin)
Newsgroups: comp.lang.scheme
Subject: Re: How to lookup symbols fast?
Date: 22 Jan 93 09:34:14
Organization: Gustavus Adolphus College, St. Peter, MN
	<1993Jan19.212543.29200@gallant.apple.com>
Reply-To: Max Hailperin <max@nic.gac.edu>
NNTP-Posting-Host: kolmogorov.gac.edu
In-reply-to: kend@newton.apple.com's message of 19 Jan 93 21:25:43 GMT

In article <1993Jan19.212543.29200@gallant.apple.com>
kend@newton.apple.com (Kenneth Dickey) writes:

   In article <1je4kvINN5cj@shelley.u.washington.edu> Charles Bass,
   chuckb@stein.u.washington.edu writes:
   >We are writing a simple pattern matching program in scheme and
   >would like to speed up some of the internal "stuff".  We have a
   >table of 20 or 30 functions that our evaluate uses to determine
   >which function/rule-set to apply.
   ...
   >Is there anything better than a simple linear search of the
   >symbols?

   The rule of thumb is "for less than 100 elements, linear search beats
   hashing".  For 30 entries use an alist & assq.

Yes, but if read has already read in something as a symbol and the
"symbol" data type in your particular variant of Scheme has a spare
slot in it's representation (say, the property-list slot), then the
hashing has *already been done* by read.  Assuming you only put a few
properties on each symbol's property list (i.e. much less than 30),
and that property lists are linearly searched much like assq
(typically true, though often the details are a bit different, i.e.
alternating key and data elements rather than a list of pairs), this
has got to be faster than searching an alist of length 30.  Moreover,
it will typically grow more gracefully, since you are more likely to
multiply by a large factor the number of symbols in the table than the
number of tables (i.e. properties).

Yes, I know that property lists are archaic and not a standard feature
of the Scheme language, but many implementations do have them and if
Bass was using such an implementation, and if he really was of
necessity starting from *symbols* as he stated (i.e. pre-hashed by
read), then there seems like little point in redoing read's work.
From: john@linus.mitre.org
Newsgroups: comp.lang.dylan
Subject: Re: GC Module
Date: 22 Jan 93 20:46:19 GMT

I think some general support (i.e. a standard module) for
introspection and possibly control over GC would be great, but there
are a number of GC technologies out there.  As a result, many of the
operators in the GC module may be no-ops in a particular
implementation.  That's okay, as long as the module design takes that
into account, and as long as users realize that their complex GC
control code may have no effect.

For example, the proposed GARBAGE-COLLECT operator itself may be
ignored in a real-time GC sceme where scavenging is co-routined with
actual program execution.  On the other hand, such an implementation
may interpret the call to GARBAGE-COLLECT as license for a full,
non-real-time scavenge.

Also, the SELECT-AREA operator might interfere with certain
generational GC schemes that assume that there are more pointers from
new space to old than vice versa.  (This is the usual situation, since
most pointer references are created by initialization at creation, and
thus in new space, rather than setting old locations to new pointers.)
Defeating this, by creating an object into an older generation, may
upset some of the assumptions that the implementaiton makes, and so it
may choose to ignore the SELECT-AREA imperative.  On the other hand, I
can think of ways around this, IF the implementors wish to bother.

There are a number of examples like this.  For each of them, I can
think of reasons that the implementation may in fact choose to take
advantage of the information that the programmer is giving them, but
usually only if the implementors are willing to add some complexity to
the GC scheme.  So we need to be aware that the elements of the GC
module may not just be a case of exporting things that are already in
every implementation anyway.

John Burger
john@mitre.org
Newsgroups: comp.lang.dylan
From: an7778@anon.penet.fi
Subject: DYLAN
Organization: Anonymous contact service
X-Anonymously-To: comp.lang.dylan
Date: Sat, 23 Jan 1993 01:38:38 GMT


WILL DYLAN MCGAMBIT RUN ON APPLE LISA?

THANKS

. 


-------------------------------------------------------------------------
To find out more about the anon service, send mail to help@anon.penet.fi.
Due to the double-blind system, any replies to this message will be anonymized,
and an anonymous id will be allocated automatically. You have been warned.
From: alms@cambridge.apple.com (Andrew LM Shalit)
Subject: Re: Windows3 OS/2 & Mac Dylan
Date: Wed, 27 Jan 1993 21:14:05 GMT
Organization: Apple Computer
Followup-To: comp.lang.dylan

In article <HARDY.93Jan21195004@golem.ps.uci.edu>, hardy@golem.ps.uci.edu
(Meinhard E. Mayer (Hardy)) wrote:
> 
> In article <9301211104.AA06758@brazil.cambridge.apple.com> S.J.Nuttall@open.ac.uk writes:
> 
> 
> ???   We at Procyon Research Limited are looking for collaborators to market
> ???   Dylan for Windowss3 OS/2 & Mac. We can rapidly offer a high-performance
> ???   Dylan to an interested partner. We are looking for a partner who can
> ???   market the product.
> Too late for the Mac!
> Marc Feeley's Macgambit-1.9-1 and the macggambit-thomas interpreter
> are already available and are FREE!

I believe the existence of Thomas still leaves plenty of room for
other Dylan implementations.  While Thomas may be useful for
experimenting with the language, it is not appropriate for substantial
development tasks.

  -Andrew
From: kend@newton.apple.com (Kenneth Dickey)
Newsgroups: comp.lang.dylan
Subject: Re: Is GC really even necessary??
Date: 26 Jan 93 17:40:24 GMT
Organization: Bauhaus

OSs written in Lisp

In article <BRENT.93Jan20131623@rcx1.ssd.csd.harris.com> Brent Benson,
brent@ssd.csd.harris.com writes:
>This got me thinking.  Is there any OS work being done in Lisp or
>Lisp-like languages for stock (non-Lisp machine) hardware?  I would
>appreciate references if you have them.  ...

NEC is doing some interesting research (STING).  There are a number of
papers on tasking, engines, etc. dating back to Mitch Wand's 1980 paper. 
The main thing to watch is GC.  Kernels are easier in that storage is
typically pre-allocated from a pool.  I have been thinking a bit about gc
"domains", i.e. allocating from a heterogeneous pool which is small and
gc is therefor cheap (note FX).  Using a number of such domains could
allow one to have a real-time kernel using, e.g. Scheme.  Note also
futures.  Note threads in EULisp.

Jagannathan & Philbin: "A Customizable Substrate for Concurrent
Languages", ACM SIGPLAN '91 Conference on Programming Language Design and
Implementation (PLDI), June 1992.

Jagannathan & Philbin: "A Foundation for an Efficient Multi-threaded
Scheme System", L&FP '92 (Proc. 1992 ACM Conference on Lisp and
Functional Programming), Lisp Pointers vol V, #1, January-March 1992, ACM
#552920.

Heib & Dybvig: "Continuations and Concurrency", Second ACM SIGPLAN
Symposium on Principles and Practice of Parallel Programming, March 1990.

Haynes & Friedman: "Engines Build Process Abstractions",  L&FP '84 (Proc.
1984 ACM Symposium on Lisp and Functionl Programming".

Wand: "Continuation-Based MultiProcessing", L&FP '80 (Proc. 1980 ACM Lisp
and Functional Programming Conference, 1980).

There are a number of other refs.  These are just a sampling.  
Enjoy!
From: kend@newton.apple.com (Kenneth Dickey)
Newsgroups: comp.lang.dylan
Subject: Re: Is GC really even necessary??
Date: 26 Jan 93 17:36:58 GMT
Organization: Bauhaus

OSs written in Lisp

In article <BRENT.93Jan20131623@rcx1.ssd.csd.harris.com> Brent Benson,
brent@ssd.csd.harris.com writes:
>This got me thinking.  Is there any OS work being done in Lisp or
>Lisp-like languages for stock (non-Lisp machine) hardware?  I would
>appreciate references if you have them.  ...

NEC is doing some interesting research (STING).  There are a number of
papers on tasking, engines, etc. dating back to Mitch Wand's 1980 paper. 
The main thing to watch is GC.  Kernels are easier in that storage is
typically pre-allocated from a pool.  I have been thinking a bit about gc
"domains", i.e. allocating from a heterogeneous pool which is small and
gc is therefor cheap (note FX).  Using a number of such domains could
allow one to have a real-time kernel using, e.g. Scheme.  Note also
futures.  Note threads in EULisp.

Jagannathan & Philbin: "A Customizable Substrate for Concurrent
Languages", ACM SIGPLAN '91 Conference on Programming Language Design and
Implementation (PLDI), June 1992.

Jagannathan & Philbin: "A Foundation for an Efficient Multi-threaded
Scheme System", L&FP '92 (Proc. 1992 ACM Conference on Lisp and
Functional Programming), Lisp Pointers vol V, #1, January-March 1992, ACM
#552920.

Heib & Dybvig: "Continuations and Concurrency", Second ACM SIGPLAN
Symposium on Principles and Practice of Parallel Programming, March 1990.

Haynes & Friedman: "Engines Build Process Abstractions",  L&FP '84 (Proc.
1984 ACM Symposium on Lisp and Functionl Programming".

Wand: "Continuation-Based MultiProcessing", L&FP '80 (Proc. 1980 ACM Lisp
and Functional Programming Conference, 1980).

There are a number of other refs.  These are just a sampling.  
Enjoy!
Newsgroups: comp.lang.dylan
From: gandalf@sabrina.dei.unipd.it (ROBERTO AVANZI)
Subject: Re: This newsgroup has _nothing_ to do with musician Bob Dylan...
Organization: D.E.I. Universita' di Padova, Italia
Date: Thu, 21 Jan 1993 08:53:55 GMT

In article <KERS.93Jan18090316@cdollin.hpl.hp.com> kers@hplb.hpl.hp.com (Chris Dollin) writes:
>In article ... paul@taniwha.UUCP (Paul Campbell) writes:
>
>[Referring to The Magic Roundabout]
>
>   This Dylan was of course a dog (and a shaggy dog at that), and probably one
>   of the most obnoxious TV characters of all time :-)
>
>Dylan was the *rabbit*. The dog was *Dougal*.
>
>The educational systems getting worse all the time.
>--
>
>Regards, "I know three kinds: hot, cool, and 'what time does the tune start?'".
>Kers     [The Beiderbeck Connection]

One of the most popular comics character in italy is Dylan Dog by Silvio Bonetti
Editore publishing house. Dylan Dog is really cool (horror comics), but,again,
it has nothing to do with Dylan-the-OODL-from-Apple, or the musician, or
the poet.... I like all the first three and sadly i know too little of the 
fourth to judge.
Cheers
Roberto Avanzi

Newsgroups: comp.lang.dylan
From: jgmorris+@cs.cmu.edu (Greg Morrisett)
Subject: Re: OSs written in Lisp (was: Is GC really even necessary?)
Organization: School of Computer Science, Carnegie Mellon
Date: Fri, 22 Jan 1993 20:06:07 GMT

In article <BRENT.93Jan20131623@rcx1.ssd.csd.harris.com> brent@ssd.csd.harris.com (Brent Benson) writes:
>
>This got me thinking.  Is there any OS work being done in Lisp or
>Lisp-like languages for stock (non-Lisp machine) hardware?  I would
>appreciate references if you have them.  I'm well aware of the
>advantages of doing compiler work in Lisp---what are the advantages
>and disadvantages of doing OS work in Lisp?

The Fox project at CMU is interested in writing systems code in
ML-like languages.  We're looking at multi-threading, data layout,
code generation, and garbage collection issues among other things.
Some folks at NEC are working on a project called STING (see 1992 Lisp&FP).
STING has a similar goal, but uses scheme instead of ML.  Both
projects assume stock hardware.




-- 
-Greg Morrisett
 Carnegie Mellon Univ.
 jgmorris@cs.cmu.edu