Pony, Actors, Causality, Types, and Garbage Collection
infoq.com
infoq.com
I very much want a language like Pony because, as this talk demonstrates, it's doing some incredibly cool and powerful things. But it's pretty confusing.
Rust types like Arc, Mutex, &, &mut, and affine, have been wayyyy easier to learn for me because they aren't totally new concepts - I know what Arc is, Mutex, references are, moves are new but that's just one thing and it wasn't too crazy coming from C++. I know how to convert between these types because they're regular structures, with methods and documentation like all other structures. This is in really direct contrast to my experience with Pony where I had to learn like 6 new keywords, try to map them back to my own reference model, and, worst of all, trying to remember the strange incantation to map between them. I bet this is a "learn it once" thing, and it would be fine if that were the only new thing, but it's not - there are object capabilities, actors, learning the runtime/GC, learning new libraries, etc - there just isn't enough complexity budget in my brain for all of these things.
I contrast this with Rust, which people consider quite hard to learn, and Pony has just been way, way harder. It's a little "too good" - nothing in Pony is unjustifiable, like not having assertions/ failures, but I really want those things! Division by 0 is a perfectly fine thing to define as returning 0, I seriously don't even care, but it's just one more straw.
All in all, I was so hooked on learning Pony at first, totally enamored, and then I just found that I couldn't justify putting in the time.
I ended up writing an actor library inspired in part by Pony for Rust, using macros, and I've been fairly satisfied - though there's much more Pony offers, by far. I'd really like to see more actor model languages crop up, and incorporating many features that Pony has, but maybe making some 'worse is better' decisions in a few places.
Rust's only advantage is its immense overhype which leads to more usage and libraries.
Verona's advantage would have been memory regions, which fits better to shared memory models with threads.
Reference types are probably the trickiest bit to learn, especially in how they relate to Pony's generics. Everyone is different, but I found learning the 6 reference capabilities to be a lot easier than trying to understand borrowing and lifetimes in Rust.
I readily accept other reasons not to pursue Pony; it's library ecosystem is budding, the runtime is still a bit unstable, and there is limited support for non-x86_64 architectures. However, I invite anyone reading this comment to form their own opinion of the language. I feel I've benefited greatly from learning it.
Also, Pony has a pretty active community on Zulip, where you will find people who will jump at the chance to help you get unstuck while you're writing Pony. https://ponylang.zulipchat.com/
Funny how that works.
I have this feeling (or maybe I should say "hope") that once you learn Pony reasonably well, you kind of take that "reference type awareness" with you and it will make you a better programmer no matter what language you are programming in. It basically makes explicit what you should already be doing implicitly.
I really should put in the effort to learn it someday
It's very difficult to introduce any kind of synchronous behaviour that doesn't also allow deadlocks. "Locking" an actor to prevent it from processing messages would very trivially allow for deadlocks - and since Pony intends to avoid them by design, the language can't ever allow for it.
Why are promises not fit for your purpose?
Verona's model allows for something along the lines of what is being suggested. How that works out in the long run, we'll see. It's still very early days for Verona.
A number of folks working on Pony also are associated with Verona and vice-versa so there's a cross-polination of ideas going on.
https://github.com/microsoft/verona
In particular see:
https://github.com/microsoft/verona/blob/master/docs/explore...
and
https://github.com/microsoft/verona/blob/master/docs/explore...
https://ponylang.zulipchat.com/#
And you can find more Pony related content on the website:
Talks (and what-not): https://www.ponylang.io/community/planet-pony/ Papers: https://www.ponylang.io/community/#papers
https://github.com/ponylang/ponyc/graphs/contributors
Is MSFT involved with pony (that'd be huge) or is this just a MSFT employee side project?
https://www.microsoft.com/en-us/research/project/project-ver...
The Imperial College hosts a Microsoft Research unit.
MDIL (Windows 8.x .NET compiler based on Bartok from Sigularity), .NET Native, async/await and C# 7+ low level features (influenced by Midori), WSL (picoprocesses came from DrawBridge), Windows 8 USB stack (P language), driver validation (Z prover),....
Sylvan is still involved with Pony but he doesn't contribute directly to the codebase these days.
Microsoft isn't involved with Pony- it's still an all-volunteer project. A number of people associated with/working on Pony are also part of the Verona project from Microsoft Research.
There's a lot of cross fertilization going on between Verona and Pony. A number of interesting ideas from Verona will probably find their way back into Pony (although many of them are "below the covers" so folks probably won't be aware).
The current Pony core team can be seen here: https://github.com/orgs/ponylang/teams/core/members
But then the company went bust and development slowed down. I checked it out again ~ 1 year ago and both language and ecosystem did not look terribly healthy or active.
What's the current status?
ps: I love the video + synchronized slides side by side. I wish this was more common for talks. There should be resizing functionality though.
https://www.microsoft.com/en-us/research/video/pony-co-desig...
https://www.microsoft.com/en-us/research/project/project-ver...
Excellent question. I can't address "healthy or active" as those would really be your own metrics to decide.
We have a lot of things going on including:
Work on a new dependency manager: https://github.com/ponylang/corral
Work on an installation tool to make it easier to get started with Pony: https://github.com/ponylang/corral
A lot of work has gone into making our release process across projects much easier to deal with as it was problematic before.
Joe, a core team member, has been working on ideas to address problems that we've seen folks experience with Pony. He has a semi-functional experimental compiler that will hopefully see the light of day eventually.
We've been working on some runtime improvements that will eventually see the light of day.
Most of the work that goes on these days is in repos other than the ponyc repo that most people tend to look at.
In the end, the important thing to know is that Pony is a volunteer driven project and thus, moves at a different timeline than something like Go or Rust with a lot of backing.
Those of working on Pony are doing it because we believe that in the long run, the time we put in outside of our jobs will be worth it. But our timeline is probably a lot longer than other folks.
-Sean, a Pony core team member.
[1] https://en.wikipedia.org/wiki/Talk:Carl_Hewitt#Short_history...