# 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