From: David Steuber "The Interloper
Subject: OS wars and Lisp
Date: 
Message-ID: <3674be68.951024711@news.newsguy.com>
Why don't we all try to agree that everyone is going to have their own
preferences as to which operating system he uses and which Lisp
environment he prefers?  Every system is going to have its merits and
demerits, real or perceived.  This is particularly true among GUI
environments where most points boil down to a matter of taste, event
models notwithstanding.

All I want out of Lisp is sufficient agreement on the implementation
details of Common Lisp so that any production grade system I build in
it can be trivially ported to _any_ platform.  As far as I am
concerned, people have a choice in the OS they use and I don't want to
coerce them into using a particular operating system simply because it
is my personal favorite.

At the same time, I don't want others to coerce me into using their
favorite operating system.  It just isn't in the spirit of Open
Source, Freedom, or anything else that is advocated by people who
should respect the rights of other people to choose for themselves.

For those in the Lisp community, and those of us who are entering as
freshmen, the goal should be full source portability.  You know that a
much more hyped language out there is going for binary compatibility.
I actually hope that effort succeeds, since it will probably give
users more choice.  As a proponent of Open Source, I would settle for
source compatibility in Lisp so that anyone can build a CL composed
program on their system.  In the longer run, it would be desirable if
CL could compile into portable binary code so that those people who
think they have something wonderful in their proprietary software can
ship to anyone without source.

Feel free to flame away.  My shields are up and can radiate many terra
joules per second (a lot of watts).

--
David Steuber (ver 1.31.3a)
http://www.david-steuber.com
To reply by e-mail, replace trashcan with david.

May the source be with you...

From: Johan Kullstam
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <uogp5xuvl.fsf@res.raytheon.com>
········@david-steuber.com (David Steuber "The Interloper") writes:

[ snip of a very good point against gratuitous OS wars ]

> For those in the Lisp community, and those of us who are entering as
> freshmen, the goal should be full source portability.  You know that a
> much more hyped language out there is going for binary compatibility.
> I actually hope that effort succeeds, since it will probably give
> users more choice.  As a proponent of Open Source, I would settle for
> source compatibility in Lisp so that anyone can build a CL composed
> program on their system.  In the longer run, it would be desirable if
> CL could compile into portable binary code so that those people who
> think they have something wonderful in their proprietary software can
> ship to anyone without source.

now that you've gone and almost mentioned java, let me ask perhaps a
silly question.  java is two things, a language and virtual machine.
is it possible (or has it been done even) to compile lisp to a java
virtual machine target?

i say this because what lisp needs is a way for lisp applets to get
out there.  the way to recruit more lispers is to offer an easy road
to lisp.  erik naggum has a great page about worse-is-better and it
makes sense to me.

i was exposed to what little lisp i know through emacs.  (and
motivated by a general sense of dissatisfaction with fortran, C, C++
&c.)  one problem with the current lisp offering is that CL is so
heavyweight.  CMUCL takes 20 or so megs of ram to run.  while it is a
fine system, this is not helping us spread lisp through small
applications and mini hacks.

emacs allows small lisp hacks to enter the mainstream.  but many
people complain that emacs is too big.  can java virtual machine help
out?

-- 
johan kullstam
From: Erik Naggum
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <3122754670863558@naggum.no>
* Johan Kullstam <·······@idt.net>
| erik naggum has a great page about worse-is-better and it makes sense to
| me.

  let me hasten to add that this is Richard Gabriel's work, not mine.  it
  was floating around as LaTeX source when I got my hands on it, and I
  thought it would be important to make it more widely available.  (and
  Richard didn't even frown when I told him face to face, so I guess it's
  OK as far as it goes, but please don't forget who really wrote this.)

#:Erik
-- 
  man who cooks while hacking eats food that has died twice.
From: David Steuber "The Interloper
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <36792849.9175113@news.newsguy.com>
On 15 Dec 1998 10:55:25 -0500, Johan Kullstam <·······@idt.net>
claimed or asked:

% now that you've gone and almost mentioned java, let me ask perhaps a
% silly question.  java is two things, a language and virtual machine.
% is it possible (or has it been done even) to compile lisp to a java
% virtual machine target?

There is a Scheme to JVM .class compiler (Kawa).  As for CL, I don't
know.  The JVM and the bytecode it runs is rather geared towards Java.
This hasn't prevented other languages from being compiled to Java byte
codes.  There are quite a few of them in fact, but I don't recall the
URL to a list of them.

I can't help but think that a complete CL implementation in Java
bytecodes would be large and slow.  Java in Java proved to be very
slow, and limitations in the bytecode prevented a complete
implementation.  There may be a problem with CL for similar reasons.

Unix systems have standard C run times on them.  Because of the wide
spread use of the elf file format for executable code, everyone can
link to one of several common libc files.

I had the thought that it might be worth pursuing the idea that a
standard CL runtime could be created and shipped with POSIX System V
systems so that CL programs didn't need to ship their own personal
runtime.  They could just dynamically link with the one on the system.

I don't know how achievable that goal is.  Also, while it addresses
the shipping of applications, it does not address applets to run in
browsers.

One solution that I've seen used is to translate Lisp to C.  I don't
know if this has been done with Common Lisp.  This solution allows the
use of the existing libc files, but the other Lisp features are doomed
to duplication as gcd and maybe even the compiler will be in the
generated code.  If the gcd and compiler were additional shared
objects, then the distributed code could be comparable in size to C
code.

The downside to standard Lisp libraries is that they will have to be
versioned, like the libc library.  There will be only one
implementation of any version on a system.  That may not be the best
one.  In short, all the problems with distributing C programs or Java
programs will still exist.  I'm not thrilled with the current solution
to the versioning issue, but I have no better solution at hand.  There
is also the fact that different Lisp implementations have different
strengths, features, and extensions.  It may be necessary to tighten
the CL language standard, I don't know.

One thing I am sure of is that it will take people a lot smarter than
I am to solve this issue.  They will have to find ways to overcome the
bad rap that Lisp has among the masses.  The only thing I can think of
that can push Lisp back into the mainstream is for mainstream programs
to be written in it.  Keeping Lisp in the closet is not the way to
make it popular.

--
David Steuber (ver 1.31.3a)
http://www.david-steuber.com
To reply by e-mail, replace trashcan with david.

May the source be with you...
From: Erik Naggum
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <3122775809735246@naggum.no>
* ········@david-steuber.com (David Steuber "The Interloper")
| One thing I am sure of is that it will take people a lot smarter than I
| am to solve this issue.  They will have to find ways to overcome the bad
| rap that Lisp has among the masses.  The only thing I can think of that
| can push Lisp back into the mainstream is for mainstream programs to be
| written in it.  Keeping Lisp in the closet is not the way to make it
| popular.

  my advice is: simply ignore everybody who thinks Lisp has bad rap.
  popularity is the hall-mark of mediocrity.  what needs to be done is
  simply to make good things and let interested people know and come see.
  this is completely unrelated to masses, mainstreams, or closets, and it
  has the disquieting quality that it doesn't have room for more pondering
  or hesitation or procrastination.  it also has the unwelcome property
  that it is possible to measure the success of the approach by how many
  people come see.

  here's something I have done.  I designed a new protocol for my client,
  and held a presentation for a group of top-notch programmers from our
  customers.  the protocol syntax is Common Lisp.  nobody complained about
  parentheses, backslashes, the position of the colon in keywords, the
  semicolons used as the mark of a non-data response line, lists with the
  command as the first element, uppercase symbol names -- _none_ of the
  regular complaints.  after a couple hours, all of them were excited about
  what we could do with this new protocol, and a few good suggestions came
  in during lunch and when we were shaking hands to leave.  it wasn't until
  some time afterwards that I came to realize that _none_ of the complaints
  we are _supposed_ to hear about Lisp were raised.  I didn't expect them,
  didn't invite them, and just explained what I had done, so maybe these
  complaints don't _exist_ unless you invite them.

  there's a new programmer in my office (I work mostly from home).  he had
  a bunch of really odd questions about Common Lisp, which we agreed came
  from his complete unfamiliarity with the language.  I showed him some
  code, explained how I had done a few simple things, and he started to
  talk about textbooks and how it looked like something he would want to
  learn, and how he had suffered from C++ blindness.  that took 10 minutes,
  and I was already exhausted from working all night to get a working demo
  for the presentation and from talking for four hours straight.

  I _really_ don't think people think Lisp is bad unless _you_ appear to be
  apologetic to begin with.  just do good work, and people listen no matter
  what they thought to begin with.

  no excuses.  no apologies.  just do it.

#:Erik
-- 
  man who cooks while hacking eats food that has died twice.
From: Rainer Joswig
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <joswig-1612981338590001@pbg3.lavielle.com>
In article <················@naggum.no>, Erik Naggum <····@naggum.no> wrote:

>   no excuses.  no apologies.  just do it.

Yep.

-- 
http://www.lavielle.com/~joswig
From: Martin Rodgers
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <MPG.10e1cb3a9faeea1e989d70@news.demon.co.uk>
In article <·······················@pbg3.lavielle.com>, 
······@lavielle.com says...

> >   no excuses.  no apologies.  just do it.
> 
> Yep.

Next summer, the last line of my sig.file will become a t-shirt.
I'm tired of subtlety. This is my CV.
-- 
Remove insect from address to email me | You can never browse enough
     will write code that writes code that writes code for food
From: Paolo Amoroso
Subject: Lisp-based protocols [was Re: OS wars and Lisp]
Date: 
Message-ID: <367b3b45.115745@news.mclink.it>
On 16 Dec 1998 05:43:29 +0000, Erik Naggum <····@naggum.no> wrote:

>   here's something I have done.  I designed a new protocol for my client,
>   and held a presentation for a group of top-notch programmers from our
>   customers.  the protocol syntax is Common Lisp.  nobody complained about

If I get things right, you designed a--network?--protocol whose commands
can be parsed with READ.

What are the possible strategies for executing or serving incoming
commands/requests with such a protocol? I can think of at least the
following:

1) direct evaluation with EVAL
2) interpretation

Option 1) has potential security problems, but this may not be an issue for
systems running in a trusted environment.


Paolo
-- 
Paolo Amoroso <·······@mclink.it>
From: Erik Naggum
Subject: Re: Lisp-based protocols [was Re: OS wars and Lisp]
Date: 
Message-ID: <3122924085350322@naggum.no>
* ·······@mclink.it (Paolo Amoroso)
| If I get things right, you designed a--network?--protocol whose commands
| can be parsed with READ.

  yes.  for two reasons: Common Lisp already has a well-defined syntax for
  all the object types we need, and the syntax we use is fairly trivial to
  generate and parse for non-Lisp programs, too.

| What are the possible strategies for executing or serving incoming
| commands/requests with such a protocol?

  two points: I don't call READ on the stream itself.  I implemented a
  stream with memory, so I set the stream's mark, eat characters until I
  see a newline, call READ-FROM-STRING on the STREAM-SUBSTRING, and if it
  barfs on end of file, I set up a timeout and eat characters until the
  next newline comes along.  the timeout is cancelled and the mark is reset
  when READ-FROM-STRING succeeds.  the timeout action is simply to emit an
  error message and reset the mark, effectively cancelling the input.
  (this simple setup makes it possible to handle all the clients' input
  streams in one Lisp process, dramatically reducing scheduler overhead.)

| I can think of at least the following:
| 
| 1) direct evaluation with EVAL
| 2) interpretation
| 
| Option 1) has potential security problems, but this may not be an issue for
| systems running in a trusted environment.

  the list of functions that may be called is a property of the stream, and
  if the first element of a list passes this test, the arguments are
  checked to be symbols (which have values) or treated as constants, and
  then I do (apply #'funcall <list>).  running with full safety in the
  functions that accept these arguments, errors are reported back to the
  client with a list (ERROR "<error message>").  the functions basically
  hand off the request to a running process or start up a new process if
  they cannot return immediately with a value.

  this has saved me a _lot_ of work that would otherwise have been spent on
  protocol syntax design and such silly details.  people seem to have
  bought it, and I'm quite happy.  (now, the annoying thing is that TCP
  connections are such unruly beasts -- back to work.)

#:Erik
-- 
  Attention, Republican members of the House Judiciary Committee!  We have
  intercepted a coded transmission from Bill Clinton to Saddam Hussein that
  puts your life in jeopardy.  Clinton is prepared to cease fire if all of
  you are killed by Iraqi terrorists, whom he won't prosecute.  Be warned!
From: David Steuber "The Interloper
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <367b75b5.63525344@news.newsguy.com>
On 16 Dec 1998 05:43:29 +0000, Erik Naggum <····@naggum.no> claimed or
asked:

% * ········@david-steuber.com (David Steuber "The Interloper")
% | One thing I am sure of is that it will take people a lot smarter than I
% | am to solve this issue.  They will have to find ways to overcome the bad
% | rap that Lisp has among the masses.  The only thing I can think of that
% | can push Lisp back into the mainstream is for mainstream programs to be
% | written in it.  Keeping Lisp in the closet is not the way to make it
% | popular.
% 
%   my advice is: simply ignore everybody who thinks Lisp has bad rap.
%   popularity is the hall-mark of mediocrity.  what needs to be done is
%   simply to make good things and let interested people know and come see.
%   this is completely unrelated to masses, mainstreams, or closets, and it
%   has the disquieting quality that it doesn't have room for more pondering
%   or hesitation or procrastination.  it also has the unwelcome property
%   that it is possible to measure the success of the approach by how many
%   people come see.

Well, it is your right to ignore me.

I disagree that popularity is the hall-mark of mediocrity.  Sure, a
lot of popular software is mediocre.  That doesn't really constitute
proof.

In deference to Erik, I will stop making judgements about the public
perception of Lisp.  It is certainly a moot point if the next killer
app rolls around and is written entirely in Lisp.

Instead, what I will try to do is find a way to get a standard Lisp
runtime into the state of ubiquity and evangelize that cause.  I would
like for Lisp programs to have small distribution files.  The reason
is that I would personally find it convenient.

CMUCL is a public domain implementation.  Software doesn't come with
more freedom than that.  So for me, the logical choice is to find a
way to modularize CMUCL so that a versionable runtime can be made
available on many machines so that Lisp binaries can have small
distribution files.  By small, I don't mean 7 meg with gzip -9.  I
mean something that would still fit on a floppy disk.

I think that using Common Lisp as a scripting language could also be
supported by the same mechanism.

#!/usr/local/bin/lisp

(format t "Lisp rules!!!")

--
David Steuber (ver 1.31.3a)
http://www.david-steuber.com
To reply by e-mail, replace trashcan with david.

May the source be with you...
From: Martin Rodgers
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <MPG.10e4916d25cf5798989d7e@news.demon.co.uk>
In article <·················@news.newsguy.com>, ········@david-
steuber.com (David Steuber "The Interloper") says...

> Well, it is your right to ignore me.

I killfiled him earlier this year, when all he had to say were flames.
(Apparently because I was paid to use NT.) Of course, I'm not 
recommending that you do the same!

> I disagree that popularity is the hall-mark of mediocrity.  Sure, a
> lot of popular software is mediocre.  That doesn't really constitute
> proof.

I've been _never_ bothered with popularity. Employment would be useful, 
tho. It helps if you have a client or two. If that's "popularity", then a 
little bit is desirable.

Of course, anyone who knows me never lets me near a client. ;) So I'm 
only talking about other people. I'll happily tell anyone who'll listen 
about all kinds of incredible things that can be done with software.
Bits that describe bits that describe bits, etc.
 
> In deference to Erik, I will stop making judgements about the public
> perception of Lisp.  It is certainly a moot point if the next killer
> app rolls around and is written entirely in Lisp.

It's also moot when an employer simply says they're not interested in 
Lisp, and could you know write this C++ app that they want. If they go as 
far as picking your tools for you, it's time to look elsewhere for work.
 
> Instead, what I will try to do is find a way to get a standard Lisp
> runtime into the state of ubiquity and evangelize that cause.  I would
> like for Lisp programs to have small distribution files.  The reason
> is that I would personally find it convenient.

So would I. I've been flamed for trying to explain why this is important. 
It's important because there's a demand for small apps. So when you do 
find someone who doesn't care what tools you use, they'll still care how 
small the code is. They may be wrong, but they care.

These days, people like slagging off bloated apps. It could just be that 
this is all the fault of C++ and MS, or a conspiracy between software and 
hardware vendors to sell more RAM and hard drives (Intel, Seagate, etc).

We're all living in the gutter, but some of us are looking at the stars.
Paraphrased, we're all programmers, but some of us are looking at bigger 
problems. Every tool has a pain threshold for a particular problem 
domain. Above that level of pain, solutions are inconceivable. All we can 
see is the pain. (This may be one reason for C/C++ advocates to use the 
"Hello, World" example - it's almost painless in _any_ language.) What I 
love about Lisp is that it has a variable threshold.

The good news is that the mainstream world is slowly discovering what we 
Lispers have known for years. Note how many ideas first used in Lisp are 
turning up in other languages and software systems. Regardess of whether 
we tell people about Lisp or not, the world is moving closer to Lisp.

Now, if we can all survive the next few years...
 
> CMUCL is a public domain implementation.  Software doesn't come with
> more freedom than that.  So for me, the logical choice is to find a
> way to modularize CMUCL so that a versionable runtime can be made
> available on many machines so that Lisp binaries can have small
> distribution files.  By small, I don't mean 7 meg with gzip -9.  I
> mean something that would still fit on a floppy disk.

10 years ago I used Cambridge Lisp, which had modular features. It could 
dynamically load and unload fastload modules on demand. This ran on a 
machine with only 1 MB of RAM! Of course, it wasn't anything as nice as 
Common Lisp, and didn't even use a GUI, altho you could add that. The 
compiler used native code and graphical apps ran as fast as anything 
else. I'd love to see Linux version.

A few years ago, I wrote a tool for putting a magazine issue onto a 
floppy, complete with high res graphics. I'd love to have used Lisp, but 
no Common Lisp system could do that. I didn't have time to find an 
alternative Lisp, and I still don't see any CL systems that can deliver 
code that small. In fact, the choice wasn't even mine to make.

While this may be a special case, that was what the client needed. No 
arguments. The real world can be harsh. Hardware limits are hard. Time 
was short. Under that kind of pressure, it's hard to sell the idea of 
using Lisp. If this sounds bad, I've heard worse. Imagine justifying the 
use of C by saying that you need to write an MPEG driver in assembly!
It's stupid but it happens. 

So the final problem is always _people_. So far, nobody has told me that 
it I can't put a magazine onto a floppy, but that day may come. I can 
just laugh and tell them how I did it...

I have a CV with attitude. It's in my sig.file.
 
> I think that using Common Lisp as a scripting language could also be
> supported by the same mechanism.
>
> #!/usr/local/bin/lisp
> 
> (format t "Lisp rules!!!")
 
This is the idea behind Guile. It works well. People are already doing 
neat things with it. Same with CLISP. In fact, CLISP should be a better 
scripting tool, if only because of performance and maturity.
-- 
Remove insect from address to email me | You can never browse enough
     will write code that writes code that writes code for food
From: Marco Antoniotti
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <lwzp8ojwhv.fsf@copernico.parades.rm.cnr.it>
········@david-steuber.com (David Steuber "The Interloper") writes:

> On 15 Dec 1998 10:55:25 -0500, Johan Kullstam <·······@idt.net>
> claimed or asked:
> 
> % now that you've gone and almost mentioned java, let me ask perhaps a
> % silly question.  java is two things, a language and virtual machine.
> % is it possible (or has it been done even) to compile lisp to a java
> % virtual machine target?
> 
> There is a Scheme to JVM .class compiler (Kawa).  As for CL, I don't
> know.  The JVM and the bytecode it runs is rather geared towards Java.
> This hasn't prevented other languages from being compiled to Java byte
> codes.  There are quite a few of them in fact, but I don't recall the
> URL to a list of them.
> 

AFAIK, Kawa is an interesting beast, but it does not use the JVM as
published by Sun.  It uses some extensions.

> 
> One solution that I've seen used is to translate Lisp to C.  I don't
> know if this has been done with Common Lisp.  This solution allows the
> use of the existing libc files, but the other Lisp features are doomed
> to duplication as gcd and maybe even the compiler will be in the
> generated code.  If the gcd and compiler were additional shared
> objects, then the distributed code could be comparable in size to C
> code.

I won't comment on this waiting for Duane Rettig's note :)  My feeling
is that CMUCL is far, far superior to GCL (and its ancestors and
siblings).

Cheers

-- 
Marco Antoniotti ===========================================
PARADES, Via San Pantaleo 66, I-00186 Rome, ITALY
tel. +39 - (0)6 - 68 10 03 17, fax. +39 - (0)6 - 68 80 79 26
http://www.parades.rm.cnr.it
From: Craig Brozefsky
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <87n24o2eue.fsf@piracy.red-bean.com>
Marco Antoniotti <·······@copernico.parades.rm.cnr.it> writes:

> AFAIK, Kawa is an interesting beast, but it does not use the JVM as
> published by Sun.  It uses some extensions.

Nope.  I've run it in the stock JDK.
From: David Steuber "The Interloper
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <367a72b7.62759112@news.newsguy.com>
On 16 Dec 1998 09:56:28 +0100, Marco Antoniotti
<·······@copernico.parades.rm.cnr.it> claimed or asked:

% > One solution that I've seen used is to translate Lisp to C.  I don't
% > know if this has been done with Common Lisp.  This solution allows the
% > use of the existing libc files, but the other Lisp features are doomed
% > to duplication as gcd and maybe even the compiler will be in the
% > generated code.  If the gcd and compiler were additional shared
% > objects, then the distributed code could be comparable in size to C
% > code.
% 
% I won't comment on this waiting for Duane Rettig's note :)  My feeling
% is that CMUCL is far, far superior to GCL (and its ancestors and
% siblings).

One idea that I've had (I'm sure I'm not the only one) was to find a
way to get CMUCL's Lisp binary into /usr/bin and the CMUCL lisp.core
file into /usr/lib (or similar places) so that a CMUCL program could
be distributed as just the files that contained the program specific
code.  /usr/bin/lisp and /usr/lib/lisp.core would constitute the run
times in the same way as libc.

This might not be such a difficult problem to deal with.  The CMUCL
community can agree on a runtime distribution and create the necessary
RPM or whatever to get it into the popular Linux and other Un*x
distributions as standard components.  There would also be a place to
get the runtime for retrofitting into an existing installation.

How difficult would it be for the CMUCL maintainers to modify CMUCL to
support this or a similar model, and would they want to?

On a side note, I've got my networking issues all sorted out.  I just
need to port my mail and news reading activity to Linux.  Anyone doing
this with XEmacs?  I built and installed fetchmail last night.  I just
need to set it up to retrieve mail from my three accounts.  I need to
get my address book over to Linux.  I also need to set up mail folders
under Linux.

So who here uses XEmacs for mail and news that is willing to offer me
some advice?

--
David Steuber (ver 1.31.3a)
http://www.david-steuber.com
To reply by e-mail, replace trashcan with david.

May the source be with you...
From: Pierre Mai
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <87iufaoz3q.fsf@orion.dent.isdn.cs.tu-berlin.de>
········@david-steuber.com (David Steuber "The Interloper") writes:

> One idea that I've had (I'm sure I'm not the only one) was to find a
> way to get CMUCL's Lisp binary into /usr/bin and the CMUCL lisp.core
> file into /usr/lib (or similar places) so that a CMUCL program could
> be distributed as just the files that contained the program specific
> code.  /usr/bin/lisp and /usr/lib/lisp.core would constitute the run
> times in the same way as libc.

ls -l /usr/bin/lisp
-rwxr-xr-x   1 root     root        78692 Nov  9 16:19 /usr/bin/lisp
ls -l /usr/lib/cmucl/
total 34055
-rw-r--r--   1 root     root        11543 Nov  9 16:18 config.lisp
-rw-r--r--   1 root     root          337 Nov  9 16:18 hemlock11.cursor
-rw-r--r--   1 root     root          296 Nov  9 16:18 hemlock11.mask
-rw-r--r--   1 root     root     12443648 Nov  9 16:18 kernel.core
-rw-r--r--   1 root     root     22212608 Nov  9 16:18 lisp.core
-rwxr-xr-x   1 root     root        61308 Nov  9 16:19 motifd
lrwxrwxrwx   1 root     root           29 Dec  1 23:44 site-init.lisp -> /var/lib/cmucl/site-init.lisp
drwxr-xr-x   2 root     root         1024 Dec 14 15:25 subsystems

And while CMUCL didn't come with my distribution of Debian 2.0, it
will come with Debian 2.1 (due in December IIRC) on CD, IMHO.  It will 
be in the same form that my C++ compiler is in, i.e. *.deb, and I'll
have the same choice at installation time (or any time after that) of
installing it, that I had with my C++ compiler.  Users of older
Debians can easily install cmucl from their favourite Debian ftp
site... Either download manually and do dpkg -i cmucl_2.4.7.deb, or
use some funky direct-ftp-install tools (apt-get?)...

> How difficult would it be for the CMUCL maintainers to modify CMUCL to
> support this or a similar model, and would they want to?

Peter's CVS Linux version of CMUCL is already thus modified, and the
*.deb files can be easily via alien to rpm, IMHO.

> So who here uses XEmacs for mail and news that is willing to offer me
> some advice?

Just start out with a 5.6.* Gnus, and start with reading news via
NNTP.  IMHO it's useful to have a local news-server (like INN+suck, or 
maybe leafnode), rather than relying on Gnus off-line mail-support,
just like it's IMHO preferable to use fetchmail, rather than directly
letting Gnus work via POP/IMAP...  OTOH I hear that Gnus-agent is
really "cool(tm)", so maybe check it out....

After News works, set-up Mail-reading.  IMHO Gnus info-documentation
is enough to get everything up and running, if read carefully.  Then
there's also gnu.emacs.gnus (IIRC), but don't post FAQs to that
newsgroup (like "how do I set-up mail-reading?" ;), cause they are
constantly being bombarded with this...  I still think that reading
Gnus info-nodes carefully clarifies much (in newer versions of Gnus at 
least)...

Regs, Pierre.

-- 
Pierre Mai <····@acm.org>               http://home.pages.de/~trillian/
  "One smaller motivation which, in part, stems from altruism is Microsoft-
   bashing." [Microsoft memo, see http://www.opensource.org/halloween1.html]
From: Christopher R. Barry
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <873e6ee25e.fsf@2xtreme.net>
········@david-steuber.com (David Steuber "The Interloper") writes:


[...]

> 
> So who here uses XEmacs for mail and news that is willing to offer me
> some advice?

The FAQs and documentation at:
http://www.xemacs.org
http://www.gnus.org

and the nice people at:
news://comp.emacs.xemacs

worked for me. They should work for you to.

Christopher
From: David Steuber "The Interloper
Subject: Far afield (was Re: OS wars and Lisp)
Date: 
Message-ID: <368266e8.4213468@news.newsguy.com>
On Fri, 18 Dec 1998 00:08:45 GMT, ······@2xtreme.net (Christopher R.
Barry) claimed or asked:

% ········@david-steuber.com (David Steuber "The Interloper") writes:
% 
% [...]
% > 
% > So who here uses XEmacs for mail and news that is willing to offer me
% > some advice?
% 
% The FAQs and documentation at:
% http://www.xemacs.org
% http://www.gnus.org
% 
% and the nice people at:
% news://comp.emacs.xemacs
% 
% worked for me. They should work for you to.

Well, I have mail working (via fetchmail and sendmail).

News has been more problematic.  There seems to be some built in
assumption that my local user name is the same one I use for a third
party news service.  I am now looking at suck and inn.  Anyone who
looks at the headers will see that I have gone and booted into NT for
a news fix.  Linux's uptime was only 3 days.

The price of freedom is not cheap.  I have become a vampire.  I think
I last saw the sun Wednesday of last week.  Something is wrong with
this picture.

In the meantime, I've managed to forget enough of Graham that I need
to start the book over.

So, to recap:

1)  I decided that Lisp would be the ideal language for an application
I wanted to write.

2)  I ended up getting CMUCL.

3)  To get CMUCL, I installed Linux.

4)  To avoid having to boot to NT all the time for mail and news I
tried to shift these functions over to Linux.

5)  I needed new hardware to get Linux on the Internet

6)  I spent a bunch of time learning to just get started with VM in
XEmacs

7)  I am still struggling with gnus.

8)  I haven't done any Lisp programming.


--
David Steuber (ver 1.31.3a)
http://www.david-steuber.com
To reply by e-mail, replace trashcan with david.

May the source be with you...
From: Kelly Murray
Subject: Re: Far afield (was Re: OS wars and Lisp)
Date: 
Message-ID: <36815E08.37EBC4F4@IntelliMarket.Com>
David Steuber The Interloper wrote:
[ tons of wasted time on free software, no lisp written ]

It can be interesting to hear a newbie's experiences,
but clearly you've taking the long hard road to getting
a lisp application developed.  
I recommend CLISP for lisp newbie's, it may even run
under NT out-of-the-box.  

I don't recall you're application area, but I wanted
to take the opportunity to point out that in my approach it is possible
for someone to develop Charlotte applications using only a web browser.
Which means one needs to install nothing, 
and could start coding immediately, using NT, MAC, Linux, or WebTV.
Of course, I haven't yet been able to document it sufficiently,
or finish the rudimentary "IDE", but I should be getting
that job done in the next few months, as my brother will
be learning and developing Charlotte lisp apps probably using
only WebTV to access my server.

-Kelly Murray  ···@intellimarket.com
From: Martin Rodgers
Subject: Re: Far afield (was Re: OS wars and Lisp)
Date: 
Message-ID: <MPG.10ec686e13d7eb03989dae@news.demon.co.uk>
In article <·················@IntelliMarket.Com>, ···@IntelliMarket.Com 
says...

>  recommend CLISP for lisp newbie's, it may even run
> under NT out-of-the-box.  
 
It does. There's a Win32 version now.
-- 
Remove insect from address to email me | You can never browse enough
     will write code that writes code that writes code for food
From: David Steuber
Subject: Re: Far afield (was Re: OS wars and Lisp)
Date: 
Message-ID: <m390fxkpfc.fsf@solo.david-steuber.com>
Kelly Murray <···@IntelliMarket.Com> writes:

> David Steuber The Interloper wrote:
> [ tons of wasted time on free software, no lisp written ]

I wouldn't say it is a complete waste of time.  I am learning stuff.
Just not the stuff I expected when I started out.

> It can be interesting to hear a newbie's experiences,
> but clearly you've taking the long hard road to getting
> a lisp application developed.  
> I recommend CLISP for lisp newbie's, it may even run
> under NT out-of-the-box.  

I think I'm still on the on-ramp.  However, I have come a long way.  I 
am currently using a machine with no Microsoft software on it.  I set
up leafnode on my other machine that does have a multi-boot
configuration.  Ok, some assembly (not code) was required.

> I don't recall you're application area, but I wanted
> to take the opportunity to point out that in my approach it is possible
> for someone to develop Charlotte applications using only a web browser.
> Which means one needs to install nothing, 
> and could start coding immediately, using NT, MAC, Linux, or WebTV.
> Of course, I haven't yet been able to document it sufficiently,
> or finish the rudimentary "IDE", but I should be getting
> that job done in the next few months, as my brother will
> be learning and developing Charlotte lisp apps probably using
> only WebTV to access my server.

I like having my own CPU and storage.  I really like having my own
network.  As I become more proficient with Linux, I expect to spend my 
money on hardware, not software.

I expect to tackle CL before the end of the year.  My environment is
now mostly set up.  It's been a lot of work, but I think it was worth
it.
From: CsO
Subject: Re: Far afield (was Re: OS wars and Lisp)
Date: 
Message-ID: <75qu49$rg4$1@news7.svr.pol.co.uk>
David Steuber "The Interloper" wrote in message
<················@news.newsguy.com>...
>1)  I decided that Lisp would be the ideal language for an application
>      I wanted to write.
>2)  I ended up getting CMUCL.
>3)  To get CMUCL, I installed Linux.
>4)  To avoid having to boot to NT all the time for mail and news I
>      tried to shift these functions over to Linux.
>5)  I needed new hardware to get Linux on the Internet
>6)  I spent a bunch of time learning to just get started with VM in
>      XEmacs
>7)  I am still struggling with gnus.
>8)  I haven't done any Lisp programming.
9) gosub interest.next()
10) goto 8
From: Rainer Joswig
Subject: Re: Far afield (was Re: OS wars and Lisp)
Date: 
Message-ID: <joswig-2312981633320001@pbg3.lavielle.com>
In article <············@news7.svr.pol.co.uk>, "CsO"
<···@colino.freeserve.co.uk> wrote:

> David Steuber "The Interloper" wrote in message
> <················@news.newsguy.com>...
> >1)  I decided that Lisp would be the ideal language for an application
> >      I wanted to write.
> >2)  I ended up getting CMUCL.
> >3)  To get CMUCL, I installed Linux.
> >4)  To avoid having to boot to NT all the time for mail and news I
> >      tried to shift these functions over to Linux.
> >5)  I needed new hardware to get Linux on the Internet
> >6)  I spent a bunch of time learning to just get started with VM in
> >      XEmacs
> >7)  I am still struggling with gnus.
> >8)  I haven't done any Lisp programming.
> 9) gosub interest.next()
> 10) goto 8

Maybe this macro from my core Lisp library will help:

(defmacro ensure-success (&body body)
  `(handler-bind ((system-unusable-error (lambda (condition)
                                           (print 'error)
                                           (ensure-have-a-mac)
                                           (invoke-restart 'got-a-mac))))
     (loop do (with-simple-restart (got-a-mac "try again")
                (return ,@body)))))

(ensure-success
  (do-some-lisp-programming))

-- 
http://www.lavielle.com/~joswig
From: Jeff Dalton
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <x2ogp1v2k3.fsf@gairsay.aiai.ed.ac.uk>
Marco Antoniotti <·······@copernico.parades.rm.cnr.it> writes:

> > One solution that I've seen used is to translate Lisp to C.  I don't
> > know if this has been done with Common Lisp.  This solution allows the
> > use of the existing libc files, but the other Lisp features are doomed
> > to duplication as gcd and maybe even the compiler will be in the
> > generated code.  If the gcd and compiler were additional shared
> > objects, then the distributed code could be comparable in size to C
> > code.
> 
> I won't comment on this waiting for Duane Rettig's note :)  My feeling
> is that CMUCL is far, far superior to GCL (and its ancestors and
> siblings).

1. GCL/AKCL/KCL and systems derived from those are not the only CL-to-C
compilers.

2. GCL (and its ancestors at least) are significantly superior to
CMUCL for some purposes.  I use GCL far, far more than CMUCL, even
though I have access to both.  (CMUCL is an excellent system, but
it's not always the best choice.)

-- jd
From: Raymond Toy
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <4ng1ads7ih.fsf@rtp.ericsson.se>
>>>>> "Jeff" == Jeff Dalton <····@gairsay.aiai.ed.ac.uk> writes:

    Jeff> 2. GCL (and its ancestors at least) are significantly
    Jeff>    superior to
    Jeff> CMUCL for some purposes.  I use GCL far, far more than
    Jeff> CMUCL, even though I have access to both.  (CMUCL is an
    Jeff> excellent system, but it's not always the best choice.)

I'm curious in what ways GCL is superior.  No flame wars.  I'm just
curious.  The only reason I run gcl these days is because maxima works 
better there (but I rarely use that), and because it's smaller.  But
for small things, I use clisp instead.

Ray
From: Paolo Amoroso
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <367a3b3f.109596@news.mclink.it>
On Wed, 16 Dec 1998 04:01:03 GMT, ········@david-steuber.com (David Steuber
"The Interloper") wrote:

> This hasn't prevented other languages from being compiled to Java byte
> codes.  There are quite a few of them in fact, but I don't recall the
> URL to a list of them.

Try:

	http://grunge.cs.tu-berlin.de/~tolk/vmlanguages.html


Paolo
-- 
Paolo Amoroso <·······@mclink.it>
From: Rainer Joswig
Subject: Re: OS wars and Lisp
Date: 
Message-ID: <joswig-1812980128520001@194.163.195.67>
In article <················@news.newsguy.com>, ········@david-steuber.com
wrote:

> One solution that I've seen used is to translate Lisp to C.  I don't
> know if this has been done with Common Lisp.

KCL (AKCL, GCL), CLICC, Eclipse CL, WCL, ...

> The downside to standard Lisp libraries is that they will have to be
> versioned, like the libc library.

True. Fortunately the MCL 4.2 shared libraries are absolutely stable.
They seem to be kind of a local maximum. Since CL
is a mature language, you can expect, once the bugs are gone,
to have very stable libraries plus a fe patch files.

> The only thing I can think of
> that can push Lisp back into the mainstream is for mainstream programs
> to be written in it.

just do it

-- 
http://www.lavielle.com/~joswig