Lambda the Ultimate

Yes, but the difference is that you can pass in where to goto. This is like a return address or a continuation. So the real issue was having to write in an explicit continuation passing style.

Communication in the actor model (in which actors are directly addressed, as opposed to channel-based communications) also resembles continuation passing style. Check out Carl Hewitt's 1976 paper "Viewing Control Structures as Patterns of Passing Messages" for lots of examples.

However, it seems to me that the criticism of channels in occam is exactly that the programmer cannot be sure "where to goto" -- with directly addressed actors, only the directly designated recipient can receive a message. With channels, if that channel has since been passed on to another component (or, in models that allow it, if multiple components are listening on a single channel), programs risk exactly the "return of the GOTO" effect described.

The implementation paper discusses this a bit. I've not read it all yet.

There is a copy-on-write mechanism for sharing structures and a "rec" keyword for recursive functions if not structures.

The part I wonder about as well is that Newsqueak has variable assignment. So how does it treat closures used to spawn processes?

I thought Pike's statement that there are no references is curious: he apparently means no mutable cells within structures, but references from variables to values.

This brief reference manual contains a hint in the last section ("implementation bugs"):

The current implementation does not allow local variables to exist past the lifetime of the prog in which they were created. ... For example,

bad1:=prog() {
    a:int;
    p:=prog(){
        a=1;
    };
};

draws an error. To mitigate the problem somewhat, squint internally rewrites the program

bad2:=prog(){
    a:int;
    begin prog(){
        a=1;
    }();
};

into the form

bad2:=prog(){
    a:int;
    begin prog(a:int){
        a=1;
    }(a);
};

... local progs not begun as processes must access only globals and variables local to themselves.

So at least at the time of the writing of that manual (April 1994), the sequential portion of the language didn't support closures, but spawned functions were lambda-lifted.

Notice that if there are recursive data structures, you could bind a recursive binding to an initialization expression that spawns a process which reads from that recursive binding, and with the closure conversion described above, the unspecified uninitialized value would be sent to the spawned process.

If recursion is only allowed via a limited function declaration syntax, I don't think there's a bug.

I still think this is one of the more challenging aspects of the design of value-oriented, concurrent languages.

I'm assuming it is an address inside the google firewall.

Yes it is. Fortunately, it redirects to Squinting at Power Series which should be publicly available.