Loose type checking in E

Tyler Close tyler@lfw.org
Tue, 13 Oct 1998 05:44:49 -0400


At 11:35 PM 10/12/98 -0700, you wrote:
>Well, if i understand you correctly, Python works this way, and
>has this advantage too.  But only by convention.  But then isn't
>this what interfaces are supposed to do for Java?

Java interfaces are similar to virtual inheritance of pure abstract classes
in C++. The (very good) idea is to separate interface definition from
interface implementation. This is an important abstraction that is very
useful; however, it does not get you out of creating inheritance
hierarchies. One of the benefits of C++ templates is that they allow you to
develop compatible software libraries without creating inheritance
hierarchies. 

If you are unsure about the benefits of this, then check out the JGL. Ask
yourself if this is something you would use in your own code.

>> Sure, but which one of us is playing the role of Gerald Wienberg.
>
>Are you implying that atomic transactions are more important than
>deadlock prevention, then?  

What would you think of an operating system that never crashed but couldn't
execute any programs? 

If I don't know what's going to happen to a vat in between method
invocations, I'm thinking that's a problem. I am reading the Actor links
that Mark gave us, and we'll see if I still think the same way.

>I'm doubtful that this is the case,
>especially when a secure operating environment for mutually
>suspicious parties is your goal.

I don't understand how your string of superlatives is relevant. I agree
that deadlock prevention is a necessary ingredient in reliable software;
however, it's a secondary problem that you need to deal with as a result of
trying to achieve your primary goals.

>
>> I am having a lot of difficulty accepting that a single computer should be
>> treated as a distributed environment.
>
>Well... effectively it is, if you want each vat on it to be
>confined and unaware (in general) of its host-mates.  Running
>any particular vat on a particular host should never prevent
>you from being able to run any other vat on that host, and
>should never affect any other vat without your permission.

Sure, this is all fine and good and works just as well with threads. Don't
give the other thread any pointers into your data structure and it won't
mess with you. My problem is that vats force me to give up the function
call paradigm even when I'm only working on one computer.

Now, I'm saying that this immediately strikes me as very bothersome; but as
I said above, we'll see if Mark's reading list changes my mind.

>
>> however, this ignores the fundamental truth that your
>> execution space is not a homogeneous environment. Designs that ignore
>> fundamental truths make me nervous.
>
>It's not like there are no optimizations in the implementation
>for communication between vats on the same host.  I don't see
>why the computational model needs to betray this heterogeneity.

Well, how about the fact that I need to totally rethink the design of
certain software components to accomodate a functionality that they are
never going to use? Asynchronous method dispatch is not the same as
traditional function call dispatch. Everything is not a distributed
calculation.

Well, I'm ranting. I tend to rant, but I can also change my mind. I'm
reading. We'll see.

ciao,
Tyler