http://asg.unige.ch/index.php?cat=bibliography&type=details&id=245&typepublication=Unpublished

What’s the markup for these comments? HTML was stripped.

Maybe your interpretation misses out the bits that Joe Armstrong regarded as essential – he listed the characteristics for his notion of “true concurrency” and it seems you are talking about some other idea of “concurrency”.

petrilli wrote “Bryce’s argument, while true, does not argue the same thing that Armstrong states, which is that aliasing is difficult to detect in practice.”

Bryce wrote “Aliasing is difficult to detect …” p107

petrilli wrote “This might be true with Java, but it is certainly not true with Smalltalk.”

I’m interested in how you think continual need to detect references to method arguments would play out in practice – wouldn’t we be spending an awful lot of time trying to detect references at run time?

Those examples kindof miss the point since there’s no need to make erlang look like common OO implementations (with a new() function and so forth), but it’s a useful example for the discussion here.

Note that COPLs must provide true concurrency, thus objects represented as processes are truly concurrent, and messages between processes are true asynchronous messages, unlike the disguised remote procedure calls found in many object-oriented languages. (p. 22)

I think here Armstrong over-reaches a bit, as RPC is more like a disguised function call in most languages. Messages in Smalltalk are synchronous, and that does potentially make creation of the type of fault tolerant systems that Erlang is designed for more difficult, but I do not think it necessarily makes concurrency itself harder.

Bryce’s argument, while true, does not argue the same thing that Armstrong states, which is that aliasing is difficult to detect in practice. This might be true with Java, but it is certainly not true with Smalltalk. Simply examine the nature of Object>>become: which swaps out objects from under everyone, and is commonly used in Smalltalk systems. Other than Objective-C, which is strongly influenced by Smalltalk, I’m not aware of any other system that has a similar capability. Some languages have some hacks to try and do this, but they often fail in practice as he mentions.

As such, I think that the difference is between message-oriented languages (such as Smalltalk and Erlang) and other more traditional approaches to solving the problem. This is not to say Erlang might not make some of these things easier than in most any other system, but I believe he paints with a slightly soiled brush when he makes the generalization about object-oriented systems.

I see where he writes

“Bryce goes on to say that object aliasing is difficult if not impossible to detect in practice, and recommends the use of protection domains (akin to OS processes) to solve this problem.”

and

“Bryce and Razafimahefa argue that is is essential to isolate programs from one another, and from the programs which run in the host operating system. This, they consider, is the essential characteristic that any object system must have. As they point out in their paper, this is a difficult problem in an object-oriented context.”

is that what you’re referring to?

afaik Smalltalk messages happily share object references – how is that like “the level of isolation that Erlang exhibits”?