
On the State of Pony - spooneybarger
https://pony.groups.io/g/user/message/618?p=Created,0,,20,2,0,6182872&offset=0
======
zitterbewegung
For a bit of context on what is Pony:
[http://www.ponylang.org](http://www.ponylang.org) . Are there any users of
the language that would care to comment on using the language?

~~~
doublec
I've used it in a few personal projects. I've written some thing about it
here:
[https://bluishcoder.co.nz/tags/pony/](https://bluishcoder.co.nz/tags/pony/)

The two major things that I stumbled on when I first started using Pony was
that there is no blocking constructs in the language and dealing with
capabilities.

I've had exposure to memory safe languages using types before (ATS, Rust) so
the Pony system of capabilities wasn't too difficult to understand once I was
able to map them to things I was familiar with. Before that I struggled to
understand why things weren't compiling. Now that things have somewhat clicked
I'm pretty productive with the language.

Dealing with writing non-blocking code was a matter of thinking in terms of
callbacks and promises - something familiar to a lot of Node programmers I
suspect.

Once I got past those two things I find the language very nice to write in and
easy to reason about the code. Sometimes I hit walls of struggling to work out
why things aren't compiling and they eventually end up being the compiler
showing me what I was trying to do would be unsafe due to data races, etc.

The language is still young though so definitely something to approach with a
bit of understanding that things may break.

~~~
35bge57dtjku
Interesting website.

------
cwyers
Does anyone have a short, paragraph or two summary of why you might choose
Pony over Erlang/Elixir or Akka with Java or C#?

~~~
spooneybarger
Prerequisite:

You have the stomach for a relatively immature language

Re Erlang/Elixir the number 1 selling point would be if you need performance
that you can't get from Erlang/Elixir.

Re Akka on the JVM, the number 1 selling point would be you want predictable
latencies from your GC that you can't get from the JVM.

Along with those, you get a type system that enforces data-race safety which
now that I am using Pony daily, is the #1 selling point for me.

~~~
mafribe
Where does Pony's performance vis-a-vis Erlang/BEAM come from? The absence of
dynamic typing? Better scheduler?

~~~
spooneybarger
There are a number of areas:

Most message passing on BEAM is done via copying. Pony can share the memory
directly because the compiler enforces safe sharing via deny capabilities. You
can only send 3 basic types to another actor:

iso -> mutable memory that you have the sole reference to val -> immutable
reference. you can read but you can't write tag -> an opaque reference. good
for sending messages to actors or doing identity comparisons

The type system certainly helps as well. It allows us to give LLVM hints on
optimizations it can make. The type system also helps because we can do
"dangerous but fast" things safely because we can prove they are safe in this
instance.

Compiling to native code via LLVM is another area for performance wins.

That said, Erlang has over 20 years of rock solid production usage behind it
and that unto itself is a quite a selling point. At this point in time, I'd
suggest Pony to Erlang/Elixir users if they need more performance, otherwise,
I'd stick with Erlang for now.

~~~
steveklabnik

      >  The type system also helps because we can do "dangerous but fast"
      > things safely because we can prove they are safe in this instance.
    

This is an area of some static type systems that I'm really interested in; it
feels counter-intuitive at first. You'd imagine that flexibility is what lets
you do the things you need to do to go fast, but in many cases, restrictions
actually are. Cool stuff.

~~~
vanderZwan
> _You 'd imagine that flexibility is what lets you do the things you need to
> do to go fast, but in many cases, restrictions actually are._

Aren't you mixing up flexibility for the programmer with flexibility for the
compiler?

The more restrictions the programmer has, the more flexibility the compiler
has to change instructions and still produce the same results.

~~~
PeCaN
I think people tend to think that C lets you go fast because of the tricks it
lets you get away with and how “close to the metal” you are. Which is
partially correct, but C is also an obnoxiously hard language to optimize
_because_ of the flexibility.

~~~
steveklabnik
Exactly.

------
wtbob
> One of the first things we did was to introduce a Code of Conduct to put in
> place rules for the community we sought to grow. A welcoming, thriving,
> civil community is what will make Pony a success. The more welcoming that
> community, the more people we will have driving Pony forward.

I honestly find a Code of Conduct _unwelcoming_ , as it indicates that it's
very likely that what I write will be attacked due to my identity, and that I
may at any time be written out of the community in a modern version of
_damnatio memoriæ_ , even if I maintain a strict wall between my personal and
professional lives (witness the people who attempted to shut down LambaConf
because they disagree with Curtis Yarvin).

A Code of Conduct longer than 'be professional' is a signal that the community
which professes it is hostile. They are, of course, free to be hostile; I am
free to choose not to join them.

~~~
sanxiyn
I think it is important to note that LambdaConf 2016 was successful. In
organizers' own words, "It just means there is a space in this world for an
indie conference that rigorously ensures professional conduct at the event,
but leaves other matters at the door."

People who protested against LambdaConf 2016 organized alternative confrence
MoonConf at the same place at the same time. Two conferences had cordial
relationship. Nothing people worried about actually happened.

[http://degoes.net/articles/post-
lambdaconf-2016](http://degoes.net/articles/post-lambdaconf-2016)

------
buttershakes
I am really interested in Pony. There are some exciting things about it. I'm
hoping that bit syntax support from Erlang is implemented, possibly with
support for recurring structures. Although, I wouldn't say that is strictly
necessary if you can do some nice recursion on binaries.

------
scardine
Thought it was about the Pony ORM (python)[1].

Perhaps the title should say "Pony Language".

[1] [https://ponyorm.com](https://ponyorm.com)

