c355e3b has quit [Quit: Connection closed for inactivity]
jemc has joined #ponylang
aturley has joined #ponylang
jemc has quit [Ping timeout: 276 seconds]
aturley has quit [Ping timeout: 272 seconds]
jemc has joined #ponylang
devbug has joined #ponylang
SilverKey has joined #ponylang
SilverKey has quit [Client Quit]
unbalancedparen has quit [Quit: WeeChat 1.5]
aturley has joined #ponylang
aturley has quit [Ping timeout: 244 seconds]
devbug_ has joined #ponylang
devbug has quit [Ping timeout: 272 seconds]
aturley has joined #ponylang
aturley has quit [Ping timeout: 260 seconds]
copy` has quit [Quit: Connection closed for inactivity]
amclain has quit [Quit: Leaving]
srenatus has joined #ponylang
jemc has quit [Ping timeout: 260 seconds]
aturley has joined #ponylang
aturley has quit [Ping timeout: 276 seconds]
<srm`>
the shadow under pony is useless
samnardoni has joined #ponylang
<SeanTAllen>
Is that supposed to be helpful feedback? Can we keep this community nice srm` ?
puzza007 has quit [Remote host closed the connection]
omarkj has quit [Remote host closed the connection]
gornikm has quit [Remote host closed the connection]
srenatus has quit [Remote host closed the connection]
russelldb has quit [Remote host closed the connection]
kushalp has quit [Remote host closed the connection]
jtfmumm has quit [Remote host closed the connection]
darach has quit [Remote host closed the connection]
strmpnk has quit [Remote host closed the connection]
<srm`>
i think it's a helpful feedback to give a better sticker, isn't it ?
<SeanTAllen>
That's not helpful.
<SeanTAllen>
X is useless isn't helpful.
<SeanTAllen>
It just makes you sound like a dick even if you didn't intend it that way.
<srm`>
ok, for my onpinion stick a sticker with a shadow under it, take lots of place
<SeanTAllen>
There are people doing volunteer work on the other side of that and "that's useless" isn't something that is going to go over well...
<srm`>
and the effect don't sounds good on a laptop
<srm`>
(sticker are often stick on a laptop)
<srm`>
stickers are more often a logo without shadow
<SeanTAllen>
There's the pony logo sticker as well
Applejack_ has joined #ponylang
<srm`>
ok
Applejack_ has quit [Client Quit]
<srm`>
sorry
<SeanTAllen>
Thank you
Applejack_ has joined #ponylang
Applejack_ has quit [Client Quit]
Applejack_ has joined #ponylang
devbug_ has quit [Ping timeout: 258 seconds]
trapped has joined #ponylang
jonrh_ has joined #ponylang
jonrh has quit [Ping timeout: 264 seconds]
<malthe>
SeanTAllen: i want those stickers
<malthe>
main's pretty cool looking to me
hibnico has joined #ponylang
jonrh_ is now known as jonrh
puzza007 has joined #ponylang
srenatus has joined #ponylang
omarkj has joined #ponylang
kushalp has joined #ponylang
russelldb has joined #ponylang
darach has joined #ponylang
strmpnk has joined #ponylang
<Applejack_>
hi, a question on Array algorithms used to fill them and corresponding GC : if I don't reserve the size of the Array, I get massive nonlinear increases in memory consumption when increasing the number of elements. I'm quite surprised by that behavior compared to Array with reserved size, so I was wondering what kind of algorithm was used to deal with Array resizing and I was also wondering if the GC
<Applejack_>
In the code I sent changing from 10000 elements to 30000 elements for example will show you what happens. Of course, when reserving the size things improve, but I still wonder how it is managed.
gornikm has joined #ponylang
jtfmumm has joined #ponylang
<malthe>
Applejack_: ya because the auto-reserve method seems to reserve space for the exact amount needed (i.e. +1).
<malthe>
it should grow geometrically.
<malthe>
(at least configurably.)
tm-exa has joined #ponylang
<Applejack_>
malthe: it should use the doubling when full, halving when quarter full algorithm
<Applejack_>
And what about the GC of the abandoned arrays? It looks like memory explodes because they don't get GC, or at least that seems to me a possible explanation for the explosive growth.
hibnico has quit [Quit: hibnico]
tm-exa has quit [Quit: Computer has gone to sleep]
Arch-KT has joined #ponylang
Arch-TK has quit [Ping timeout: 244 seconds]
omarkj has quit [Remote host closed the connection]
kushalp has quit [Remote host closed the connection]
jtfmumm has quit [Remote host closed the connection]
srenatus has quit [Remote host closed the connection]
puzza007 has quit [Remote host closed the connection]
darach has quit [Remote host closed the connection]
russelldb has quit [Remote host closed the connection]
strmpnk has quit [Remote host closed the connection]
gornikm has quit [Remote host closed the connection]
puzza007 has joined #ponylang
srenatus has joined #ponylang
gsteed has joined #ponylang
omarkj has joined #ponylang
kushalp has joined #ponylang
russelldb has joined #ponylang
darach has joined #ponylang
strmpnk has joined #ponylang
gornikm has joined #ponylang
jtfmumm has joined #ponylang
c355e3b has joined #ponylang
gsteed has quit [Remote host closed the connection]
hibnico has joined #ponylang
<SeanTAllen>
Applejack_: I've been looking at something like this. Its not specific to Arrays. I went into it thinking that it was a memory leak and I'm reasonably sure now that it isn't but I still need to do a deep dive through the pool allocator.
<SeanTAllen>
I have some ideas but I did to look into some stuff some more before I say anything
Praetonus has joined #ponylang
<hibnico>
AFAIK, the GC can only run between message handling
<hibnico>
so in the main actor, nothing can get garbage collected
<Applejack_>
hibnico: Suppose I had an actor called Storage separate from Main, and in Main I would have the create behaviour in which I would loop over some integer and at each iteration I would send a message to Storage containing the element to be pusshed to an Array held internally in Storage, then because I would summon Storage.add at each iteration then the abandonned arrays inside Storage would get GCd
<Applejack_>
between each such message ?
<hibnico>
yes, that is what I understand of how the GC works
<Praetonus>
Applejack_: You're allocating Arrays in Main and sending them to Storage?
<Applejack_>
Praetonus: No, I actually push in Main.create, but because of the problems I encountered if not reserving the space, I made the hypothesis that there was a GC problem made worse by the algorithm used to resize the Array which apparently adds 1 space for each extra element encountered instead of using better approaches
<Applejack_>
and hibnico remarked that there was no GC in between messages, thus my "suppose" above
<hibnico>
I wrote that there are GC *only* between messages. Note though that I’m not 100% sure, I have read this somewhere in the user mailing list.
<Praetonus>
Yes, GC occurs only between behaviours. Pushing a lot of stuff into an Array without reserving memory before would indeed generate a lot of garbage, and is terrible for performances because you're spending a lot of time copying data
<Applejack_>
Praetonus: Yes, but as I said it is made much worse than it should be by the resizing "algorithm", which only extends size by 1 when overflow occurs
<samnardoni>
Hi guys. I'm on a Windows machine and want to play around with Pony, but can't be bothered to build it from source. What's the easiest way I can have a play with Pony? Is there an online "try pony" available anywhere?
<Applejack_>
samnardoni: Hi, the original Pony sandbox has been deprecated, and no replacement exists AFAIK
<samnardoni>
That's a shane :(
<samnardoni>
shame*
<Praetonus>
Yes, the resizing is quite awful. I think opening an issue would be good to discuss about better patterns
<Praetonus>
samnardoni: You can install the compiler with Docker. We should also get nightly builds soon. I don't have much information about it, I suggest getting in touch with a member of the core team for more details
<Candle>
samnardoni: I threw a VM together, and built ponyc there.
<samnardoni>
Praetonus: Cheers, but I've already tried it with Docker and the Windows Boot2Docker and couldn't get it to work. Nightly builds would be great!
<samnardoni>
It's amazing how different Rust is now though...
<samnardoni>
I've got to admit... I really like the look of Pony. Just watched a couple of youtube vids of conference talks and I'm really impressed
<hibnico>
how rust is different now ? I only know rust by the read of its tutorial
<samnardoni>
hibnico: It's been slowly morphing into C++ pretty much
<samnardoni>
It used to look reasonably similar to Pony a few years ago
<SeanTAllen>
samnardoni: unfortunately the sandbox got very behind and we don't have the source to it :(
<samnardoni>
SeanTAllen: That's a shame. I think either a "try online" or prebuilt binaries are a massive win for attracting developers
<SeanTAllen>
Applejack_: I don't think there is a GC leak. Ive spent 2 months determining that I dont think there is one. But, there appears to be some very odd emergent behavior between the values you set for gcfactor and gcinitial. I'm seeing very interesting stuff that I have to sit down and wrap my head around at some point.
<Applejack_>
samnardoni: Pony really got me hooked, then led me to Erlang and what Joe Armstrong says in his many videos enlightened me and increased further my interest in Pony
<SeanTAllen>
samnardoni: agreed. we'd love someone to take on an iPython kernel. and we could really use someone who is good at release engineering to help get our build pipeline sorted. we're make slow progress on the latter but it is slow at the moment.
aturley has joined #ponylang
<samnardoni>
Applejack_: Good idea. I've been wanting to watch some more Pony talks but couldn't find any. I think watching more about Erlang/Actor programming in general is a great idea!
<samnardoni>
SeanTAllen: I'd love to help but I'm awful at release/builds etc. :P
<Applejack_>
samnardoni: I'm exploring Pony for scientific computation, and it either impresses me or disappoints me for some reason that's not inherent to the language but rather due to some implementation problem like the array stuff
<samnardoni>
That's interesting. I guess it's a good sign to be annoyed by implementation details rather than the language though :)
aturley has quit [Ping timeout: 240 seconds]
<SeanTAllen>
Applejack_: the pony VUG June Meetup is about the actor model
<SeanTAllen>
Info is in the group. Monthly over zoom.
<SeanTAllen>
3 30 eastern usually
<Candle>
Which eastern? US? Europe?
<Applejack_>
sylvanc says his three goals are Safety _together with_ Speed, "performance is the only metric" and I like that for my interest in scientific computing
<Applejack_>
So because I want easy concurrency, and help with parallelisation, together with safety and speed, I decided to give Pony a serious try
<samnardoni>
Yeah I've heard Erlang is slow when it comes to 'computation' (but it's awesome for the stuff it's made for)
<SeanTAllen>
Still plenty of rough edges Applejack_ but we are using it at work so we are pushing it quite heavily and accelerating development
<samnardoni>
"Speed" is interesting though. There's always throughput vs latency....
<Applejack_>
SeanTAllen: ok, excellent
<samnardoni>
SeanTAllen: Ah so Pony is being used in production?
<Applejack_>
SeanTAllen: (I was refering to the VUG)
<Applejack_>
SeanTAllen: so Sendence is to Pony what Mozilla is to Rust ?
<SeanTAllen>
samnardoni: we aren't in production yet. Earlier versions of ponyrt have been in prod used from C to several years.
<Applejack_>
I mean, it's the company that pushes Pony for some possible production work?
<SeanTAllen>
Mozilla is huge Applejack_, we are small so I'm wary of the analogy but we are investing in Pony
<Applejack_>
Yeah, I know, I wasn't trying to imply something
<Applejack_>
Just to understand the dynamics
<SeanTAllen>
Pony has been making hard things easy for us and because of its immaturity, some easy things hard
<Applejack_>
In some cases if there's no corporate support, things don't grow, Armstrong is quite explicit about that in the case of Erlang/Ericsson
<Applejack_>
It's important to know what kind of support Pony gets, because at this early stage, investing time into learning the language and developing some libraries is risky for developers who don't have the desire nor capacity to work on the language internals
<Applejack_>
libraries and applications I mean
<Applejack_>
What king of application are you targeting ?
<Applejack_>
s/king/kind
<SeanTAllen>
Stream
<SeanTAllen>
Processor
tm-exa has quit [Quit: Bye bye - have a good <insert timezone day period>]
<SeanTAllen>
Data analytics
<Applejack_>
samnardoni: We're working on rewriting the Julia benchmarks for Pony
<Applejack_>
Fintech?
<SeanTAllen>
It's the initial market, yes
<Applejack_>
And what about Causality? What do they target really ? Adapting Pony to potential customers interested in safety and speed and concurrency ?
<SeanTAllen>
Causality doesn't exist anymore
<Applejack_>
ah
<Applejack_>
Has it morphed into Sendence?
<SeanTAllen>
No connection between the two companies
<Applejack_>
do you know of any other company involved with Pony?
<SeanTAllen>
Yes but they don't talk about it publicly and aren't involved in the open source version
<SeanTAllen>
I also know of a couple things that were in the works but I don't know what happened w them
<Applejack_>
ok, interesting, thanks
<lisael>
hello, pony folks o/
<lisael>
I found a segfault in ponyc
<lisael>
on recursive type alias
<lisael>
type Foo is (Array[Foo], String, None)
<SeanTAllen>
Recursive isn't allowed
<SeanTAllen>
At the moment
<lisael>
there's no syntax error ( i understand why recursive type aliases are impossible)
<SeanTAllen>
Should be a compiler error
<lisael>
on master it segfault
<lisael>
linux 64
<lisael>
0.2.1-927-g98bdb41
<SeanTAllen>
Can you open an issue with a minimal case to recreate along w llvm version, OS etc?
<lisael>
sure :)
<SeanTAllen>
Thank you lisael
aturley has joined #ponylang
aturley has quit [Ping timeout: 250 seconds]
aturley has joined #ponylang
SilverKey has joined #ponylang
<Applejack_>
SeanTAllen: Is there anyone working actively on Array (resizing) and more generally the collections package?
<lisael>
It segfault ony if there's a Map in the type
<shepheb>
that's a perfectly legal recursive type alias! it should work, but doesn't, and it makes me (and JSON parsing code) sad.
Arch-TK has quit [Quit: I hate quit messages with fucking URLs in them.]
SilverKey has quit [Quit: Halted.]
<lisael>
shepheb: the problem here is the segfault, more than the illegality of the statment
<shepheb>
yup
<shepheb>
they're not supported, and there are crash bugs there.
<lisael>
I wish it'd work too, but it's another issue :)
<shepheb>
unfortunately it's a very deep issue in the compiler. as I understand it, aliases are expanded eagerly, which is obviously a problem for recursive aliases.
<shepheb>
it would need to be heavily rewritten to treat aliases as a new type, with a flexible is-this-type-a-member-of-this-other-type function.
<shepheb>
(caveat: I have no idea what I'm talking about; this is just my impression from the outside.)
<Applejack_>
Is that something that was proved not to be possible to happen in Pony ? If so, does it happen because of the principle's implementation ?
<shepheb>
Applejack_: what do you mean?
unbalancedparen has joined #ponylang
Arch-TK has joined #ponylang
<Applejack_>
shepheb: I mean that sylvanc has proved stuff about the type system, formally, and I was wondering if that segfault was amont the things proven formally never to happen, and if so if that happening was due to the implementation of the principles in the compiler which couldof course not be faithful to the idea
<shepheb>
I don't know either way. I think the segfault is a bug in the implementation; some cases trigger an error message rather than a segfault.
<Applejack_>
well, as for the array resize thing, it's different if it's the implementation that fails or the language's underlying principles
<Praetonus>
The memory safety guarantee is for Pony programs. The compiler is written in C it doesn't apply here
<Applejack_>
Praetonus: Ah, I see
<samnardoni>
Any plans for Pony to be a self-hosting compiler? Or just too much work for too little gain at the moment?
<hibnico>
I have read that it is a wish of the core team
<Applejack_>
( Applejack_ would really like to watch a compiler bootstrap itself in the console while stdouting the phases it goes through, he finds the idea fascinating)
SilverKey has joined #ponylang
<lisael>
The segfault in the compiler doesn't break the no-crash promise of pony, per-se, but it's not a good signal for people who came to pony because of this promise
SilverKey has quit [Client Quit]
<hibnico>
this segfault doesn’t tell about the language, it tells about its maturity, especially since it is the compiler that crashes
aturley has joined #ponylang
jemc has joined #ponylang
SilverKey has joined #ponylang
aturley has quit [Ping timeout: 272 seconds]
<samnardoni>
Although a Rob Pike quote: (paraphrasing) 'One bad thing about bootstrapping the compiler too early is that you end up with a language that's great to write a compiler in but not so useful for other stuff'
<SeanTAllen>
Applejack_: some conversation around getting zero copy working but not resizing. Non API changes are welcome via PR. API changes need to go through RFC process. Weekly sync call is s good place to bring up what you are thinking about.
<SeanTAllen>
Applejack_: segfault is implementation
<SeanTAllen>
Re: pony in pony. Yes but not the runtime. Writing a GC in pony would be very hard.
<SeanTAllen>
Type system is safe, implementation is not. Because humans make mistakes.
<jemc>
samnardoni: I've been working (slowly) on the pony compiler in pony stuff - one small step at a time and lots of yak shaving in between
<jemc>
trying to approach it carefully so as to be sure that I'm not going to be unloading a big pile of technical debt on the project
Applejack_ has quit [Ping timeout: 250 seconds]
runehog has quit [Remote host closed the connection]
<jemc>
make good architecture decisions, be sure that the language and standard library support good patterns, etc
<samnardoni>
jemc: good stuff :)
<jemc>
the zero-copy string slicing is one piece of that yak shaving
<jemc>
Applejack_: regarding array resizing - I was under the impression that the internal buffer size grows by powers of 2, not by adding 1 element - but it's been a while since I looked at that piece of code so I may be wrong
<jemc>
you definitely want to reserve your space ahaead of time though - or, if you can, use `append` instead of `push`ing a bunch of times, because `append` will reserve space for you
<jemc>
when you resize a bunch of times within a single behaviour, the intermediary buffers (between the initial size and the final size) will not be garbage collected, because Pony only garbage-collects between behaviours
<samnardoni>
jemc: I had a sneaky-peak at the Array implementation earlier, and it looks like a change was introduced a few weeks back that changed it from next power of 2 to size+1...
<SeanTAllen>
its doing 1 at a time jemc.
<SeanTAllen>
for array resizing
<SeanTAllen>
samnardoni: do you know what commit that was at?
<samnardoni>
reserve() previously did the next-power-of-two conversion, now it blindy accepts whatever size it is given to reserve, and reserve is called via reserve(size+1) in push()
<SeanTAllen>
i'll have to check with Sylvan on that once he comes off holiday this wekeend
<samnardoni>
I watched a talk about Pony earlier, and I think it was Sylvan giving the talk. All I've got to say that it was an amazing talk and really piqued by interest in Pony
<SeanTAllen>
looks like a mistake
<SeanTAllen>
thanks samnardoni
<samnardoni>
no problem
<SeanTAllen>
i emailed that to sylvan it really looks like a mistake when there was a rename
<SeanTAllen>
but, i'm not 100% sure
<samnardoni>
jemc: is your Pony-in-Pony on Github or anywhere? I'd love to follow along
<samnardoni>
(I appreciate if you don't want to make it public though)
<jemc>
samnardoni: I like to work in public on almost everything from an early stage
<jemc>
right now the main work is happening in packages that the eventual compiler will use
<jemc>
I haven't done an initial commit yet, but the pony-in-pony compiler stuff will probably be at https://github.com/jemc/ponycc
<jemc>
I'll go ahead and create the repo in case anyone wants to subscribe
<samnardoni>
I'm stalking you on Github now so I'll know when you do :)
<jemc>
created
<samnardoni>
Watched and starred :P
<samnardoni>
That sweet sweet vapourware
<jemc>
once I've got a nice POC, at some point I'll probably try to transfer the code to the "official" org, but for now it is most convenient to work on my own in a very antisocial way :)
<jemc>
haha, yep, breathe in those vapours!
<samnardoni>
Rust has a nice approach. They have a "rustlang-nursery" org for 'ideally one-day will be official but WIP currently'
<samnardoni>
I think the usual process is: 1) Starts as a repo in the users space. Once it's got a bit of traction, moves to 2) The rustlang nursery for more exposure for work, then once it's at a 1.0 kind-of stage, moves into 3) The official rust org.
<jemc>
yeah, that does sound like a nice process
<jemc>
individual -> collaborating -> official
<samnardoni>
Spot on
<jemc>
probably nice to not make that leap immediately from 1 to 3
<samnardoni>
Exactly
<samnardoni>
notable examples are rustfmt and regex
<samnardoni>
You don't want to put a half-baked regex implementation as the official one
<samnardoni>
But you also want to let people know, heyy guys, there is a regex library, here it is in the nursery
<samnardoni>
Anyway, home time for me. Catch you guys later.
samnardoni has quit [Quit: Page closed]
amclain has joined #ponylang
hibnico has quit [Quit: hibnico]
aturley has joined #ponylang
aturley has quit [Ping timeout: 260 seconds]
aturley has joined #ponylang
<darach>
Ooo! ponycc
aturley has quit [Ping timeout: 276 seconds]
rurban has joined #ponylang
<jemc>
:D
rurban has left #ponylang [#ponylang]
runehog has joined #ponylang
runehog has quit [Remote host closed the connection]
runehog has joined #ponylang
SilverKey has quit [Quit: Halted.]
<Candle>
Remind me, I have an Array[U8] ref from array.slice() (which is already clone'd). How do I get a Array[U8] val from that so I can pass it to String.from_array(..) ?
SilverKey has joined #ponylang
<jemc>
Candle: you need a recover block around the creation of the ref to enforce that you don't "leak" any mutable references
<jemc>
so assuming you're `clone`ing from a `val`, you want to pass the original `val` to inside the recover block, then clone and slice inside the recover block, then return the newly created `ref` at the end of the recover block to recover to a higher cap (like iso or val)
<jemc>
I've got an RFC open for a couple new API calls that let you slice without copying (calling it `trim`), including a function which lets you trim a `val` to get a new `val` that shares the same underlying memory
<Candle>
The only way I've got it to work is ugly. Create a new string and push() the bytes on. :(
<jemc>
ah, well this is actually a common pain point - we are lacking an iso clone for Array - String.clone returns an iso, but Array.clone returns a ref (because in the case where Array has non-sharable elements, the iso clone would have tag elements)
<jemc>
this has come up before in discussion and so far we have different ideas about how best to address it
<jemc>
some would involve using type params and/or viewpoint adaptation in a clever way, some would involve just adding a second method to do an iso clone
<jemc>
either way, we recognize that the status quo on this currently sucks
<Candle>
Fair enough, I'll stick with my ugly way for now and note the problem.
jemc has quit [Quit: WeeChat 1.4]
jemc has joined #ponylang
copy` has joined #ponylang
Applejack_ has joined #ponylang
<Applejack_>
A question on the homogeneous distributed Pony Sendence works on: we shall just, like, declare the nodes in some way in the source code, and otherwise use actors/behaviours as before ? I mean, it should just be a matter of adding a node declaration to already working Pony programs, and off we go?
<Applejack_>
Just to see what I can count on in the near future, and what kind of changes it would require in existing code.
<SeanTAllen>
Applejack_: so the general idea is that you supply the location of a node in a cluster when you start your app up and you join that cluster
<SeanTAllen>
for a while, you need to be running the same binary and there will be no actor migration by end of summer.
<SeanTAllen>
sylvan and i sketched out an API that we think will be good for doing calls on remote actors but we'll see how it survives actual use.
<SeanTAllen>
the moment something gets finished for distributed pony, we start using it in our stuff
<SeanTAllen>
and we start shaking bugs out
<SeanTAllen>
initially there is no "spawn a node". you do that outside of pony. but you can send messages to remote actors.
<SeanTAllen>
for each distributed pony node to node connection, there's a tcp connection that is used to communicate over so casual messaging should still apply. we have testing infrastructure that we will be able to deploy to shake out bugs and verify that.
<Applejack_>
Ok, fine
<Applejack_>
jemc: what's a weekly sync ?
SilverKey has quit [Quit: Halted.]
SilverKey has joined #ponylang
<SeanTAllen>
we have a zoom call every Wednesday Applejack_. If you are on the pony+dev list, its on the calendar.