From: Don Hopkins <don@brillig.umd.edu>
Subject: Gnumacs lisp message passing
Date: 4 March 1986 at 21:06:46 GMT+1
To: rms@prep.ARPA
Cc: don@mimsy.umd.edu


I am taking a class in which the project is to write a Lisp
interpreter. I would like to incorperate message passing into mine,
and it might be neat if I were able to transplant the code into
Gnumacs lisp when I am done. I don't yet grok lisp implementation, but
I know there are various message passing schemes. I've used ZetaLisp
flavors and Franz Lisp flavors, which are similar, and XLisp classes,
and also an implementation of methods in Ubiquitous Systems u4th. Is
there a particular scheme that would fit well into Gnumacs lisp? I
don't necessarily want my Lisp to be similar internally to Gnumacs
lisp. That is to say, profound parallels between Gnumacs lisp and my
project probably wouldn't go over very well with the professor. But
none the less, I can keep Gnumacs lisp compatibility in mind when
writing the code. I guess I should start by reading a few Lisp
interpreters. What suggestions do you have regarding approaches to
message passing that would plug right into Gnumacs lisp? Pointers to
things to read about it? Has it already been done?       -Don


From: rms@PREP.AI.MIT.EDU (Richard M. Stallman)
Subject: Gnumacs lisp message passing
Date: 4 March 1986 at 23:35:45 GMT+1
To: don@brillig.umd.edu

I would not want to add any message passing to GNU Emacs Lisp
because keeping the size of Emacs from increasing any further
is more important than new features in the Lisp language.
You could still write such an extension, but I would not
want to distribute it except perhaps under a compilation
conditional that is normally off.

However, I don't mind answering some questions to help you
with your project.

The first thing you have to do is decide a few things:

1. whether to combine methods in advance (as in flavors) or to find
them all at run time (as in Smalltalk).

2. Whether to allow multiple superclasses (useful, but much extra work).

3. how to access the slots of instances: dynamic binding, or some kind
of precompilation.  Precompilation is not very hard if you don't have
multiple superclasses.  Dynamic binding is more modular; it doesn't
require changes in the evaluation or compilation of variables.