IRC channel logs

2016-12-21.log

back to list of logs

<janneke>Mes parses simple main using Nyacc!
<janneke>ACTION -> zZzzz
<civodul>Guile makes reproducible gensyms!
<janneke>Whoa civodul!
<civodul>good news today ;-)
<civodul>ACTION -> zzz
<civodul>night!
<janneke>night!
***logicmoo is now known as dmiles
***karswell` is now known as karswell
***micro` is now known as Guest46857
<janneke>Morning Guilers!
<janneke>ACTION is manually bisecting to find psyntax.scm patch allowed PEG to compile
<janneke>now down to 7 commits
<janneke>
<janneke>could it be in `5f16116 really boot primitive-eval from scheme.'? ... i hope not
<janneke>seems that PEG ERROR: definition in expression context in subform `sym' of `(unsyntax syn)' was not fixed in any psyntax.scm patch...20 more commits to bisect :-(
<janneke>
<janneke>yeah, after Nyacc, now also PEG loads in Guile-1.8
<paroneayea>that feeling when you have several procedures that nearly do the same thing, but they're all off in subtle ways so it's hard to find a nice abstraciton around them
<davexunit>I know that feel
<paroneayea>I'm having to write out all the components
<paroneayea>maybe that'll help me sort it through.
<davexunit>wingo: friendly ping regarding the patch I sent to guile-devel a week ago. :)
<wingo>davexunit: tx :) /me fetches mail
<wingo>ACTION implementing work-stealing for fibers
<davexunit>wingo: do you have any thoughts about "job control" wrt fibers?
<davexunit>like being able to kill a thread
<wingo>not really. i thought about it and couldn't come to many suitable answers
<davexunit>my examples always revolve around games: there's an enemy AI that is represented as a fiber. when the enemy dies its fiber should be terminated.
<wingo>it sounds like a good idea tho
<wingo>you can of course build that in user-space
<davexunit>sure, that would be acceptable
<wingo>i.e. make each "wait" operation also include a wait on a cvar (though we need to implement cvars)
<paroneayea>the actor route is to self-destruct the actor :)
<paroneayea>can't get more messages if it's dead!
<davexunit>I have my own experiment where every fiber knows its parent and children and whether it is running or not.
<davexunit>to terminate is to flip the 'running?' bit
<davexunit>and in turn do the same to the children
<paroneayea>seems like a reasonable approach
<wingo>basically you wrap each operation in such a way that the operation adds an additional event source, and that event will fire when a corresponding cvar gets a value
<wingo>a cvar is an event source which fires when it has a value, and fires to all waiting operations
<davexunit>all continuations are wrapped such that they check if the fiber has been killed first
<wingo>so it's like a running? bit but one which wakes up anything waiting on it as well
<davexunit>interesting
<wingo>like whenever you would want to kill the fiber, you set this cvar
<wingo>and wrap any wait operation in something that also waits on that cvar
<davexunit>so every fiber would have such a cvar
<wingo>only works for cml events tho
<wingo>well every killable thing would need a cvar
<davexunit>yeah
<wingo>one killable thing might have many fibers
<wingo>racket uses custodians for this, also...
<davexunit>right re: many fibers
<wingo>and has some interesting extensions in findler's "kill-safe abstractions" paper
<davexunit>which is why I copied from UNIX and kept track of the fiber tree
<davexunit>so killing a parent will recursively kill the children
<wingo>yeah. i think a supervision tree or whatever is something that properly exists on top of fibers rather than in the core
<davexunit>hmm, interesting.
<davexunit>it seems core to me.
<davexunit>I mean I've never considered the idea of it not being a core thing
<davexunit>it feels low-level to me, but your approach sounds sane.
<paroneayea>huh
<paroneayea>I did manage to get my abstractions sorted out :)
<paroneayea>took a couple hours, but yay
<paroneayea>o/ terpri
<paroneayea>beep boop
<davexunit>wingo: what effect would prompt contification have on fibers?
<davexunit>I've done enough with floating point VM ops that I can look at the disassembly and have a pretty good idea if things are good/bad wrt unboxing
<davexunit>but when I look at the disassembly of a procedure that uses prompts, I can't yet tell what is unoptimal.
<davexunit>I was able to implement the float comparsion stuff because I knew the bytecode I wanted to see.
<amz3>héllo #guile!
<amz3>since I am giving a talk at FOSDEM
<amz3>in a month or so
<amz3>I'd like to know what people want to hear about wiredtiger
<amz3>Reference API? benchmark? internal? usecases? autotools? minikanren?
<amz3>ahem microkanren
<amz3>given IIRC it's 20minutes
<paroneayea>amz3: I think showing off cool use cases, and talking about your design decisions, and minikanren
<paroneayea>would all be great
<wingo>davexunit: nothing afaiu, fiber conts are not escape-only
<wingo>davexunit: sent review
<wingo>regarding prompt trees/parentage, it might be a core thing, but until now it doesn't seem needed on a basic level. i dunno tho :)
<wingo>ACTION heads out for a walk
<amz3>paroneayea: ok
<amz3>paroneayea: tx
<quigonjinn>hello guilers. is there any library for guile, with which "live" data plotting can be done?
<amz3>quigonjinn: maybe you can generate data for rendering with gnuplot in a thread and retrieve the image from there to display in gtk window
<amz3>s/with/for
<quigonjinn>amz3: to display the image like so, it should be piped to gnuplot, right?
<davexunit>wingo: thank you!
<amz3>quigonjinn: maybe you should ask the mailling list if nobody answers here, because I know people using guile with a lot of numbers
<amz3>quigonjinn: yes, if gnuplot can take arguments in stdin
<quigonjinn>amz3: ok, thanks. i'll try with gnuplot first and see how it goes
<amz3>quigonjinn: as you wish
<davexunit>wingo: thanks for pointing out the issues. I will be dropping the patch.
<amz3>quigonjinn: here is the mailling list archive https://lists.gnu.org/mailman/listinfo/guile-user
<amz3>quigonjinn: I have a bash script that does plot memory over time using gnuplot
<amz3>you plot memory use using this https://github.com/kiwix/sotoki/blob/wiredtiger/memory-log.sh
<amz3>and then run gnuplot with this config file
<amz3> https://github.com/kiwix/sotoki/blob/wiredtiger/memory-plot.gnuplot
<amz3>config file or script whatever it is
<amz3>I don't know much else about gnuplot anyway
<amz3>but it works well to plot memory
<amz3>it only plots vsz, which probably means virtual memory
<amz3>I should update it to plot all memory someday
<quigonjinn>amz3: that's cool. it should be trivial to adapt this to take input from guile
<amz3>yw
<amz3>ACTION looks for tantalum on IRC?
<didi>Is Guile's GC generational? Compacting?
<amz3>didi here is guile's garbage collector website http://www.hboehm.info/gc/
<amz3>I don't understand the question otherwise
<didi>amz3: Thank you.
<amz3>tantalum has awesome projects
<amz3>too bad, they are not on IRC.
<amz3>I will make a post about my persistent object class system I've written
<paroneayea> http://sph.mn/content/94b huh
<paroneayea>sexp -> sql
<paroneayea>I wonder how stable / safe this is.
<paroneayea>doing sql string concatenation right is hard, but if done right, I could really use this
<[df]>what I really want is for someone to replace sql with a sexp-based language, ideally based on third manifesto d
<[df]>but that's hard and stuff
<paroneayea>[df]: I hear you
<paroneayea>it would be great to have postgresql but to be able to just shoot sexps to it
<paroneayea>all the string munging is a nightmare
<amz3>in wiredtiger there is no string munging but the API is different from SQL
<amz3>you can execute a subset of SQL in wiredtiger directly using the API, but for doing SQL it would require a SQL parser first
<[df]>postgresql would definitely be where I'd start, it's architected nicely enough to support a totally new query language
<amz3>the order of the arguments is all weird in SQL
<amz3>you mean it would be possible to create an abstraction on top of postgresql SQL to map scheme statments?
<amz3>for instance: select COUNT(a) FROM urls; returns a single row, it's counter intuitive from scheme perpective where you'd have to write a fold
<[df]>no, I mean it would be possible to implement a new query language in pg that had nothing to do with sql
<amz3>[df]: definitly
<amz3>that would be an interesting project
<paroneayea>[df]: if you or someone you know is ever bold enough to take on such a thing, let me know ;)
<amz3>[df]: what is third manifesto?
<[df]>paroneayea: it's on my very long todo list...
<[df]>amz3: https://en.wikipedia.org/wiki/The_Third_Manifesto
<amz3>[df]: tx!
<amz3>it seems easy to do
<amz3>at least if http://www.quicksort.co.uk/DeeDoc.html follows correctly the Manifesto