0cachecoherency

Hi, I'm Sylvan Clebsch, the designer of Pony. I'm very much involved in Pony, as are most of the Causality founders in various ways. It's unfortunate that this kind of misinformation keeps being passed around.

Similarly, Pony's union (ie sum) type implementation always optimises to untagged, but required "boxing" raw machine-words when they're in a union type.

That anti-pattern isn't possible in Pony, because Pony has no blocking receive call.

Pony prevents you from writing that code. All communication between actors is by message passing, and there are no global variables. Check out reference capabilities.

Sandstorm looks extremely interesting. Very very extremely. If Pony could be useful at all to Sandstorm, please get in touch!

Sorry for the docs misunderstanding - I promise, bad docs not withstanding, we are using "capability" to mean exactly what you want us to mean :)

I think you're right, the documentation should DEFINITELY be corrected!

No worries on a false alarm, as I am always eager to discuss capabilities security, in any form :)

The "type qualifiers" you refer to are an extension of the capabilities-secure nature of Pony. They are themselves also a form of capabilities, specifically because the underlying language is itself capabilities-secure.

You may be interested in the type system paper that covers this:

http://ponylang.org/papers/fast-cheap.pdf

That's great news that you know Mark! We have talked extensively with Mark about the design of Pony, and he agrees that it is indeed a capabilities type system, and that it is capabilities secure.

Data races are a subset of all race conditions. We don't claim that it's impossible to wait on a network message that never arrives, of course!

However, Pony makes a messaging order guarantee that's much stronger than is typical for the actor model. It guarantees causal messaging. That is, any message that is a "cause" of another message (i.e. was sent or received by an actor prior to the message in question) is guaranteed to arrive before the "effect" if they have the same destination.

That guarantee is achieved with no runtime cost, which is pretty fun.

Pony still allows unbounded non-determinism, of course, but causal messaging gives a very comfortable guarantee to the programmer.

1. Because Pony is both type and exception safe, actors (the Pony equivalent of an Erlang process) don't fail in the catastrophic sense. Right now, if an actor wants to report that it can't go on to some other actor, it just sends out messages. Obviously, we are big fans of Erlang, and big fans of the Erlang supervisor pattern, so we'll be writing a Pony package that puts a nice interface around this.

2. Yes! Pony has first class pattern matching already (along with algebraic data types, i.e. tuple types, union types, and intersection types, to make pattern matching really useful). It allows matching both on type and on standard or programmer defined structural equality. As I mentioned, we're big Erlang fans, so we definitely won't ignore stuff like this.

If you're interested in the object GC portion, there's this:

http://ponylang.org/papers/OGC.pdf

The Pony object garbage collector is fully concurrent, the reachable memory for any actor is GC'd totally independently. At the same time, Pony allows (safely, with no data races) sharing pointers across actors, for performance (ie without copying).

There's a paper on the type system that allows this:

http://ponylang.org/papers/fast-cheap.pdf

Sorry about that, we'll get more docs up as soon as we can.

For now, check out some of the included packages, like net/ssl. That calls C extensively (libressl, or openssl if you like). Or regex, which uses PCRE2.

There's a difference between GC'ing the memory reachable from an actor and GC'ing the actors themselves. Erlang requires a "poison pill" message to kill actors.

The research paper is here:

http://ponylang.org/papers/opsla237-clebsch.pdf