Comments 4

phimvt@lurac.latrobe.edu.au — 2000-07-18 07:24:54

I am still catching up ... slowly.

The digests are a good idea - are they full summary (done automatically)?

1. "Digest 19"

    The concatenation operator "concat" takes 2 parameters, lists or strings

to produce one list or string result. From the result one cannot tell

what the original constituents were - the joint could be anywhere.

If the resultant list (or quotation) is to be executed, then it might

be wasteful to first concatenate and then execute - instead execute

with the b combinator:

    b  ==  concat i

Or, if execution is not wanted immediately,

    [b] cons cons

In Digest 19 it was pointed out that

    [[i] dip i] cons cons 

could be used equally, since   b  ==  [i] dip i

Note that we are replacing inside a quotation here:

    [b] cons cons  =/=  [[i] dip i] cons cons

But 

    [b] cons cons i ==  [[i] dip i] cons cons i

Note also that the two different programs 3 lines above are different

again from what is produced by concat.

2. "Digest 24"

    There was a lot of very competent discussion here, but since I am

so far behind I'll concentrate on matters directly related to Joy.

3. "Digest 26"

    Again, very interesting. One one remark concerning the number of

parameters needed in concatenative languages. I seem to remember a

result in Universal Algebra - something to the effect that it is

_always_ possible to have as the base(?) primitives(?) only operations

with at most 2 parameters. That might be of interest to us - but it

could also be that such a base or whatnot is not necessarily intuitive.

Any real mathematicians out there ? (I'm only a philosopher !)

4. "Digest 27"

    On "conservative GC": I understand the concept to apply to

mark-sweep and perhaps also to stop-copy garbage collection

(thought _not_ to reference counting). In the mark-phase, mark

anything in the heap which is referenced by a 32-bit value anywhere

in memory (stack+heap). It is just possible that a particular 32-bit

value is a plain integer or part of a string. But that is hard to

tell at runtime. So, mark everything to be on the safe side, that

is being conservative. After the sweep, the freelist will contain

only stuff that cannot possibly be pointed to by anything. There

might be some waste that was not collected, but still, being

conservative pays off in terms of time taken to do the collection.

My understanding is that (some version of) GnuCC does precisely this.

(My Joy prototype implementation does not rely on this, though).



I am looking forward to reading more of the 280 or so messages

that I have to catch up with.

   Best wishes to all

        Manfred