🚀 go-pugleaf

In article <28MAR91.21053267@uc780.umd.edu> cs450a03@uc780.umd.edu writes:
>Darren New   >>
>Me            >
>>>If I have a bitmap, that's a homogenous collection, and I sure don't
>>>carry type information along with each bit.
>> 
>>Well, comparing it to the example of buttons and subviews and
>>scrollbars in a list, yes you said that.  Of course, there will be
>>homogenous lists where you don't carry the types along. But that isn't
>>what we were talking about.  We were talking about seemingly-hetro lists
>>which you said were actually homogeneous.
>
>Well, I guess I should pay attention, and find out what I was really
>saying...  8-)  Or make yet another attempt to have what I think I'm
>saying the same thing as other people understand me to be saying.

Sorry.  Looking back on it, I realize that my above-quoted material
sounds quite rude.  I didn't mean it that way, and I apologise. 

I think sometimes these language/flame wars go off because people take
statements out of context and then change the context, and I suspect it
is because of the passage of time between comments, and not on
purpose.

My interpretation of the conversation went as follows: I said "a window
is hetrogeneous and thus you need dynamic typing" and you said "I treat
that as a collection of pointers to tagged structures" and I said "I
would implement it that way but I would treat it as a collection of
buttons and texts and ..." and you said "but it would be silly to treat
a bitmap as an array of pointers to tagged structures" and I said the
above. (Or at least, that's how I interpreted it.) Anyway, my point is
that I'm sorry if I sounded like you were weasling or if I was rude.  I
didn't mean it that way.  I just meant that the point you were making
was not the point I was arguing and that I agree with you in the case
you were arguing. It sounded like you were changing context, and I merely
wanted to say "in the context which you first made that statement, it
seemed to me that you did not mean what you meant by the same context
in the current statement."  How's that? :-)

>Maybe if I clarified my terms?
>
>A list which was made by sticking a string of bits onto the end of a
>string of characters would be hetrogenous.  Each bit and each
>character would need a type tag.  The list's type in this case is not
>"string of bits" and not "character string", but "hetrogenous".

Sounds like ASN.1:  
SEQUENCE OF { CHOICE {alpha OCTETSTRING, beta BITSTRING}}
(modulo memory faults)

Anyway, so why would you not call a list inside of a window structure that
tells the window what buttons, scrollers, and other subviews it contains,
a hetrogeneous list rather than a list of pointers to tagged structures?
I see little difference between this list and a list of "string of bits
or characters" except for the size of the structures.

>The language I use is dynamically typed.  Each structure has size and
>type information associated with it.  If I made a list which was made
>by catenating a list of structures onto a list of bits, then each
>element would have to have a type tag: either "structure" or "bit".
>You might call that silly.  I call that hetrogenous.

I call that hetrogeneous also. Are you saying that because the elements
of the window list are not stored inline then the list is not
hetrogeneous? Or is it because the type tags in the window example are
stored with the elements of the list rather than actually in the list?
What about the case where the list, the types, and the bits are all
physically stored disjointly? Or is it that in one case, you would
mentally envision it in one way and in the other case you would
mentally envision it the other way, regardless of implementation?
In that case, I don't think there is much more to say except that
a language that allows both visualizations is probably better than
a language that allows only one such viewpoint.

>I was very careful, each time I called a list of structures
>homogenous, to point out that this was my point of view, and not an
>attempt to classify all problems for all people.

Again, I apologise if I sounded rude or nasty.  That was not the
intent.  I also have trouble when people misinterpret what I was unable
to state clearly enough. I believe at least one of my followups said
something like "you prefer to treat it as a list of pointers and I
prefer to treat it as a list of stings and bitmaps".  I realize that it
is *all* point-of-view because at the bottom level, it's all bits.  I
was merely trying to keep the discussion focused on hetrogeneous lists
which could be interpreted as homogenous, and not on clearly-homogenous
lists.

>I hope my statements are now understandable.
>Raul Rockwell

Hmmm...  Tell the truth, it didn't really clarify much, unless you mean
that a list of two different types of structures will always be
homogenous because you always store "pointers to tagged structures" but
an intermixed list of bits and characters is hetro because they are
physically stored ajacent to each other.
       -- Darren

-- 
--- Darren New --- Grad Student --- CIS --- Univ. of Delaware ---
----- Network Protocols, Graphics, Programming Languages, FDTs -----
  +=+=+ My time is very valuable, but unfortunately only to me +=+=+
+ When you drive screws with a hammer, screwdrivers are unrecognisable +