
Pony language 0.11.0 released - spooneybarger
https://pony.groups.io/g/user/message/892
======
fnord123
Pony is an open-source, object-oriented, actor-model, capabilities-secure,
high performance programming language.

[http://www.ponylang.org/](http://www.ponylang.org/)

~~~
xkxx
I always wondered whether the language had or had not been named because of
that show about colorful, pastel-, candy-colored equines, of which I'm totally
not a fan of.

~~~
avian
Have you seen the FIM++ language? Perhaps somebody should re-write the
interpreter in Pony.

[https://github.com/JaredMFProgramming/fimpp](https://github.com/JaredMFProgramming/fimpp)

~~~
Cyph0n
Oh man, but that's nothing compared to this:
[https://github.com/ErisBlastar/cplusequality](https://github.com/ErisBlastar/cplusequality)

------
staticassertion
Actors + type safety is a huge selling point for Pony that, to my knowledge,
no other language is really providing.

I'm definitely keeping an eye on it and I'm very excited to see its
development continue.

~~~
jeremyjh
The distributed-process (Cloud Haskell) library gives you Erlang-style
processes/actors in Haskell. Haskell is a good language to map these concepts
to since it already has lightweight threads, pattern matching, asynchronous
exceptions and other language features required to faithfully implement Erlang
semantics.

Scala/Akka would be another choice but it has totally different semantics from
Erlang, and you can never forget you are working in an async model.

~~~
zzzcpan
I think there is some misunderstanding of what Pony is. It doesn't target
distributed systems by the looks of it, it's more like a statically typed OO
language with an alternative to threads/mutexes/channels. So you can see it
being interesting to people with statically typed OO background, who
understand the downsides of multithreading and want concurrency and
parallelism on a single system, i.e. those coming from languages like Java and
C++. It's more appropriate to compare it with Rust or Go, but not Erlang or
Akka.

~~~
spooneybarger
I'm not sure why you would say that Pony doesn't target distributed systems.
In the sense that there is no "distributed pony" yet, then yes.

I spend my days writing a soon to be open sourced distributed system in Pony.
The "alternative" to threads/mutexes/channels is actors which from a
concurrency model perspective makes it very like Erlang. The GC model is also
very like Erlang.

In the end, it is its own thing.

~~~
amorphid
What's a good use for distributed Erlang? I'm writing some Elixir apps, and I
can't think of a great reason to use distributed between a client and a daemon
running on the same box.

~~~
59nadir
Why are you specifying that they're on the same box? You can use distributed
erlang between different computers and the messaging remains the same even in
those circumstances.

On top of that you also get automatic failover for distributed apps(0) that
are supposed to run on only one node at a time, handled entirely by the
runtime, with takeover, etc.

If you're using Elixir, you should probably actually read up on the technology
you're using. These are basic concepts explained in, for example, "Programming
Erlang".

0 -
[http://erlang.org/doc/design_principles/distributed_applicat...](http://erlang.org/doc/design_principles/distributed_applications.html)

~~~
amorphid
I've got an Elixir app running as a daemon to manage cleaning up some certain
build related files for a build system. The daemon is a release started by the
init system. N clients might call the daemon, and the daemon makes sure the
files needed for the build, or maybe left over from the last build, or in the
correct state. The client could talk to the daemon via a socket or TCP port,
but distributed Erlang would also be an option.

~~~
59nadir
I would say when it comes to client-server interaction in Erlang, it's fine to
make that as if it were any other language, but there are plenty of situations
where you'd like to spin up several nodes of something in AWS, for example,
and those would necessarily have to talk to each other.

You'll set up the ability for them to coordinate (by simply setting their
longnames and setting them all up to connect to one machine, making them
create a mesh network) and transparently you'll now have several machines
working on something as if they were one, with minimal effort on your part.

The big downside to using distributed erlang is that it has very little to
offer in terms of security. If you don't add something yourself (which
admittedly isn't too hard) you'll be relying only on a common password for
connecting to the mesh, as well as knowing which machine to connect to.
Obviously it makes for a situation where it's best and most appropriate to use
on your private network, setting up other means of communicating with public
networks.

------
didibus
I have to admit, the name of it throws me off. The intended or unintended
relation with the subculture of obsessed adult men with a pre-teen show, and
this programming language's name really makes me not want to take it
seriously.

I love to judge things for what they are, and not what they're named or
related too, but given there's so many languages fighting for my attention,
this one is hard to swallow.

------
spooneybarger
The 2017 Pony Community Survey just went up. If you are a Pony user or have
played around with, we'd love to hear from you.

[https://goo.gl/forms/5qAmppwIEkvvEFkq1](https://goo.gl/forms/5qAmppwIEkvvEFkq1)

------
hellofunk
Here is a really great, very high performance, full featured c++ library for
actors:

[https://actor-framework.org/](https://actor-framework.org/)

------
kovek
I wonder, where does ponylang fall short? I think that might be an interesting
way to compare it to other languages.

~~~
spooneybarger
I'm on the core team and I'm working on a "Why Pony?" talk that starts with
all the reasons you wouldn't want to use Pony. There are many.

I'd be happy to discuss via email if you want. My address is in my profile.

------
kkirsche
Curious what the deployment story for this looks like compared to things like
Crystal. Is it compiled?

~~~
spooneybarger
Yes. Pony compiles to LLVM bytecode and from there to native binaries.

~~~
fnord123
So it has Rust and C++'s compile time problems?

~~~
striking
What would you suggest someone use instead? As someone looking to write his
own language, I'm very interested in alternatives to LLVM.

~~~
shakna
Using a system like LLVM locks you into C-like behavior. You can work around
it, but it's harder and can come with unnecessary overheads.

Nanopass is one approach to compiling that tends to be more general.

However, LLVM is great if you just want to compile without learning the
intracies of assembly. It even gives you access to multiple backends.

Linking against a framework let's you get up to speed faster, and someone else
handles the security in your compiler, for the most part.

But, when you need flexibility, you'll probably need to do it yourself.

(See Scala and Dotty, as Scala becomes even less Java-like).

------
igt0
Pony is amazing, I am curious about the object capability model applied to
distributed systems.

~~~
BuuQu9hu
[http://erights.org/talks/thesis/markm-
thesis.pdf](http://erights.org/talks/thesis/markm-thesis.pdf) has several
chapters dedicated to the concept. Happy reading.

~~~
spooneybarger
that's an awesome paper. thank you for posting it.

------
patrickg_zill
Can anyone comment on the level of development?

I came across one comment where the author seemed to think the main gurus were
no longer working on it. e.g. here: [https://www.quora.com/What-is-your-
experience-with-using-Pon...](https://www.quora.com/What-is-your-experience-
with-using-Pony-programming-language)

I myself don't have much knowledge of Pony,which is why I ask...

~~~
spooneybarger
Sylvan (referenced as main guru in the link) is still an active member of the
Pony community and he's contributing on a regular basis. His most recent
commit that was merged to master was yesterday:

[https://github.com/ponylang/ponyc/commit/eaf1dcd525c691feae1...](https://github.com/ponylang/ponyc/commit/eaf1dcd525c691feae1b3e569d1fe52b2fa08749)

The Pony development community is still relatively small but we make good
regular progress. We all wish the community was bigger and we were progressing
more quickly but that is always going to be the case.

We have a regular weekly development Zoom call that is open to the public.
Feel free to join. Info is available in the Pony development groups.io group:
[https://pony.groups.io/g/dev/calendar](https://pony.groups.io/g/dev/calendar).

If you join the development list, you'll also get access to the recordings of
the sync meeting going back close to a year. There's a wealth of info there
for anyone cares to dig in. Probably more than anyone would care to ever
listen to.

~~~
rurban
Sylvan is busily working with his team on the feature for distributed actors
at Microsoft Research.

* Type-system for machine specific data (local vs foreign actors, e.g file descriptors, ...)

* Node failure

* Distributed GC (pointer identity => random id)

* Distributed work-stealing (CNF-ACK protocol, user-specific scheduler rules: moving cost, ...)

There's also more work going for more formal proofs.

Here is a bit of explanation:
[https://www.youtube.com/watch?v=KIziz1c41ww](https://www.youtube.com/watch?v=KIziz1c41ww)

"Development status: Everything we talked so far is real and is in use. Runs
on everything from a Raspberry PI to 4096 core SGI Windows OSX Linux FreeBSD
Performance is competitive with C/C++, often better as core counts go up"

Esp. the last 10 slides.

