00:16 <blanu> So I'm trying to learn pony and so far it's been pretty easy, but I'm stuck finding examples of using actors to actually do things. For instance, I would like to map a function over an array in parallel, where I use one actor per array item. Can anyone advise me or point me to some relevant code examples?

00:17 <SeanTAllen> I'm not aware of any examples of doing that. I know some folks have done, but not sure if they ever posted.

00:17 <SeanTAllen> In general that's not a particularly common usage of actors.

00:18 <SeanTAllen> For what you are talking about I think you would want to use Promises and then join on all the results

00:18 <SeanTAllen> https://stdlib.ponylang.org/promises-Promise/#promise91a-any-share93

00:19 <SeanTAllen> Im not really sure what you mean by "to actually do things".

00:19 <SeanTAllen> The echo server example, uses actors to do things (echo): https://github.com/ponylang/ponyc/blob/master/examples/echo/echo.pony

00:20 <SeanTAllen> There's the producer/consumer example: https://github.com/ponylang/ponyc/tree/master/examples/producer-consumer

00:21 <SeanTAllen> Readline example uses an actor: https://github.com/ponylang/ponyc/blob/master/examples/readline/main.pony

00:21 <SeanTAllen> The timers in timer example are actors: https://github.com/ponylang/ponyc/blob/master/examples/timers/timers.pony

00:21 <SeanTAllen> And plenty more, if you clarify, perhaps I could help more.

00:23 <blanu> Oh I see, well that is very interesting feedback, thank you.

00:24 <SeanTAllen> Were you thinking of actors purely as a means of parallelization?

00:24 <blanu> It seems from your examples that I've misunderstood the role of actors in pony as being about parallelism, when they are more used for concurrency.

00:25 <blanu> Yes, the idea that you can have millions of actors implied to me that they were for parallelism.

00:26 <SeanTAllen> well, they can be used for parallelism but, more than that

00:27 <SeanTAllen> its about resource ownership so you can "share" resources in a safe fashion and "synchronize" on that resource via message passing

00:27 <SeanTAllen> so for example, an actor per tcp connection and you send over the socket by sending messages to that actor

00:28 <SeanTAllen> or if you application logged to a file, you would have an actor whose job it was to receive message that would in turn be logged into said file, all in a data race free, thread safe fashion

00:28 <SeanTAllen> you could do the pure parallelization case but that's not the most common case

00:30 <blanu> Sure, that makes sense. I understand the concurrency use case.

00:31 <blanu> The the low overhead and automatic scheduling of pony actors makes pony seem attractive to me for data parallelization, so it's interesting to hear that this is not common practice.

00:34 <blanu> Thank you for the actor examples, I will study them and figure out what it is that I'm not understanding.

00:37 <SeanTAllen> Youre welcome. Stop by whenever you need help. There is often someone here, but if not ask your question and check the logs later for an answer. We try to answer all questions or at least, ask follow ups.

01:15 <blanu> It might be handy to have https://github.com/ponylang/ponyc/tree/master/examples on the website. I didn't find it while looking through the documentation and it has many useful code examples.

01:16 <blanu> Ah, an example of data parallelism! https://github.com/ponylang/ponyc/blob/master/examples/mandelbrot/mandelbrot.pony

01:22 <blanu> Interestingly, it divides the task into chunks and spawns worker actors, rather than using a parallel map function. I wondering if this is just because it's the paradigm that pony programmer think in, or if there is a performance reason.

01:50 <blanu> So if I'm understanding correctly, to use actors you make several instances using a constructor function, and you get one actor per instance. Then you call "be" methods on the actors.

01:51 <blanu> I guess I was expecting there to be some different syntax or types involved, but as far as I can tell using actors vs. classes is similar except for the declaration.

01:55 <slfritchie> If you're describing the small-seeming difference between a `fun` and `be` annotation on a method-looking-thing, you're right.

02:01 <blanu> Indeed!

02:04 <blanu> Is there a resource somewhere for existing pony packages? I might write a package, if what I need doesn't already exist.

02:11 <slfritchie> Sorry, blanu, there isn't a CPAN-style collection of package description, though that'd be really handy.

02:11 <slfritchie> A runner-up is to ask GitHub for pony language repositories ... though not nearly as useful.

02:11 <slfritchie> s/for/about/

02:23 <SeanTAllen> the pony-language topic on github can help you find some

02:55 <SeanTAllen> https://github.com/topics/pony-language

04:13 <blanu> I think I might see why a parallel map is not a good match for pony. Behaviors do not return values, so the actors need a place to write their results. So each actor needs a write-only reference to a different part of the array in which to place its result. It's unclear on how to do this in pony, or if it's possible, since isolation seems to be at the level of the whole data structure.

04:13 <blanu> The mandelbrot example bypasses this issue by writing results directly to a file.

12:04 <SeanTAllen> blanu: to do that in pony, you would use something like a Promise, so you can get the result back from each of the "workers" then it would work out fine.