Pony: An actor-model, capabilities-secure, high-performance programming language

https://www.ponylang.io/

by RossBencina • 12 months ago

286 243 12 months ago

ponylang.io

https://www.ponylang.io/discover/

https://playground.ponylang.io/

throwthrowrow• 12 months ago

Discussion from 4 years ago: https://news.ycombinator.com/item?id=25957307

tomhow• 12 months ago

Thanks!

Pony – High-Performance Safe Actor Programming - https://news.ycombinator.com/item?id=25957307 - Jan 2021 (152 comments)

voidUpdate3• 12 months ago

I wish these language websites would put an example of some code right there on the homepage so I can see what the language "feels" like. I finally found some code in the tutorials https://tutorial.ponylang.io/getting-started/hello-world

burnt-resistor3• 12 months ago

Exactly. A "try language" demo should dive right into an editable executor with syntax highlighting and API-docs floating tool tip code completion. Make it as painless and fast to understand as possible.

codethief• 12 months ago

You mean this executor[0] which is linked right there on the page we are discussing here?

[0] http://playground.ponylang.io/

ratdragon2• 12 months ago

Example pony applications: https://github.com/ponylang/ponyc/tree/main/examples

Playground: https://playground.ponylang.io/

They're on HP https://www.ponylang.io/ unfortunately the article link points to /discover/

jillesvangurp• 12 months ago

I was also wondering what kind of language this is and where they were hiding all the code. Even the tutorial requires clicking past several pages of (more) introduction before you get to see any code. Probably better to lead with the code. Less waffling, more code would be my recommendation.

Timwi4• 12 months ago

Honestly, I get it. The document wants to tell you what's new and different under the hood, not what the language looks like superficially. Code examples don't actually tell you what the language feels like in production. It's kinda like judging a person's character by how they dress.

I would be torn if I had to write intro documentation like this. On the one hand, people demand code examples, but on the other hand, the majority of people reading code examples will nitpick minor pet peeves in the syntax and completely detract from the actual new ideas and concepts that go way beyond just the syntax.

I found the descriptions of the concepts very enlightening and I honestly think they gave me a better idea of what the language would “feel like” to program in than a code example (or a description of the syntax) would have.

In theory, syntax should be interchangeable. It's conceivable to parse a syntax into an AST and reexpress it in another syntax without changing the AST. In practice, this is not done for many reasons (incl. tooling like diffs) but a big reason is that individual bits and bobs of the syntax are tied to the new concepts in subtle ways. There could absolutely be multiple syntaxes for the same concept, but if the concept is new, even in small and unobvious ways, then no prior existing language’s syntax will map it exactly. For this reason, a code example can't really express the new concept, especially if the syntax is superficially similar to another language that doesn't actually have that concept.

archerx3• 12 months ago

Yea but the syntax looks like a mix of Python and JavaScript. By just seeing that I know I don’t want to use it, by seeing the code up front I know that I don’t want to keep reading what ever rationalizations they have to justify the existence of this language.

So by seeing the syntax up front I can save a lot of time because in a world where there are many languages that do the same thing it really boils down to using the one with the syntax that you like the most.

voidUpdate3• 12 months ago

On the homepage, just move the descriptions to the left a bit, and put a big block on the right side where there is some example code that shows off the concepts a bit. It's not like they're struggling for space

notfed2• 12 months ago

people reading code examples will nitpick minor pet peeves in the syntax and completely detract from the actual news ideas and concepts

Err, ok, so? Don't be so afraid of criticism, I guess? Yeah, some people will nitpick. I don't see the problem.

Lutger• 12 months ago

In a way, leading with the core ideas and not with the syntax also shows what this language is about, and selects for people who are more interested in the PL concepts than its looks. After all, syntax is the bikeshed of programming language.

gr4vityWall• 12 months ago

the majority of people reading code examples will nitpick minor pet peeves in the syntax and completely detract from the actual new ideas and concepts that go way beyond just the syntax

I believe that, regardless of our personal preferences, the reality is that syntax is a major criteria for adopting a programming language.

Some people have trouble following Lisp code, and won't touch your project if it looks like chat. Others will have the opposite reaction and have their interest captured instead.

jibal17• 12 months ago

The syntax is the least interesting thing about the language, and hello-world examples demonstrate almost none of the syntax.

This bit from the About page is notable: "never write a programming language. That’s like rule #1. Everybody will just tell you it isn’t needed and then argue about syntax."

klas_segeljakt• 12 months ago

It's not only about showing off syntax. It's also about showing what type of applications the language makes easy to implement.

poulpy1232• 12 months ago

The syntax is the least interesting thing about the language, and hello-world examples demonstrate almost none of the syntax.

I agree for the hello world but I disagree with the syntax. It is the first thing you see and the characteristic you can never escape. It is like the layout and typesetting of a text: the substance is of course more important, but it is still very important. I personally find much more readable languages that have a concise-but-not-too-much syntax, that use not too many special characters, and that is read like fortran/pascal/c/etc (I don't how to define it, but for example lisp is different)

pxeger1• 12 months ago

The designer's syntax decisions tell you a lot about their semantic decisions, which languages they take inspiration from, and the language's philosophy about things like flexibility, correctness, and opinionatedness.

Mawr2• 12 months ago

The way a Ferrari looks is the least interesting part of it too. I still want to see the thing front and center on its homepage.

The syntax is the language. To show me the language you have to show me its syntax.

notfed2• 12 months ago

Even caling this an example is a stretch... it's a hello world...that's it. I mean, at least show some conditionals, or something. We get it, your language is amazing, ok, so...can we see it now?

nallerooth• 12 months ago

I think Nim has a good homepage, with some bullet points explaining what the language is all about coupled with several code examples. I'm not saying Nim is better, but I visited the page the other day and thought it was neat.

https://nim-lang.org/

voidUpdate3• 12 months ago

Yeah, that's exactly the thing I'd hope to see on anything trying to sell me on using a new language. Tell me about what it does, and show me how it does it

1980phipsi2• 12 months ago

The D language home page has something similar with a drop down with code examples

https://dlang.org/

whalesalad• 12 months ago

Nim feels like the perfect language to me. Keep meaning to give it a shot for something.

mvieira38• 12 months ago

It still looks great with Javascript off, 3rd party frames disabled and no remote fonts, too, for us privacy nuts

stared• 12 months ago

Also it took surprisingly many clicks to see any code. After 3 clicks I had impression that it is not yet a language, just and idea for one.

brap• 12 months ago

Unfortunately this is true for basically any kind of “product”.

It’s crazy how many people build something and make a website for it, only to hide the thing they’ve built somewhere deep in the website. Just show me the damn thing!

rapnie• 12 months ago

Same impression. I was reading several pages with "Interesting.. interesting.. interesting.. but where is the code?". First code I managed to find was a Github repo with examples [0], and just now trying to follow the click path that led me to it, couldn't find it anymore. I looked up the link from my browser history.

[0] https://github.com/ponylang/ponyc/tree/main/examples

katzgrau• 12 months ago

I also (usually) go looking right away to see if the syntax makes me feel warm and fuzzy. I’m so shallow.

Twey• 12 months ago

I've always loved Factor's homepage, which includes a random snippet of non-trivial (i.e. small but not ‘hello world’) code: https://factorcode.org/

gmfawcett• 12 months ago

(also, velociraptors)

FrustratedMonky• 12 months ago

I wish these new languages would put an elevator pitch on first page.

Why another object language?

dismalaf• 12 months ago

Agreed. Pony even has nice syntax. Web page is pretty bad though.

sitkack• 12 months ago

It is funny you say this, because nearly every posting of the Pony language includes this comment. And it is always apologized as you need to go to https://tutorial.ponylang.io/ which still doesn't have source on it.

https://github.com/KittyMac/PonyCAT/blob/master/pony-cheat-s...

The project looks hostile to any sort of adoption.

0x4574• 12 months ago

Probably hiding the fact that it's whitespace significant

spooneybarger3• 12 months ago

It's not.

jbritton• 12 months ago

I see this comment on all language postings and I just don’t get it. I’m much more curious about the motivation behind the language. If the syntax was that of APL, Forth, or Prolog would you just instantly ignore it because it doesn’t look like Java. I think if the language motivation is compelling then you can decide to dive into a tutorial where the syntax will be explained step by step. I don’t see how syntax can be judged before it is understood. Do you accept/reject languages over simple syntax like curly braces vs begin/end or significant white space, or abbreviations you don’t like eg. def, fun, defun, function, procedure.

thesz• 12 months ago

Examples such as Hello, World! can tell you many things.

They can tell you whether language is statically typed or not, does it have an effect typing (it necessarily needs higher order types), does it have type inference, etc,

A syntax of one is semantic of other.

WorldMaker• 12 months ago

Code is poetry and even if you don't know the syntax or details of the tools of the language, a choice example up front gives you a sense of the "rhyme" and "meter" of the language.

Sure, some people are going to use that as an immediate gut filter for "doesn't look enough like languages I already know" or various pet peeves, but on the other side for those that love to dig deep into the syntaxes of esoteric/lesser-known languages it becomes like the first sniff when working on tasting notes of a beverage and tells you a lot up front to your "nose" faster than paragraphs of prose about the motivations of the language. "Ah, yes, I'm sensing a strong Python influence on top of earthy notes of Erlang and just a bit of floral Pascal-ness most recently from the vineyards of Typescript, perhaps?"

newswasboring• 12 months ago

This is a type declaration. The keyword actor means we are going to define an actor, which is a bit like a class in Python, Java, C#, C++, etc. Pony has classes too, which we’ll see later.
The difference between an actor and a class is that an actor can have asynchronous methods, called behaviours. We’ll talk more about that later.

Who wrote this[1]? The Doctor?

[1] https://tutorial.ponylang.io/getting-started/how-it-works

Timwi4• 12 months ago

I personally thought it was pretty well-written. It sticks to the details that are relevant in the moment so it doesn't detract or get bogged down, but it does let you know what other things are there so it doesn't feel limited or barebones.

simonask• 12 months ago

This is my pet peeve. "We'll get back to that later" is almost never a useful thing to say, particularly not in writing, and it often just increments the mental burden of the reader by adding another loose end. Instead, outline the concepts you need within context and provide a "Read more" link.

burnt-resistor3• 12 months ago

Notable for the GC (ORCA) and the sharing model. They have a Zulip[0] and a weekly office hours.

Sylvan Clebsch is now working on Project Verona[1].

0. https://ponylang.zulipchat.com

1. https://www.microsoft.com/en-us/research/project/project-ver...

zelphirkalt3• 12 months ago

Having a Zulip (preferably self hosted) is sympathetic, compared to having shitty options like Slack. It indicates, that the people care about privacy. A zulip chat I would consider visiting, a Slack would be a hard pass.

teiferer3• 12 months ago

I gave it an honest look for 5 minutes and after still only having found a 3-line hello world I gave up (and came here to complain).

It's great that you have all that philosophy behind it, all sounded great, but if you don't show me a compelling example in the first minute or two, not even in tutorial, then you'll fail to capture my interest.

ratdragon2• 12 months ago

Example pony applications: https://github.com/ponylang/ponyc/tree/main/examples

Playground: https://playground.ponylang.io/

They're on HP https://www.ponylang.io/ unfortunately the article link points to /discover/

teiferer3• 12 months ago

Sure, if I go dig deep I'll find that. But I was talking about the sales pitch. Once it's necessary to go click links in a levels-down comment in the HN discussion section, you've already lost most folks.

Timwi4• 12 months ago

I personally found the descriptions of the concepts and ideas more illuminating and interesting than a code example. If you're only looking to nitpick the superficial syntax, kinda like judging a person's character by how they dress, then I guess you're not in the target audience for this documentation.

pdimitar• 12 months ago

And you cannot have both at the same time, because...?

austhrow743• 12 months ago

It's entirely possible to not want to look at an ugly person without casting aspersions as to their character.

teiferer3• 12 months ago

I don't care about syntax. The concepts were too abstract though. I'm sure these descriptions make sense if you already know what it's about, but in that case you are hardly the target audience..

jibal17• 12 months ago

dang recently pointed me to the HN guidelines. I think this one applies here:

"Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something."

chownie• 12 months ago

This is by definition a critical comment which teaches something, ie if you don't present viewers with pertinent information about your project, they cannot take an interest in your project. I think it should be noted that both GP and another few highly rated comments are making this exact point.

sbt• 12 months ago

This is probably my favorite programming language I would like to use if it had more backing. Their reference capabilities in particular seem like a very good match for the actor model. Alas, it does not appear to have a large corporation behind it pushing it forward, nor a compelling niche use case (e.g. it is still GC'd).

ndr2• 12 months ago

I loved playing with this a few years ago, but have lost track of it for a while.

The causality model was great, but is there a way to handle backpressure now?

mcintyre1994• 12 months ago

I was randomly looking at examples and I think this is one showing that: https://github.com/ponylang/ponyc/blob/main/examples/under_p...

api2• 12 months ago

Go is GC’d and that doesn’t stop it. What’s wrong with GC? Maybe for tiny tiny tiny embedded or constant time use cases that’s a deal breaker.

RossBencina5• 12 months ago

constant time use cases that’s a deal breaker.

There are real-time safe GC algorithms. I don't know whether Pony offers that option. I would like to know.

rurban2• 12 months ago

It's GC'd, because this is faster and secure.

macgillicu4• 12 months ago

The guy behind the language - Sylvan Clebsch - seems to have a very solid background, and current professional situation. He works at "Microsoft Research Cambridge" in the Programming Language Principles group.

Read the "Early History of Pony":

https://www.ponylang.io/blog/2017/05/an-early-history-of-pon...

My point is - sure, it doesn't have a handful of massive companies stewarding it like Rust. But, on the other hand, it's made by a guy with really serious chops, who has a solid programming language related job. So while not being as industry-sanctified as Rust, or Java, it seems nonetheless like a language that could go places!

__red__10• 12 months ago

This is alas the chicken and egg scenario and the most common reason I hear for people not wanting to invest the time in pony.

The vast majority of people I discuss it with understand the value and the problems it is designed to solve, but they either don't have domain-problems that require pony's approach more than any other language - or the lack of supporting libraries makes them nervous over adoption.

As a pony developer for 5+ years, it can be frustrating - but I do understand.

delifue• 12 months ago

The difference between Pony and Rust is that Pony allows easy reference cycle.

One of the innovative point of Pony is the iso reference. iso reference means that an object graph is accessible from only that iso reference. It avoids sharing mutable data.

pjmlp8• 12 months ago

And that it has a nice garbage collector, which is good enough due to the way capabilities work, being per actor, and how references work.

api2• 12 months ago

Pony also seems to hide more complexity and come with more batteries included than Rust, making it a little closer to the spirit of Go in that sense. That’s my first impression.

ucyo• 12 months ago

There is a nice Podcast about choosing the right programming language for a project and in this, the final choice is relevant to this post :)

https://corecursive.com/055-unproven-with-sean-allen/

macgillicu4• 12 months ago

"The love child of Erlang and Rust"

Wow, what a phrase! Thanks for the link, very interesting stuff!

webprofusion• 12 months ago

Took a while to find the Hello World. It looks like a sort of oop python.

mkl• 12 months ago

It doesn't look anything like Python (which is fine at OOP itself).

ndr2• 12 months ago

Don't be tricked by syntax.

It's statically and strongly typed, and super concurrent. It's a very different vibe than anything python.

pjmlp8• 12 months ago

More like Pascal/Algol/Ada inspired than Python.

ramon156• 12 months ago

Sorry for another complaint, but after skimming through I only see boasting paragraphs without any real information

If I click "why pony" i want to know when to use it. I want to decide for myself if I want to use this

I couldn't find a page where it's clear if I should invest my time in it

How to do this: - examples - companies/projects who use X - what this language aims to do - what this language is good at

danneezhao• 12 months ago

What's new next we can see?

adwn5• 12 months ago

The standard way to avoid these problems is to use locks to prevent data updates from happening at the same time. This causes big performance hits […]

No. Modern mutex implementations [1] are extremely efficient, require only 1 byte of memory (no heap allocation), and are almost free when there's no contention on the lock – certainly much faster and much lower latency than sending messages between actors.

[1] Like the parking_lot crate for Rust.

otabdeveloper4• 12 months ago

A contended mutex is a system call and likely stalls all the CPUs on your machine.

Lockfree spinlocks will only waste cycles on one CPU. A huge difference when you have dozens and hundreds of cores.

adwn5• 12 months ago

A contended mutex is a system call […]

Because modern mutexes are so cheap (only 1 byte directly in the data structure, no heap allocation), you can do very fine-grained locking. This way, a mutex will almost never be contended. Keep in mind that a reader waiting on an empty queue or a writer waiting on a full queue will also involve syscalls.

[…] and likely stalls all the CPUs on your machine.

Huh? Where did you get this idea? Only the waiting thread will be blocked, and it won't "stall" the core, let alone the entire CPU.

By the way, if all your threads are waiting on a single mutex, then your architecture is wrong. In the equivalent case, all your actors would be waiting on one central actor as well, so you'd have the same loss of parallelism.

gpderetta11• 12 months ago

So does a contended queue. As much as I might like the model, message passing is not a silver bullet. Any sufficiently complex message passing system will end up implementing shared memory on top of it... and mutexes.

alfanerd2• 12 months ago

Sending a message between Actors can be just moving a pointer to a piece of shared memory.

I think sending messages is more about the way you think about concurrency, more than the implementation.

I have always found the "one thread doing "while True receive message, handle message" much easier to reason about than "remember to lock this chunk of data in case more than one thread should access it"

gpderetta11• 12 months ago

Unless you have NxN queues across actors[1], which is done on some specialized software but is inherently not scalable, queues will end up being more complex than that.

[1] at the very least you will need one queue for each cpu pair, but that's yet another layer of complication.

adwn5• 12 months ago

Sending a message between Actors can be just moving a pointer to a piece of shared memory.

No, you also need synchronization operations on the sending and the receiving end, even if you have a single sender and a single receiver. That's because message queues are implemented on top of shared memory – there's no way around this on general-purpose hardware.

adwn5• 12 months ago

I think sending messages is more about the way you think about concurrency, more than the implementation.

That's a valid point of view, but Pony's claim to which I objected is about performance, not ease-of-use or convenience.

__red__10• 12 months ago

There's a whole lot of discussion below so I'm just going to tag from here.

I think of pony actors in the same way as I think of erlang actors. They have a "mailbox", and when they receive a message, they wake up, execute some amount of code, and then go back to sleep.

This is how I think about it. This is not how it is actually implemented.

Here's the key that I think many people miss about pony.

Referential Capabilities DO NOT EXIST at runtime.

So let's talk passing a String iso from Actor A, to Actor B. (iso is the capability that guarantees that this is the only reference to this object):

  // This is code in Actor A
  actorB.some_behaviour_call(consume myisostring)

The "consume myisostring" completely removes myisostring from Actor A. Any reference to it after this point will result in an "unknown variable myisostring" error from the compiler.

The reference to myisostring then gets sent to Actor B via its mailbox.

If ActorB was idle, then the message receive will cause Actor B to be scheduled and it will receive the reference to that String iso - completely isolated.

Now, if we're going to measure "performance of passing data between threads" as latency per transaction, then actor contention on a scheduler is going to be a bigger factor.

If you're measuring performance across an entire system with millions of these actions occurring, then I would argue that this approach would be faster as there is no spinning involved.

adwn5• 12 months ago

Why is this downvoted? It's factually correct, on-topic, and relevant (because it contradicts a claim on the linked website). If you disagree, say so and we can discuss it.

senderista2• 12 months ago

Nit: you can’t have a 1-byte mutex unless you implement your own wait queues like parking_lot does. Any purely futex-based mutex (ie delegating all the blocking logic to futex syscalls) must be at least 4 bytes.

pjmlp8• 12 months ago

Without wanting to derail the conversation too much.

Its original designer, Sylvan Clebsch, is nowadays working at Microsoft Research on languages like Verona [0], the last paper he contributed to, which has Guido as well among the collaborators, is about adding regions to dynamic languages, using Python as example implementation,

https://www.microsoft.com/en-us/research/publication/dynamic...

[0] https://www.microsoft.com/en-us/research/project/project-ver...

CharlieDigital• 12 months ago

Notable the Microsoft has not one but two actor model "frameworks": Orleans (for .NET) and Dapr Actors (for containerized workloads).

pjmlp8• 12 months ago

Probably even more, most folks aren't aware of how many research is sponsored by Microsoft Research across all their university sites.

guiriduro• 12 months ago

The .NET ecosystem itself has another mature actor-based framework in Akka.NET, being probably closest to the Erlang/Elixir supervisor style, in C#/F#.

threatofrain• 12 months ago

Is Verona still receiving attention? Seems like a quiet project.

pjmlp8• 12 months ago

The paper I mentioned, is also done as part of Verona project

https://www.microsoft.com/en-us/research/project/project-ver...

Maybe they are now mostly behind MS walls, or have indeed decided to look elsewhere for their research goals.

titzer• 12 months ago

Last I chatted with Tobias Wrigstad, work is still happening on Verona.

zelphirkalt3• 12 months ago

As always with the languages, I think about what the ecosystem looks like. What libraries exist? Seems there is a list of available packages on their website: https://www.ponylang.io/use/packages/

xnorswap• 12 months ago

I clicked one at random (net_ssl) to get a sense of what a package looked like in this ecosystem and how to install it, but it takes you straight to a github page which says it's deprecated and to use a different package (ssl) instead, which is not listed on the packages page.

Not a great look, although it looks like it was only deprecated 2 weeks ago, so I'll give them a pass.

zelphirkalt3• 12 months ago

With such sanctified list of libraries, I think it is not unlikely, that more packages exist out there, that are simply not listed, or that there are repos out there, showing how to do things, but are not isolated libraries.

Maybe a third-party awesome list or so would be interesting.

Other than that, I guess one could get involved in the community to ask questions about things one needs for some project, or search more specifically for things one needs and hope to then find them.

spooneybarger3• 12 months ago

Thanks. I had missed that.

https://github.com/ponylang/ponylang-website/commit/89211a89...

seunosewa• 12 months ago

"Exception-Safe¶ There are no runtime exceptions. All exceptions have defined semantics, and they are always caught."

So checked Exceptions like Java?

ameliaquining7• 12 months ago

The difference is that there's only one exception type and it can't carry payloads. This turns out not to be very different from an option type like in Rust or Swift, just with a bit of syntactic sugar around it.

pjmlp8• 12 months ago

In Rust and Swift they can have payloads and variants, which in Rust's case due to lack of ergonomics, there are plenty of macro crates to work around this.

spopejoy• 12 months ago

Hmm ... How do you implement the common pattern of a top-level exception catcher (e.g. for a long-running thread) with option types in pony/rust/swift? In Haskell this is ergonomic thanks to Functor and friends, but how do langs other than Haskell propagate this behavior up the call stack?

pjmlp8• 12 months ago

Checked exceptions like CLU, Modula-3 and C++, before Java came into the world.

Or checked result types as in many FP languages, which many seem to miss the similarity.

anacrolix• 12 months ago

It's a great concept but the ecosystem, tooling, and stewardship are really crap.

jmcgough• 12 months ago

It's sad that the only company using it in production switched to using Rust.

pull_my_finger• 12 months ago

The only company "publicly" using it. I know Sean has mentioned there's a lot of fintech (i think) using it, just not blogging about it.

__red__10• 12 months ago

TO be clear…

The switched because they changed their business focus from one of their products to another.

I'm sure we'd all agree that the best language to use is the language the best fits your problem domain.

Rust was a better fit for that new product than pony. That's not a reflection on the language.

gpderetta11• 12 months ago

Deadlock-Free: This one is easy because Pony has no locks at all! So they definitely don’t deadlock, because they don’t exist! This really annoys me every time I read Pony description. What does deadlock free even mean here? Deadlock-free is typically the property of an algorithm, not a language.

Does pony guarantees forward progress in all cases? Does it means that if I tried to implement a python interpreter in Pony it will statically reject the implementation? Requires me to submit a proof of deadlock freedom with any program I feed the interpreter? Or any python program running on this interpreter is magically free of deadlocks?

edit: as an aside, deadlocks have little to do with locks.

BlanketLogic• 12 months ago

It is based on actors and "reference capabilities". These two blogs[1,2], could provide nice introduction.

1. https://blog.jtfmumm.com//2016/03/06/safely-sharing-data-pon... 2. https://bluishcoder.co.nz/2017/07/31/reference_capabilities_...

gpderetta11• 12 months ago

That's quite interesting, but it doesn't answer the question: Would the python program running on an interpreter written in pony deadlock or not?

perching_aix9• 12 months ago

Does it means that if I tried to implement a python interpreter in Pony it will statically reject the implementation?

How could that be true? You'd be emulating the language particularities, so deadlocks would be just virtual states. Your interpreter itself being free of deadlocks doesn't mean it cannot represent them.

It's like thinking that you cannot write e.g. console emulators in Rust, because people typically ship unsafe code to consoles, yet Rust enforces memory safety. Yes, it does enforce it - so you'd be representing unsafe accesses instead, rather than actually doing them.

gpderetta11• 12 months ago

Well, yes, that's my point. So what does it means that Pony is deadlock-free?

unbrice2• 12 months ago

It would be technically deadlock free because you'd have a state that is unable to progress forward but it wouldn't technically involve a synchronisation primitive. In my view a real deadlock would actually be easier to debug but I'm just a caveman.

rurban2• 12 months ago

Of course it cannot guarantee forward progress in all cases, because that would be NP.

Pony guarantees deadlock freedom by eliminating locks and other mechanisms that can lead to deadlocks. Instead, Pony uses a message-passing concurrency model and static analysis to prevent data races and deadlocks at compile time. This means developers don't need to worry about manually preventing deadlocks because the compiler handles it. The scheduler is lock-free, the order of message-delivery to all actors is guaranteed.

Here's a more detailed explanation:

Message-Passing:

Pony employs a message-passing model where actors (objects) communicate by sending messages to each other. This avoids the need for shared mutable state and locks, which are primary sources of deadlocks.

Static Analysis:

The Pony compiler performs static analysis to ensure that concurrent access to data is safe. It prevents data races and other concurrency issues that could lead to deadlocks by verifying that no two actors can simultaneously write to the same memory location.

No Locks:

Because Pony doesn't use locks, there's no possibility of threads getting stuck waiting for each other to release locks, which is a common cause of deadlocks.

Data Race Freedom:

By eliminating the possibility of data races (concurrent modification of shared mutable state), Pony also eliminates a major source of potential deadlocks.

gpderetta11• 12 months ago

sorry, that's nonsense, you can trivially deadlock without mutexes with message passing.

edit: and to be clear, I'm quite interested in Pony, static typing, shared nothing threading with message passing, capabilities, per thread GC is very close to my ideal programming language. But the bogus deadlock-freedom claim make me question the other claims.

thayne2• 12 months ago

Because Pony doesn't use locks, there's no possibility of threads getting stuck waiting for each other to release locks, which is a common cause of deadlocks.

It may be a common cause of deadlocks, but it isn't the only way to have deadlocks.

A book I read on erlang had an entire chapter on how to avoid deadlocks with actors that had several examples of how you can get a deadlock with just message passing.

In fact, it is possible to implement a lock/mutex (also a semaphore) with actors and message passing.

throwaway328• 12 months ago

Request to HN mods: that the link be changed from

https://www.ponylang.io/discover/

https://www.ponylang.io/

On the second link, as another commenter mentions, the "Try it in your browser" is one click away, near the top. On the first link, it's two clicks away, but the first of those clicks is a perhaps surprising backwards-lick to get back to the homepage...

Unfortunately, many of the diehard language enthusiasts here seem to be getting quite worked up over how inaccessible the code examples are. Instead of being able to immediately see the syntax so they can rush back here to make insightful and educated comments on how that syntax compares to $their_fave_lang, they are forced to spend up to 4 or even 5 minutes reading documents clearly describing the design of the language, and being obliged to click on their mouses up to 10 times even in some cases.

If a member of the Pony team sees this: even though it's more than a tad ridiculous and you have in fact made a lovely website with loads of clear information, maybe consider adding the "Try it in your browser" link as another option in the burger menu thing on the left. That way it follows everyone around, and you never have to suffer a HN discussion getting needlessly derailed by the resident PL fanatics.

tomsmeding3• 12 months ago

Personally, I would say that if one is a real PL fanatic, one is more interested in the semantics than the syntax. :)

The problem with the linked docs on the Pony website is not that it doesn't explain the semantics (it does!) but that it seems to be written at a pace appropriate for someone who has no clue what static types even are. [1] Give a concise demonstration of the syntax and the semantics, even if that means that the latter will use terminology that not everyone will understand. Then the full tutorial is there for the details.

[1] https://news.ycombinator.com/item?id=44722779

Mawr2• 12 months ago

Instead of being able to immediately see the syntax so they can rush back here to make insightful and educated comments on how that syntax compares to $their_fave_lang, they are forced to spend up to 4 or even 5 minutes reading documents clearly describing the design of the language, and being obliged to click on their mouses up to 10 times even in some cases.

Welcome to interface design! Your way of thinking could not be more wrong if you tried :)

How buying stuff on say Amazon works:

1. Click on picture of a car

2. Click "Buy Now"

How it would look like if we apply yours/the Pony website designers' approach:

1. Read a 10 page description of what the car is

2. Click on a link buried on page 12 that lets you buy the thing

Which approach gets more sales?

Timwi4• 12 months ago

I don't know about you, but I'm not sure I'd be all that interested in a programming language that is focused on scoring sales.

macgillicu4• 12 months ago

1. Read a 10 page description of what the car is
2. Click on a link buried on page 12 that lets you buy the thing

But the link to the playground is on page 1, the home page, and not page 12? So your whole argument is moot, since it seems the Pony people obeyed at least this part of your interface design dogma.

Or, in other words, "you could not be more wrong if you tried :)".

The issue here was that page 2 was linked in the title, so everyone was getting to page 2, and not clicking back to page 1, where the playground was, and instead clicking forward and getting lost.

And all that aside, as another commenter said, even if the playground was hidden behind the most fiendish of mazes -- perhaps not every programming language is interested in attracting the kind of people who think every corner of the universe must mirror Amazon's approach to "sales".

dang4• 12 months ago

Ok, I've done that and put the other links at the top.

macgillicu4• 12 months ago

Top modding, I couldn't believe how much discussion was being wasted on trivial matters. And for such a cool-looking language!

gwd2• 12 months ago

If you want to dive right into what seems like the first key "interesting" idea, it's here:

https://tutorial.ponylang.io/types/actors

If you know a few programming languages I think you should be able to guess what the syntax does from context.

And then the next key idea is here:

https://tutorial.ponylang.io/reference-capabilities/referenc...

(Although I think the first actual interesting I idea I saw was "Destructive read" under https://tutorial.ponylang.io/types/classes#functions , but that's clearly just an isolated quirk, not part of the core idea of the language.)

brightball3• 12 months ago

August 15th and 16th there will be a talk on Pony at the Carolina Code Conference in Greenville, SC.

https://carolina.codes

pseudocomposer• 12 months ago

Was this meant to be a reply to the top-level story, and not a specific comment?

It seems really bizarre to respond to “there should be easily-accessible examples of code that demonstrate the language’s key features on the website” with “there’s a $200 conference in South Carolina where there will be a talk on it.” Honestly, it comes across as not just bizarre, but somewhat disrespectful (though I’m sure that was not your intention).

brightball3• 12 months ago

I just clicked the first reply button in a hurry when I saw the Pony thread. It's hard to turn off the conference promoter mode. :-)

My apologies.

bdcravens• 12 months ago

I lost track of how many links I had to click to get to a screen that had a line of code.

tomsmeding3• 12 months ago

I'm going to join the choir saying that languages need a concise description of what makes them special easily accessible — but while syntax is important, with a language like Pony (where the cool stuff is in the semantics), the cool semantics should be upfront.

It seems, from some skimming of the first like 10 pages of the guide, that Pony is an object-oriented language with actors, and a built-in concept of mutability of references. What kind of references are there? You say that deadlock is impossible; how — do you have session types or something? You say that nulls don't exist; how — do you have linear typing? How do you express capabilities?

Essentially, give me a one-page overview of the static and dynamic semantics (i.e. type system and runtime semantics) that gives me all I need to know about this language to decide whether I want to learn more about it.

The language looks cool, but all documentation I've seen so far seems to assume that the reader doesn't even know what static typing is. To get knowledgeable people interested, I think it's useful to have a pitch that appeals to people who are already familiar with a bunch of languages.

ameliaquining7• 12 months ago

I agree with you, but also, it is legitimately hard to explain concisely the unique aspects of Pony's semantics. My short attempt at it from a couple years ago: https://news.ycombinator.com/item?id=33980738

tomsmeding3• 12 months ago

Thank you! This is quite illuminating. It's not enough for me to know precisely how the language works or how it feels to program in it, but it allows me to put the language in a box so that I know what concepts it introduces and what problems it tries to fix. :)

TOGoS• 12 months ago

I don't have a one-page overview of Pony, but I did listen to https://corecursive.com/055-unproven-with-sean-allen/ in the car a couple of times and that made me want to try it.

bccdee• 12 months ago

What I haven't seen anyone mention yet is that syntax exists to concisely express semantics. If you want to give me an immediate feel for your interesting semantics, show me how you express them syntactically.

It may be easier to explain (for instance) Rust's borrow-checker in prose, but if you show me a snippet of code using `&mut`, it'll click for me intuitively that something conceptual and important is happening here. That's why I want an illustrative example at the top of the front page.

NortySpock• 12 months ago

https://youtu.be/u9da3UzEhEI

For those who enjoy long form video interviews, here is Kris Jenkins of Developer Voices interviewing Sean Allen on Pony language

babygetoboy• 12 months ago

Here is a talk about Pony

https://www.youtube.com/watch?v=WlGSpYFntUU

tempodox• 12 months ago

I keep being irritated by the fact that Pony does not have operator precedences. You have to parenthesize arithmetics.

gwd2• 12 months ago

OK, so having poked around the documentation a bit, I do think the Pony documentation could use a lot more examples. But there's one reasonably concrete example here:

https://patterns.ponylang.io/data-sharing/isolated-field

Basically what I gather is:

1. Actors are like threads, but have data structures associated with them. Actors have functions like methods associated with them called "behaviors", which are called asyncronously. BUT, any given Actor will only ever have one thread of execution running at a time. So calling a "behavior" is like sending a message to that actor's thread, saying, "Please run this function when you get a chance"; "when you get a chance" being when nothing else is being run. So you know that within one Actor, all references to Actor-local data is thread-safe.

2. They have different types of references with different capabilities. Think "const *" in C, or mutable and immutable references in Rust, but on steroids. The extra complexity you do in managing the types of references means that they can get the safety guarantees of Rust without having to run a borrow checker.

So in the above example, they have a Collector actor with an internal buffer. Anyone can append a character tot he internal buffer by calling Collector.collect(...). Code execution is thread-safe because the runtime will guarantee that only one thread of Collector will run at a time. The data is of type 'iso' ("isolated"), which ensures that only one actor has a reference to it at any time.

Once the internal buffer gets up to 10, the Collector will transfer its buffer over to another Actor, called a Receiver, by calling Receiver.receive(...) with its own internal buffer, allocating a new one for subsequent .collect() calls.

But its internal buffer has a reference of type 'iso', bound to Collector. How can it transfer this data to Receiver?

The magic is in these two lines:

    let to_send = _data = recover Array[U8] end

This creates a new local variable, to_send. Then it atomically:

- makes a new Array[U8] of type iso

- assigns this new array t; Collector._data

- Assigns the old value of Collector._data to to_send

Now Collector._data has a new reference of type iso, and to_send has the old one.

Next we do this:

    _receiver.receive(consume to_send)

The "consume" ensures that to_send can't be referenced after the consume call. So the compiler can verify that Receiver.receive() will be the only one able to access the old value of _data that we passed it.

Sounds like an interesting approach; it would be nice to see more examples of realistic patterns like this; perhaps simple sequential programs broken down into multiple actors, or things like a simple webserver implementation, with some sort of shared state.

germandiago• 12 months ago

Incorrectness is simply not allowed. It’s pointless to try to get stuff done if you can’t guarantee the result is correct.

This is more nuanced actually. And it could have implications and contradictions with "get stuff done". IfI can have a non-provable piece of code that serves me well 99% of the time I could save coding time at the expense of correctness and could fit the bill for my use case.

wongarsu2• 12 months ago

Even academic mathematics and computer science work like that to a degree.

We get a lot of stuff done assuming P != NP, that no polynomial-time prime factorization algorithm for classical computers exists, that one-way functions exist, etc.

As long as assumptions are clearly stated and are routinely questioned it's fine to have them

wongarsu2• 12 months ago

I love the syntax for checked math. a + b for wrap around, a +? b to raise an exception on under/overflow, and a +~ b for maximum performance, leaving behavior on under/overflow undefined (including floats having undefined behavior on +-Inf and NaN).

Compared to e.g. Rust (one of the better modern examples of easy rigorous math) I really like how concise they are. What I'm missing are saturating operations. I know some people find them useless, and through a "perfect results" lens they are, but they still give you the closest representable number. And they are often intuitive for humans since that's how most analog instruments work

renox• 12 months ago

It's interesting that Rust and Pony have différent default for addition.

1-more• 12 months ago

A fun fact about Pony: it solves the problem of division not being total by making integer division by zero equal zero! A few proof assistants and Elm take this approach too.

thebeardisred• 12 months ago

Bringing more pony play into computing.

dmux• 12 months ago

I think this is the first time I've seen a github badge (with number of stars) that's for the website itself and not the language repo!

vfclists• 12 months ago

I wish these language websites would put an example of some code right there on the homepage so I can see what the language "feels" like. I finally found some code in the tutorials https://tutorial.ponylang.io/getting-started/hello-world

+ 85 replies

The usual HN post where the threads which are tangential to the topic always rise to the top.

How much irrelevant dross to readers have to read through before they get to comments on the actual product?

Time to sit back and see if this one will also rise to the top or somewhere near.

dang4• 12 months ago

Related. Others?

The New Wave of Programming Languages: Pony, Zig, Crystal, Vlang, & Julia - https://news.ycombinator.com/item?id=36911186 - July 2023 (9 comments)

Pony Programming Language - https://news.ycombinator.com/item?id=33970547 - Dec 2022 (82 comments)

We moved from Pony to Rust - https://news.ycombinator.com/item?id=28777306 - Oct 2021 (175 comments)

Pony – High-Performance Safe Actor Programming - https://news.ycombinator.com/item?id=25957307 - Jan 2021 (152 comments)

Pony, Actors, Causality, Types, and Garbage Collection - https://news.ycombinator.com/item?id=24398469 - Sept 2020 (29 comments)

Pony 0.29 - https://news.ycombinator.com/item?id=20370448 - July 2019 (19 comments)

Fearless Concurrency: Clojure, Rust, Pony, Erlang and Dart - https://news.ycombinator.com/item?id=19241427 - Feb 2019 (143 comments)

Pony 0.25.0 released - https://news.ycombinator.com/item?id=18212633 - Oct 2018 (38 comments)

Introduction to the Pony programming language - https://news.ycombinator.com/item?id=17195580 - May 2018 (72 comments)

Pony (programming language) Cheat Sheet - https://news.ycombinator.com/item?id=17118368 - May 2018 (1 comment)

The Snake and the Horse: How Wallaroo's Python API Works with Pony - https://news.ycombinator.com/item?id=16768706 - April 2018 (8 comments)

Some high level information about the Pony programming language - https://news.ycombinator.com/item?id=16619264 - March 2018 (10 comments)

Why we wrote our Kafka Client in Pony - https://news.ycombinator.com/item?id=16264845 - Jan 2018 (95 comments)

Why we used Pony to write Wallaroo - https://news.ycombinator.com/item?id=15558051 - Oct 2017 (84 comments)

Pony Performance Cheatsheet - https://news.ycombinator.com/item?id=14999899 - Aug 2017 (35 comments)

Pony: Combining safe memory sharing with Erlang-like actors - https://news.ycombinator.com/item?id=14676505 - July 2017 (62 comments)

An Early History of Pony - https://news.ycombinator.com/item?id=14280565 - May 2017 (8 comments)

Pony language 0.11.0 released - https://news.ycombinator.com/item?id=13846063 - March 2017 (52 comments)

On the State of Pony - https://news.ycombinator.com/item?id=12331458 - Aug 2016 (40 comments)

Using Pony for Fintech [video] - https://news.ycombinator.com/item?id=11849579 - June 2016 (6 comments)

Pony is an open-source, actor-model, high performance programming language - https://news.ycombinator.com/item?id=10902906 - Jan 2016 (57 comments)

Pony – High Performance Actor Programming - https://news.ycombinator.com/item?id=9482483 - May 2015 (124 comments)

matesz• 12 months ago

For anyone interested in a deeper dive into the foundations of the Actor Model, I highly recommend this entertaining 45-minute explainer by Carl Hewitt, one of the model’s original pioneers:

https://m.youtube.com/watch?v=7erJ1DV_Tlo

Pony: An actor-model, capabilities-secure, high-performance programming language

Related Stories