<jemc>
you can also try to isolate your blocking calls to a single actor or two so that you're not blocking *every* scheduler thread as you might if you were making blocking calls everywhere
<jemc>
I haven't played with the opengl API before, so not sure how this would apply
<pragma_>
yeah luckily most of the api calls dont block
<pragma_>
i also have to wrap my head around the actor model first to see if how that would interplay :)
<jemc>
the main thing to keep in mind is that each actor will execute just one behaviour at a time, so each behaviour can be seen as an atomic transaction over the actor's internal state
<pragma_>
i'm not sure how all non blocking actors would map to external events like you want to render a frame every 16ms so maybe there has to be some sort of external synchronisation.
MC_Hamming has quit [Remote host closed the connection]
<jemc>
You'll have to excuse my OpenGL illiteracy, but is the framerate an externally driven event? As in, does OpenGL initiate each frame with some sort of callback in a thread that it manages, or does your application initiate each frame and send the new buffer to OpenGL?
<jemc>
because if its the latter it would be pretty easy to do in Pony - just use a 16ms recurring `Timer` actor to initiate each frame
Perelandric has joined #ponylang
<pragma_>
you have the option to explicitly wait until the screen is ready to swap the content of your buffer to the front. you can also issue multiple frames without manually synchronising it. but you have to make sure there are not to many frames in flight otherwise you will have an increased input lag.
<pragma_>
so something like a timer or an actor who counts the number of frames that are in flight might actually work
<zaquest>
o_O there's no math library yet, i guess there's no chance to find ready to use bindings for something like gmp. how young is the langauge? :D
<jemc>
pragma_: yeah, I imagine it's going to be an interesting exercise, but definitely possible
<pragma_>
yes :) sounds like fun
<jemc>
pragma_: if you come up with something, please do share it with the rest of us :)
<pragma_>
sure i will
<jemc>
it'd be cool to have an opengl-wrapping library that took care of most of the dirty work for you
<jemc>
zaquest: not sure what kind of math you're looking for, but there are some useful math methods you can call on the builtin numeric values themselves
<jemc>
pragma_: anyway, I've been playing around with a somewhat more complex case which actually *does* involve callbacks invoked from another thread (JACK audio)
<jemc>
so far I've got a little proof of concept that will uses a pair of file descriptors to interface between the callback thread and the pony-scheduled actor
<jemc>
I'd like to clean it up and make it generic as well at some point
<zaquest>
jemc, oh, thank you. found the methods.
<pragma_>
audio isnt really forgiving when it comes to lag. so i guess when it works for audio it will be fast enough for most things
<jemc>
I'm not 100% sure my strategy is going to work *well* for audio, but the proof of concept works at least :)
<unbalancedparen>
where can i read more about pony scheduler?
<unbalancedparen>
is it preemptive in some way with a reduction budget like erlang?
<shodan45>
reading the code of conduct, I wonder at what point just saying "... everyone, regardless of ANYTHING AT ALL" will overcome the need to list out all those different personal traits :)
<jemc>
unbalancedparen: pony uses a work-stealing algorithm for scheduling
<jemc>
the paper as a whole is oriented toward distributed pony, which is still a WIP, but the description of the scheduling and work stealing algorithm is also applicable to the local pony runtime
SilverKey has quit [Quit: Halted.]
<unbalancedparen>
i will read it, thanks
<unbalancedparen>
in the meanwhile, could you sum up how does the work stealing algorithm works in pony?
<unbalancedparen>
if you don't have time, that is perfectly fine :)
<shodan45>
heh, pony devs were surprised that 49% of people wanted to use pony for web dev? for better or worse, that's where a lot of people make a living...
<shodan45>
myself included
<unbalancedparen>
me too :P
* shodan45
goes back to editing a giant JS file... that just calculates a bunch of numbers on a form ;(
<jemc>
shodan45: probably was a surprise because a lot of the early adoption of Pony has been in fintech
<jemc>
unbalancedparen: yeah, the short summary of the scheduler is pretty simple -
<jemc>
the pony runtime runs on N scheduler threads, where N will default to the number of cores on your system unless you specify otherwise with a CLI arg `--ponythreads`
<jemc>
every time you send a message to an actor it is seen by the scheduler as a unit of work
<jemc>
when a scheduler thread has no work to do, it tries to steal some work from other scheduler threads
<unbalancedparen>
if a pony process is running and has a lot of messages in its queue, the scheduler will stop assigning cpu shares to that process at some point?
c355e3b has quit [Quit: Connection closed for inactivity]
<jemc>
it's not so much about cpu shares - the pony runtime doesn't deal with slicing time and leaves that up to the OS
<unbalancedparen>
my concern is the following one: if i design my system with an process/actor per user, what would happen if a user is doing something really cpu intensive
<unbalancedparen>
other actors will be affected?
<jemc>
well, pony doesn't currently track the sizes of actors' message queues
<unbalancedparen>
i think i am not expressing my question well enough, i am not a native speaker and i am a little bit asleep, sorry
<jemc>
if you need backpressure or throttling, you'll have to do it explicitly at the application level
<unbalancedparen>
jemc: thanks your information is really useful :)
<unbalancedparen>
jemc: last question: there is a global GC?
copy` has quit [Quit: Connection closed for inactivity]
<unbalancedparen>
or there is a GC per actor like in Erlang?
<jemc>
GC is per-actor, but it's not quite like erlang - the pony GC is actually pretty special and has its own paper :)
<unbalancedparen>
i have watched the talks but completely forgot about some of the key semantic aspects of pony
<unbalancedparen>
anyway, my biggest concern with pony is more related to supervisors and how to handle mistakes
<jemc>
around 30min in he talks about the unbounded message queues in pony, and how the backpressure problem basically gets pushed to the "edges"
<jemc>
the erlang paradigm of supervisors isn't quite as applicable to Pony, because the "let it crash" mentality is not as applicable
<jemc>
SeanTAllen likes to call it "let it crash at compile time"
<unbalancedparen>
i know, i have read about that
<unbalancedparen>
and even discussed via email with sean
<jemc>
however, having hierarchies of actors that have different tiers of responsibilities is totally idiomatic for pony, so in that sense, I think it is applicable
<unbalancedparen>
my issue with let it crash at compile time is that the compiler can't detect all errors
<jemc>
because of the capability-security and the lack of ambient authority, you have to pass down and refine authority through a hierarchy starting at the `Main` actor
<unbalancedparen>
some errors can only be detected at runtime and I don't want to have my system crash because i did not handle some edge case
<unbalancedparen>
i will try to code some more pony code to be sure that my concern is real for the type of things i want to use pony
<unbalancedparen>
anyway, i really like pony :) it is a great language
<jemc>
well, pony's way of error handling really pushes you into addressing every possible error explicitly, as close to the point of error as you can
<unbalancedparen>
that is great, and i think in some way ML, Rust and Haskell try to do that
<jemc>
a pony program shouldn't crash except in an extreme case like running out of memory
<jemc>
if your error is one that you can't handle in a reasonable way, you'd have to explicitly stop your program yourself (by taking whatever action necessary to dispose of any listening actors, so it can arrive at quiescence)
<jemc>
but mostt of the time in practice you'll handle, swallow, or log the error explicitly using application-specific mechanisms
<unbalancedparen>
i have read the documentation, but i want to code a few examples
<unbalancedparen>
a few more examples
<unbalancedparen>
to be able to ask how you would handle a few problematic scenarios that i normally have in Erlang
<unbalancedparen>
like receiving bad input or dealing with some bad network protocol implementation
<jemc>
SeanTAllen: I just realized that since the move to gitbook, pony source code is no longer highlighted
<jemc>
(in the tutorial)
<jemc>
so I've been working on a quick PR to highlight.js to try to fix that
aturley has joined #ponylang
aturley has quit [Ping timeout: 240 seconds]
SirWillem has joined #ponylang
Praetonus has quit [Quit: Leaving]
graaff has joined #ponylang
unbalancedparen has quit [Quit: WeeChat 1.5]
aturley has joined #ponylang
aturley has quit [Ping timeout: 272 seconds]
SilverKey has joined #ponylang
SilverKey has quit [Quit: Halted.]
graaff has quit [Quit: Leaving]
amclain has quit [Quit: Leaving]
dididada has joined #ponylang
dididada has quit [Client Quit]
rurban has joined #ponylang
rurban has left #ponylang [#ponylang]
aturley has joined #ponylang
aturley has quit [Ping timeout: 250 seconds]
<malthe>
jemc: how come Array.clear() doesn't have to iterate through elements and unset them, when HashMap._resize has to?
<malthe>
(just trying to understand how it works, sorry ..)
srenatus has joined #ponylang
devbug has quit [Ping timeout: 272 seconds]
Willem has joined #ponylang
jemc has quit [Ping timeout: 276 seconds]
SirWillem has quit [Ping timeout: 244 seconds]
aturley has joined #ponylang
aturley has quit [Ping timeout: 264 seconds]
Applejack_ has joined #ponylang
rurban1 has joined #ponylang
rurban1 has left #ponylang [#ponylang]
rurban has joined #ponylang
<malthe>
looking a bit at object allocation size, it seems like there's a 36 byte allocation overhead. is that about accurate?
aturley has joined #ponylang
aturley has quit [Ping timeout: 250 seconds]
Praetonus has joined #ponylang
trapped has joined #ponylang
rurban has left #ponylang [#ponylang]
copy` has joined #ponylang
<SeanTAllen>
jemc: awesome. i was hoping someone would do that.
georgem_ has joined #ponylang
aturley has joined #ponylang
georgem_ is now known as Guest37577
Guest37577 is now known as georgemarrows
aturley has quit [Ping timeout: 244 seconds]
rurban has joined #ponylang
rurban has quit [Ping timeout: 250 seconds]
Perelandric has joined #ponylang
TwoNotes has joined #ponylang
pulpfiction has quit [Quit: Leaving]
rurban has joined #ponylang
c355e3b has joined #ponylang
Applejack_ has quit [Ping timeout: 264 seconds]
rurban has left #ponylang [#ponylang]
rurban1 has joined #ponylang
rurban1 has left #ponylang [#ponylang]
unbalancedparen has joined #ponylang
Applejack_ has joined #ponylang
<Perelandric>
It seems that a tuple can't be defined as the parameter for a 'case function', like `fun test(t: (U8, U8)) =>`. I get... "can't capture a tuple, change this into a tuple of capture expressions". I've tried many different forms. Is there a proper way to do this?
rurban has joined #ponylang
georgemarrows has quit [Ping timeout: 252 seconds]
rurban has left #ponylang [#ponylang]
georgemarrows has joined #ponylang
aturley has joined #ponylang
aturley has quit [Ping timeout: 250 seconds]
gsteed has joined #ponylang
SilverKey has joined #ponylang
SilverKey has quit [Quit: Halted.]
aturley has joined #ponylang
jemc has joined #ponylang
aturley has quit [Ping timeout: 272 seconds]
SilverKey has joined #ponylang
jemc has quit [Quit: WeeChat 1.4]
jemc has joined #ponylang
SilverKey has quit [Read error: Connection reset by peer]
SilverKey has joined #ponylang
<Applejack_>
fg
<Applejack_>
Perelandric: you mean that declaring such a function does not compile?
<Applejack_>
Hi, anyone knows how to convert a Range[F64](0,10) into an Array ?
<Perelandric>
AppleJack: Yes, as part of a "case function", it gives the error text.
<Applejack_>
For me case function means you have the same named function with different argument types, is that what you also mean?
<Perelandric>
Yes, a second would be say... `fun test(t: U8) => ...`
<jemc>
Perelandric: in general, you can't `match` a tuple against a non-tuple or against a tuple of a different size
<jemc>
case functions are implemented as syntax sugar for `match` blocks, so that's why it doesn't work
<Applejack_>
Perelandric: I made it work with type Foo is (U8,U8)
<Applejack_>
and type Fii is (F32,F32)
<Applejack_>
and then two definitions first with argument Foo second with Fii
<Applejack_>
didn't yet try with Fii is U8, a non tuple
<Perelandric>
jemc: I think I actually had a little better success with toying with it as a `match`, though I may be remembering incorrectly. So are you saying that a `tuple` isn't necessarily a type?
<Applejack_>
apparently it works too
<Perelandric>
Applejack: Thanks! I'll play around with that.
Praetonus has quit [Quit: Leaving]
georgemarrows has quit [Remote host closed the connection]
<Perelandric>
Applejack_: Seems to work!
<jemc>
Applejack_: regarding converting an Iterator into an Array, you can do `Array.concat(iter)`
SilverKey has quit [Quit: Halted.]
runehog has quit [Read error: Connection reset by peer]
<jemc>
Perelandric: runtime type matching is done by comparing object headers
runehog has joined #ponylang
<jemc>
a tuple doesn't have overhead of an object header - it's just a sequence of other types
<jemc>
I'm pretty sure that's why it is that way, though I personally haven't looked at the code in question
<Perelandric>
jemc: I see, thanks for the info. So making an alias must add some overhead?
<Perelandric>
(type alias)
<jemc>
no, I don't think it does
<Applejack_>
Perelandric: cool
<jemc>
type aliases get resolved at compile time to the type they reference
SilverKey has joined #ponylang
<Perelandric>
jemc: That would make me wonder why a tuple fails but an alias to a tuple succeeds in a case function.
<jemc>
Perelandric: honestly I'm surprised to hear that it does work - there might be bugs afoot
<jemc>
case functions are a relatively unpolished feature right now
<Perelandric>
jemc: I see. I'll continue, blithely assuming it'll work and will rework it if it breaks. ;)
<Perelandric>
Thanks all for the assistance!
<jemc>
I'll try to take a look later and investigate but I have a lot of other stuff on my plate today, so I may not get to it immediately
rurban has joined #ponylang
<jemc>
no problem - good luck! :)
<Applejack_>
jemc: concat had not caught my eyes in the stdlib doc...
rurban has left #ponylang [#ponylang]
<Applejack_>
Perelandric: in case you did not know, the case functions return a union type to which a None is added to your existing possible output types. I got biten by that.
<Perelandric>
Applejack_: Good to know. Thanks for the heads-up!
<jemc>
malthe: Array is built on Pointer, while HashMap is built on Array.
<jemc>
malthe: assigning _MapDeleted in HashMap has more to do with the hash map algorithm and entry detection than it does with memory management
amclain has joined #ponylang
shodan45 has quit [Quit: Konversation terminated!]
SilverKey has quit [Quit: Halted.]
Applejack_ has quit [Ping timeout: 258 seconds]
SilverKey has joined #ponylang
<dos000>
for pony package managers cant you use maven ? this would make integaration with all the jvm tools much easier
<dos000>
this is a far fetched idea but i cant see why reinvent the wheel here
graaff has joined #ponylang
SilverKey has quit [Quit: Halted.]
aturley has joined #ponylang
SilverKey has joined #ponylang
aturley has quit [Ping timeout: 272 seconds]
copy` has quit [Quit: Connection closed for inactivity]
runehog has quit [Remote host closed the connection]
<malthe>
but I think I understand the pointer gc stuff now; the old _array goes away and the pointer instrinsics take care of the gc'ing.
<malthe>
I did some testing on object allocation size and found that a string object takes up a minimum of 92 bytes. is that about right?
<jemc>
don't know - I haven't measured myself
SilverKey has quit [Quit: Halted.]
<malthe>
some of it is an overhead from the memory allocator and some of it maybe from the gc handle to it, but it would be interesting to have documented exactly what the overhead is and why
SilverKey has joined #ponylang
<jemc>
I'm personally still learning about the pool allocator and other memory-related stuff myself
Applejack_ has joined #ponylang
runehog_ has joined #ponylang
runehog has quit [Read error: Connection reset by peer]
unbalancedparen has quit [Quit: WeeChat 1.5]
Matthias247 has joined #ponylang
MC_Hamming has quit [Remote host closed the connection]
aturley has joined #ponylang
<malthe>
jemc: wdyt about small string optimization techniques? in libc++ for example, std::string runs in two modes, short and long; it's designed to fit a 22-byte zero-terminated string in the object itself (which is 24 bytes in size), without needing to expand to long form that requires a separate allocation.
<malthe>
but it's a space/time trade-off because there's going to a branch instruction for every access to the string (to see which mode it's in).
aturley has quit [Ping timeout: 260 seconds]
SilverKey has quit [Quit: Halted.]
SilverKey has joined #ponylang
copy` has joined #ponylang
SilverKey has quit [Quit: Halted.]
unbalancedparen has joined #ponylang
rurban has joined #ponylang
aturley has joined #ponylang
<Applejack_>
What's the logic behind allowing both fun and be in actors? How can synchronous and asynchronous live together ? If a be changes the state of the actor, and the fun reads it, what happens?
srenatus has quit [Quit: Connection closed for inactivity]
SilverKey has joined #ponylang
aturley has quit [Ping timeout: 276 seconds]
<Applejack_>
I get some raference capability error, which I don't yet understand in detail, but it certainly says that mixing fun and be inside actors is bad. So why allow it in the first place ?
SilverKey has quit [Client Quit]
SilverKey has joined #ponylang
<jemc>
Applejack_: `fun` is allowed on actors mainly so that it can call itself synchronously within a `be`
<jemc>
Applejack_: Pony's reference capabilities will not allow synchronous calls on an actor from outside the actor if they can read or write state
<jemc>
this means you can call a synchronous `fun tag` on an actor from the outside, but usually this is only useful for wrapping a call to a `be` of the actor
<jemc>
since the `fun tag` cannot read any state
<jemc>
note also that you can have outside code call functions of the actor, as long as the execution of the outside code takes place inside the actor, since the `ref` reference to an actor can't leave the actor - that sounds confusing when I type it out like that, but see this pony pattern I wrote for a better explanation: http://patterns.ponylang.org/async/access.html
<jemc>
malthe: I'm not the best person to ask about memory management I think
<jemc>
as far as knowing intuitively when various optimizations would be good for or bad for overall performance
<TwoNotes>
My program is now 7 separate pieces that communicate by broadcasting JSON strings over UDP. very tedious. Distributed Pony would be kinda nice about now.
<SeanTAllen>
@TwoNotes: there is serialize/deserialize in master. That could help you some. It was a giant boon for us.
<TwoNotes>
It has a lot of restrictions as I recall. As I am distributed over dissimilar architectures, it can't be all one comilation unit
<TwoNotes>
These are separate command-line-level programs. (Multiple executables) They have to be able to find each other
<SeanTAllen>
Ah well
<SeanTAllen>
That's going to be an issue for a while
<TwoNotes>
There was a roadmap for distributed Pony. I thought there were supposed to be some results this summer
<SeanTAllen>
TwoNotes: the same binary constraint is going to be there for a while
<jemc>
SeanTAllen: not a great description of Pony, IMO, but it's nice to get mentioned :)
<TwoNotes>
I have put all the UDP/JSON logic in a single package that all program share, so at least I have it compartmentalized
<SeanTAllen>
Solving that different binary issue means possible different type definitions which is non trivial
<TwoNotes>
Erlang got arround that by specifying a portable 'wire format' for all value types.
<TwoNotes>
The cost of converting formats is quite small compared to the comm link overhead
<jemc>
erlang also has a very limited set of value types - where Pony has gobs and gobs of user defined types
<darach>
SeanTAllen. Sweet!
MC_Hamming has joined #ponylang
SilverKey has quit [Quit: Halted.]
<TwoNotes>
At least by using UDP+JSON, plugins to my architecture do not HAVE to be in Pony. Could be in Python or anything else convenient
<Applejack_>
jemc: ok, will have a look at that link
<jemc>
TwoNotes: also, I have worked off-and-on with a Pony implementation of CapnProto, which might be ideal if you wanted to keep it open to other possible language intercommunication
<Applejack_>
TwoNotes: Is what u did some kind of proto-(distributed Pony) ?
<jemc>
TwoNotes: I did a basic proof of concept so far, but the library's not *really ready to use yet, unfortuntately - https://github.com/jemc/pony-capnp
<TwoNotes>
Applejack_ it is not general purpose if that is what you mean. It is driven by the needs of my particular application (voice controlled home automation)
<SeanTAllen>
We started our app using OSC then swapped in pony serialization
<SeanTAllen>
And have proxy actors to allow network communication which is the next distributed pony thing to swap out
<TwoNotes>
Using UDP allows me to use simple addressing with strings rather than tracking IP addresses. "Hello module FOO whereever you are out there, here is a message ofr you."
<Applejack_>
Ok... but the principle u used can be used again to build some other needed specialized distributed Pony I guess.
<TwoNotes>
The concepts could be used probably.
<TwoNotes>
I am in the middle of refactoring a lot of it. I used to use TCP links, which was making for a lot of overhead.
<TwoNotes>
I added a JSON generator to make the messages easier to create. It takes an array of tuples ("tag",value) and turns that into JSON
<Applejack_>
TwoNotes: Could u post some high level super simple one paragraph description of what u did, the goal you had, i.e. expand a bit on ""Hello module FOO whereever you are
<TwoNotes>
On the receiving end, it shows up as a Map[String,String].
<TwoNotes>
I have not updated all the documentation in the wiki yet to reflect the refactored protocol
<Applejack_>
Ok, but is there a high level overview, avoiding the nitty gritty ? I should probably just loo.
<Applejack_>
look
<TwoNotes>
The key for the name-based addressing is the concept "The medium is the multiplexor". All modules around the LAN receive all messages, but the interface i the seclink package filters out the interesting stuff.
<Applejack_>
So to look for someone you send a message to everyone and the interested person only reacts?
<TwoNotes>
But that is the old TCP protocol which was too complicated.
<TwoNotes>
Yes. But there can be more than one 'interested' module.
<TwoNotes>
For example, if you send a 'speak' message, all the speech synthesizers in all rooms of the house can process it. (Unless you add a 'room' modifier to restrict it)
<TwoNotes>
And during the speaking, all music players get muited at the same time, so you can hear the speech
<Applejack_>
So you need different binaries because each room has a box with such a dedicated binary?
<TwoNotes>
Yes. Although i npractice most will probably be RaspberryPi3's
<TwoNotes>
My development machine is x86_64
<Applejack_>
If these were exactly the same box, could it be the same binary or would it still require different ones because of the devices plugged in?
<TwoNotes>
Each machine can specialize in a particular room in the house, and provide services appropriate to that location.
<TwoNotes>
For example, one module controls lights over the X10 protocol. It requires the hardware X10 interface be plugged in.
<TwoNotes>
The speech modules require audio in and out
<Applejack_>
But couldn't a single binary kind of "if device then do stuff end" ?
<TwoNotes>
If you had one machine that could do all of that, you could run al modules on it. But they would still communicate over UDP
gsteed has quit [Quit: Leaving]
<TwoNotes>
Well, it is all written as separate programs so that is CAN be distributed. And you can add modules without recompiling everything
<TwoNotes>
The speech and grammar files that drive the recognizer are all external data files and can be updated
<TwoNotes>
The state of the art in speech recognition pretty much requires you be close to the microphone. You can't shout from one room to the other and expect it to understand you
<TwoNotes>
Thus multiple speech module instances
<Applejack_>
Each module is such an independent binary ?
<TwoNotes>
This has the benefit fo providing location information. "Turn on the lights here." means turn on the lights in the room where you hear me say it.
<TwoNotes>
yes
<TwoNotes>
On top of all this, and speaks and understands multiple languages. (Currently English and Japanese)
<TwoNotes>
But the drivig factor for the comm protocol was flexibility of deployment on multiple boxes
<Applejack_>
This makes me realize I probably misunderstood distributed heterogeneous Pony: I thought it would mean declaring some nodes, then launch the actors and see their behaviors executed on whatever node the scheduler decided. How could that make possible one microphone in one room to detect a voice and switch on the light in that same room?
<TwoNotes>
Right, schdulig the work to wherever a CPU is available is *not* what I want
<TwoNotes>
Speech processing has to happen where there are microphones and speakers. Lamp control needs the X10 interface. The game control I am workin go has to ru on the machine where the game is running
<Applejack_>
So you effectively need different binaries.
<TwoNotes>
The music player needs a speaker. Which may or may not also be where speech processin ghappens
<TwoNotes>
You *could* compile it all as one massive binary that does everything, but that also means you have to redploy ALL of them if you make a change to ONE of them
<Applejack_>
I see. And cpu bound behaviors ?
<TwoNotes>
I wanted to make it easy for people to add new modules without restricting them to coding in Pony
<TwoNotes>
So far there are no CPU bound behaviors
<TwoNotes>
The music player is just 'mplayer' running in a subprocess. So whatever that takes
<TwoNotes>
The speech recognizer is 'julius' also in a subprocess. It is idle most of the time.
<Applejack_>
I need to think about this and come back with more focused questions, thanks for sharing.
Applejack_ has quit [Ping timeout: 250 seconds]
rurban1 has joined #ponylang
aturley has joined #ponylang
unbalancedparen has quit [Quit: WeeChat 1.5]
runehog_ has quit [Remote host closed the connection]
aturley has quit [Ping timeout: 264 seconds]
TwoNotes has left #ponylang [#ponylang]
MC_Hamming has quit [Remote host closed the connection]
Matthias247 has quit [Read error: Connection reset by peer]