🚀 go-pugleaf

In general, it has been many years since I found any paper whose title
was "xxx in Lisp" was any more interesting than a paper whose title
was "xxx".  Lisp is a general purpose programming language and
anything that can be done in other languages, good or bad, can be done
in Lisp.  That doesn't mean I don't think things are worth doing in
Lisp--it means the measure I use of goodness for the paper is how good
the work is, not whether it was done in Lisp.

I don't see any reason to suppose that worms work any differently in
Lisp than in any other language.  I think "simulating worms" is pretty
much like "running real worms" when you start to ask questions like
how and when to open network connections.  A simulation does not
require actual network connections.  But whether you are opening real
connections or not, I don't think the sample program you wrote is 
illustrative of the investment I expect to see in someone who is doing
serious work in "agents"--it looks more like a quickie hack done with
dangerously few safeguards.  It shows little evidence of thought about the
real control issues that would go into any such serious work.

Also, in most implementations I know of, your sample program does NOT
create "programs" nor does it "clog computers".  It simply infinitely
recurses.  (It might create multiple processes in KCL or its
descendants, which spawned subprocesses for compilation, but that's
just a sign of poor workmanship of the creator of the Lisp
implementation, not a feature of Lisp.)  It is true that worms and
viruses thrive on programmer errors, but there is nothing especially
Lisp-specific to this particular design error--just a calculated (and
documented) trade-off by some implementor which turned out not to pay
off well in some situations.

If there is some good reason to study worms, I hope that study is done
privately by agencies with APPROPRIATE FACILITIES AND SAFEGUARDS FOR
SERIOUS ISOLATION, not in the open on machines like Lisp Machines which are
designed for use in an open network, not a closed-off one.

I doubt strongly that any enlightenment will come from what you
propose.  And if someone manages to write a good sample to help you, I
can see a lot of harm openly sharing such a sample.  Further, if you
aren't expert enough to write that good sample yourself, then you
perhaps aren't expert enough to know if you have appropriately
contained your project.

I'm sorry if this sounds harsh.  I mean no slight of you personally.
I do not know you or your credentials, and none of my remarks are
based on any assessment of you personally--only an assessment of this
single message you've sent.  I simply don't see within it what it
would take to make me feel comfortable about your query.  The last
thing the Lisp industry needs is to be associated with publicity about
the rebirth of or next generation of worms...

I strongly urge you not to pursue this work, and I urge my colleagues
in the Lisp community not to contribute to this effort without first
verifying that appropriate safeguards are being taken.  I especially
think a casual sharing of "helpful hints for worm-building" over SLUG
is a bad idea.  Basically,  I'd say: "just say no to this can of worms".
(Sorry, couldn't resist.)
 -kmp