At Deep Into Smalltalk at Lille in March Noury Bouraqadi presented a simple example of remote messaging. (The exampes are here http://car.mines-douai.fr/noury/docs ).

You have two images. One is a proxy; the other is the server. You send a message to the proxy and it appears on the Transcript of the server.

proxy := Proxy newOnPort: 5432. proxy cr; show: 'This is my boomstick!'.

So you send a message to Proxy, which understands absolutely nothing. Zilch. It defaults to #doesNotUnderstand:, which captures the message as an instance of Message.

doesNotUnderstand: *aMessage* "Message answer is not handled!" | messageBytes | *aMessage* lookupClass: nil. messageBytes := ReferenceStream streamedRepresentationOf: *aMessage*. socketStream := SocketStream openConnectionToHostNamed: 'localhost' port: portNumber. socketStream isConnected ifFalse: [^nil]. [socketStream sendCommand: messageBytes] ensure: [socketStream close].

You can see here that it is serialized by ReferenceStream, shot over the wire by SocketStream. It is de-serialized here in the server image:

dispatch: messageBytes | message | *message* := ReferenceStream unStream: messageBytes. *message* sendTo: Transcript

The important part is the last line, which has the Message instance sent #sendTo: and so for all intents and purposed you have send this old standby:

Transcript show: 'This is my boomstick!'

except the Transcript is not yours; it's somebody else's.

Now let's look at Croquet/Qwaq FarRef>>#doesNotUnderstand: which has a class comment that says:

"I represent a reference to an object living on another island. When I receive a message I pass the message on to the object."

The class FarRef looks to me to be the same as Noury's Proxy: it understands no selectors; it uses a #doesNotUnderstand: override to capture the message; and, sends the message over the wire.

The implementation of #doesNotUnderstand: is not clear to me, so I'll stick to the class comment as my proof. Does Qwaq use ReferenceStream to serialize? I don't know.

In Spoon we have Other>>#doesNotUnderstand: which has this class comment:

"Each of my instances respresents an object in another memory, reachable through a NetStream. Messages sent to one of my instances are forwarded to the remote object, and another Other is answered."

It has #doesNotUnderstand: with a simple #forward: selector

doesNotUnderstand: aMessage ^self forward: aMessage

and then:

forward: aMessage "Forward aMessage to the remote object I represent, and answer the result." "This message was invoked by the virtual machine, in response to an attempt to send aMessage to me."

"Transcript cr; print: aMessage; endEntry." ^( ReflectiveBehavior at: aMessage selector ifAbsent: [ ^OutgoingMessageExchange forward: aMessage for: remoteIdentity over: session] ) value: session value: aMessage arguments

I think Craig may be familiar with the idea of a remote Transcript as he's included a class comment there that looks like Noury's simple program. The message gets passed to OutgoingMessageExchange. Does it use ReferenceStream to serialize? I don't know yet.

To conclude, each of these different programs creates a proxy that understands no selectors, but uses #doesNotUnderstand to glean the message. Thus captured it sends it to a remote receiver.

This is the beachhead I've needed to understand Spoon. I'll extend outward from this observation.

Chris