
Video of Panel Discussion with Tony Hoare, Joe Armstrong, and Carl Hewitt - carlehewitt
https://www.youtube.com/watch?v=37wFVVVZlVU
======
carlehewitt
In a wide ranging discussion, there were some fundamental disagreements among
the panelists as follows:

I disagreed with Tony Hoare about using synchronous communication as the
primitive because it is too slow for both IoT and many-core chips. Instead,
the primitive for communication should be _asynchronous sending and receiving_
, from which more complex protocols can be constructed.

Also, I disagreed with Tony about sequential actions (using ";") as being
foundational. Instead, _concurrent actions_ are foundational for digital
systems as follows:

    
    
        * Receipt of a communication activated sending other communications
        * An Actor received one communication before it received another communication
    

Consequently, a computation is a partial order of causality. Tony and I did
agree that tooling is needed for navigating the partial order. We just
disagreed about whether sequential actions (using ";") are foundational.

Furthermore, class hierarchies are _not_ a suitable foundation for _Scalable
Intelligent Systems_. _Interfaces_ instead of subclassing should be used for
IoT communication. Also, entities and descriptions in large ontologies do not
fit in an object class hierarchy, e.g., Java and C++. Subclassing is _not
secure_ because it allows a subclass to _impersonate_ a superclass.

I disagreed with Joe Armstrong about requiring use of external mailboxes
because they are _inefficient in both space and time_. Instead of _requiring_
an external mailbox for each Actor, buffering/reordering/scheduling should be
performed _inside_ an Actor as required.

Of course, Tony and Joe made other great points with which we agree entirely.

