Hi Rob --

At 6:19 PM -0800 11/14/03, Rob Withers wrote:
>Alan, these posts are always so stimulating.  Could
>you tell me a little about abstact algebras and how
>you relate them to computers sending messages to other
>computers?  Is it related to defining languages, in
>some way?

Originally, algebra was a symbolic form of arithmetic. In the 19th 
century, mathematicians realized that there were lots of other 
systems that had some of the properties of numbers, and they gave 
such systems with various overlaps to numbers, names such as groups, 
fields, rings, etc., and algebras. This then became a useful metaphor 
and goal: to try to find common properties of systems and abstract 
them into the simplest schemes that covered all of them. So, e.g, a 
number of the object-like systems I saw in the 60s, such as 
Sketchpad, used a particular offset in the layout to find the pointer 
to (say) the display subroutine for that kind of object. Today we 
call that polymorphism, but this term is borrowed from theory of 
functions and is not quite right. In any case, once you have an 
inside and an outside, and try to do everything through embedded 
procedures of some kind, you have set up the possibility for an 
"algebra" of meaning that could extend over all objects. Clearly, a 
good job of this cuts down the size and nomenclature of the concept 
space. This thinking was before APL, but not before Iverson's book 
that defined a more comprehensive version of APL, and it occured to 
me that you could go much further than Iverson did with what I called 
"generic procedures".

>
>you also wrote:
>
>>  An interesting consequence of this structure was
>>  that protection was
>>  complete in ST-72, and all messages could be
>>  serialized if the object
>>  wanted (we did not bother with this because we were
>>  working on
>>  different kinds of problems -- but Hewitt thought
>>  about it a lot).
>
>Could you say a little more about why protection was
>ensured?

In the very same way that a computer on the Internet is quite 
intrinsically safe -- no outside entity can force anything because 
the computer has to run some of its own code before anything can be 
admitted and acted upon. To hurt a computer it has to have stupid and 
foolable SW. The ST-72 objects were only given a pointer to the 
message and the knowledge that a message was trying to be sent. They 
had to do the rest of the work to receive the message, and they had 
full power to act or not.

>  Also, I like the implications of serializing
>all msgs.  How did this work in these systems?

As I said, we didn't do very much about this, but part of the style 
that the first Simula used, and the later Hewitt Actors inspired by 
ST-72 were very much concerned about serializing. Again, thinking of 
an object as a computer, it was quite possible to make objects that 
would implement ques, etc., that would handle or reject messages in 
serial order. This is part of Dave Reed's scheme in his '78 MIT 
thesis and in his part of Croquet.

Cheers,

Alan

>
>thanks!
>journeyman rob


--