12:18 <slayful> "19:18 <SeanTAllen> slayful: yes. also, they'll end up getting reviewed at sync on Wednesday.

12:18 <slayful> thanks for responding - I got disconnected so I missed it

12:20 <slayful> for reference the question was about asking for CR in this IRC "would this be a good place to ask for some feedback on the two PR to ponylang or is it unnecessary?"

12:21 <slayful> I wonder if we could explain the review and merging process in the the contributing page? https://www.ponylang.org/contribute/

16:23 <Schwarzbaer> I've asked before whether before whether Pony supports Erlang-like distribution, and the answer was "Not right now, but we plan to". I'd be interested in what characteristics such distribution is expected to have, and maybe also when.

16:30 <Schwarzbaer> Also, the tutorial mentioned that *having* many actors isn't much of an impact, but how about creating and destroying them? Would it be feasible to create thousands of objects or actors per second?

16:35 <SeanTAllen> yes its feasibly to create thousands per second but that's potentially memory allocation so it has a performance impact.

16:35 <SeanTAllen> distributed pony isn't on anyone's near term radar as far as i know

16:35 <SeanTAllen> sebastian's paper on distributed pony is here: https://www.ponylang.org/media/papers/a_string_of_ponies.pdf

16:39 <Schwarzbaer> That's... 101 pages. To be honest, I'm curious, and willing to read, but *that* is a bit much.

20:01 <jemc> it's well-organized, so you should be able to skim to find what you need - you're in a better position to do that than we are, since you know what you're looking for

20:37 <lolman> hello lads, quick question: is there a bnf grammar or something similar for the language somewhere. I can't seem to find anything.

20:39 <Praetonus> lolman: The `pony.g` file at the root of the ponyc repository contains an ANTLR grammar for the language

20:39 <Praetonus> https://github.com/ponylang/ponyc/blob/master/pony.g

20:39 <lolman> nice, thanks!

20:56 <Schwarzbaer> I'm reviewing the sales blurbs of a bunch of languages, maybe someone here knows them better than I do... As far as I can see, what makes Pony stand out is "The parallelism of Erlang and Elixir (distributed computing pending), the type safety of Haskell"?

21:10 <jemc> you forgot "the speed of C" :)

21:12 <jemc> and actors as well, but that's lumped into the Erlang comparison for you perhaps

21:13 <jemc> to me, the shining feature of Pony is the reference capabilities, though - they are unlike any other language (though a bit similar to the spirit of what Rust does)

21:30 <Schwarzbaer> Indeed reference capability is something I haven't quite grokked yet. So far it seems like something along the lines of "That type isn't just the right type, it can also be (read | written)" to me.

22:01 <jemc> other than the official tutorial, doublec has some good blog posts here about ref caps: https://bluishcoder.co.nz/tags/pony/index.html

23:07 <vaninwagen> i have a a C function (`@SSLeay_version[Pointer[U8]](t: I32)`) returning a `const char*` which i want to turn into a `String`. String.from_cpointer doesnt seem to do the trick as i always get a `Pointer[U8] tag` and would need a `Pointer[U8] ref`

23:09 <vaninwagen> does anyone know a safe way to convert from some NULL-terminated `char*` returned from an FFI call into a pony `String`?

23:13 <Praetonus> vaninwagen: You can specify any type that you want in an FFI function signature. So you can use `Pointer[U8] ref` as the return type in order to do what you want

23:20 <Schwarzbaer> Random point while I'm still wrapping my head around reference capabilities: How come that Pony apparently doesn't semantically use, or at least enforce, indentation rules? After all, it does things like "private variables, and only they, start with an underscore"; same for capitalizing Types. I think that's great, as it enforces common code legibility standards, and makes intended semantics obvious. So why not the

23:20 <Schwarzbaer> same for indentation?

23:23 <Schwarzbaer> As for said head-wrapping... So reference capabilities are annotations about limitations of referenced objects, specifically things like "This is immutable" or "There's no other actor that references this object"?

23:24 <SeanTAllen> re: refererence capabilities... yes thats a good way to think of them Schwarzbaer

23:26 <Schwarzbaer> Well... I'm a little too tired to imagine how that'll play out while actually writing code, but I guess that's a matter of actually doing so for a bit. I've noticed though that there's apparently no capability type that implements something like "Multiple actors may have references, but only one actor may mutate"?

23:30 <SeanTAllen> that wouldnt be safe

23:35 <Schwarzbaer> I guess this is why languages should be designed by people more clever than me... or at least why I should get some sleep. Good night. And thanks.