Subject: Hello

From: [email-masked] (Erann Gat)
Date: Mon, 17 Jul 95 15:09:19 PDT

Hello everyone,

Although I have been using CLisp for about a year I just now signed up for
the mailing list.  (Don't ask me how I missed it for all this time -- I don't
know myself!)  I'd like to tell you a bit about what I'm using it for, and
find out who is currently doing active development on it.

I work at the NASA Jet Propulsion Lab, which is responsible for unmanned
exploration of the solar system for NASA.  I am involved in a project to
develop an advanced architecture for controlling autonomous spacecraft.
This project is part of a project called New Millenium whose purpose is to
develop inexpensive spacecraft for the year 2000 and beyond (hence the name).
I am using CLisp to prototype a spacecraft executive based on a control
methodology called conditional sequencing.  I won't bore you with the
details; if anyone is interested, contact me.

The current project is only a prototype, but I am also interested in using
Lisp for actual flight code.  I am a bit of a lone warrior in this, as Lisp
is widely perceived by people in NASA to be too big and slow for "real" work.
My approach is, rather than arguing with people, to instead build working
systems that meet all the performance requirements.  Towards this end, I and
a student of mine (with considerable help from Bruno) have ported CLisp (the
January 1995 version) to vxWorks, which is a real-time operating system that
is one of the lead candidates for use on flight hardware.

So that's what I'm up to.  I am interested in hearing from people who are
actively developing CLisp, especially if anyone else out there is interested
in using it in a cross-compiled or embedded environment.  Also, is anyone
working on lightweight threads?

Erann Gat
[email-masked]

---

From: [email-masked] (Peter Dudey Drake)
Date: Mon, 17 Jul 95 16:39:07 PDT

Date: Tue, 18 Jul 95 00:15:27 +0200
   From: [email-masked] (Erann Gat)

Web page!  Web page!

Take a look at Paul Graham's _On_Lisp_.  It's a fabulous book, and it
has an example where Lisp does some numerical computation faster than
C.

+-     PETER DUDEY DRAKE      279-D SE Lilly Ave.,  Corvallis, OR  97333     -+
|       MS student in Artificial Intelligence, Oregon State University        |
|                           Food is for the weak.                             |
+-  [email-masked]        (finger [email-masked])  -+

---

From: Marcus Daniels <[email-masked]>
Date: Tue, 18 Jul 1995 01:00:49 GMT

>>>>> "Erann" == Erann Gat <[email-masked]> writes:

Erann> So that's what I'm up to.  I am interested in hearing from
Erann> people who are actively developing CLisp, especially if anyone
Erann> else out there is interested in using it in a cross-compiled or
Erann> embedded environment.  Also, is anyone working on lightweight
Erann> threads?

CLISP is a considerable distance from being truly cross-buildable.
lisp.run can be cross-compiled using GCC with relatively little fuss.
I've never tried Lisp cross-compilation there is some
support, and it has been done for at least one platform (Atari).  
Another problem is that memory images aren't portable.  

The only thing close to multiprocessing I've ever done with CLISP
is with PVM.  Then there is ILU, which should not be too hard
to get running now that there is a FFI, and since ILU 1.8 has
a single-threaded example.  I know.. a far cry from true Lisp threads.

For the next release, the only thing I expect to add is support for
GNU gettext (along with our bug fixes).  That is what I'm working on
in my free time.  Also, I have a BFD-based dynamic linker moseying
toward usability that I hope to use for loading CLISP modules.
(http://sayre.sysc.pdx.edu:8001/~marcus/dlbfd.tar.gz)

If anyone is interested in doing CLISP development, perhaps it would
be good for us to setup a net-accessible CVS source tree.  For the
time being, I can't provide a host for this.

---

From: Don Cohen <[email-masked]>
Date: Tue, 18 Jul 95 10:01:24 PDT

widely perceived by people in NASA to be too big and slow for "real" work.
Not only NASA, of course.  The too big seems particularly galling to me,
since several good lisps (inc CLISP) run in what's rapidly becoming a
negligible amount of space; the too slow has often annoyed me coming from
people who don't even have concrete speed requirements.  (Slower than the
corresponding C program doesn't seem relevant to me - it's not a race.)

Cross compiling: since the lisp code is byte compiled, I had originally
expected that clisp would be compiled code compatible across all platforms.
It turns out that this is not true.  But it's close.  I spent a little
time looking into how to make it so, but didn't actually do it.  I really
don't think it's difficult, except for macros that expand differently for
different machines.  I'm pretty sure all the system supplied macros could
be easily fixed to compile into the same byte code for all machines (put
the machine dependence into functions called by the expansion).  Of course,
the programmer would be responsible for his own macros.

Threads: That's something else I'd have liked, but haven't actually needed
yet.  There has been some mailing list discussion on this topic.
I don't know enough about the internals to know how hard it is to do.
Unfortunately, I'd guess it IS necessary to know a lot about the internals
of clisp in order to know what is needed.  Thus, even if it's not actually
hard to do, it might be hard to find out or to get someone who knows to do
it.

P.S. on GC - I believe the normal way to avoid GC is to write your code
to avoid allocating space - not natural in lisp, but it can be done.