[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]


I agree with Cointe about the intuitiveness of the name ``shared''
versus ``class.'' I agree with Danny about ``instance'' being better than
``local.'' I'm not sure we've come to grips with the real problem, though.

The real problem is the distinction between the CLOS language constructs -
in particular their syntax - and the English we use to describe them.
There is no problem, aside from confusion, with having CLOS provide
for slots with allocation type :class and calling such a slot a shared
slot. For example, we can write a piece of code like this:

	(let ((n 0)) #'(lambda () (incf n)))
and describe it as producing a closure, though the string ``closure''
appears nowhere in the piece of code.

One rule of technical writing is to avoid creating names for objects that
are compound nouns where some or all of the nouns are jargon words. The
term ``shared slot'' is a normal English noun phrase because ``shared'' is
a normal English adjective. The term ``class slot'' is a compound jargon

To be blunter about it, if a naive weenie saw the term ``class slot,'' he
might think, ``how nice, a class slot in a mediocre instance!''

The phrase ``:class slot'' is even worse, because ``:class'' is not a word
(this is why you never see LGD and me write ``.... CLASS-CHANGED is a
generic function that....'' but ``The generic function CLASS-CHANGED....''
because in the latter construction ``CLASS-CHANGED'' is used as a name
referred to by the text rather than as a word in it.)

If I were to contemplate rewriting the CLOS specification to use the
term ``class'' where ``shared'' was used before, I would opt for
re-phrasing the noun phrase ``shared slot'' as ``a slot whose allocation
type is :class'' in order to be precise.