IRC channel logs

2016-09-14.log

back to list of logs

<davexunit>ACTION wonders how possible it is to make a guile instance that doesn't have file system access
<davexunit>or rather doesn't expose file system access to the user
<wleslie_>I think wingo wrote a blog post about guile's suitability as an ocap lang
***wleslie_ is now known as wleslie
<wleslie> http://wingolog.org/archives/2011/03/19/bart-and-lisa-hacker-edition
<wleslie>not sure if he ever /built/ that safe evaluator
<davexunit>yeah I don't think it ever happened
<davexunit>the reason I'm thinking about this stuff is because I saw a thing called the "PICO-8". it's a virtual video game console made with lua.
<davexunit>and I thought, how about making something similar but with Guile?
<wleslie>yes, it's quite beautiful
<davexunit>but to really sell the "virtual" part I need Guile to virtualize things like the file system
<davexunit>to provide the illusion of it being a separate machine in an alternate universe where lisp machines rule the world
***captain is now known as Guest57529
<wingo>rekado: new fibers stuff, fyi: https://github.com/wingo/fibers/wiki/Manual
<wingo>ACTION distchecks a guile 2.1.4
<wingo>yarrrr, again, a whole friggin distcheck only to fail at the install phase because of ld impurities :?
<wingo>export GUIX_LD_PLEASE_PLEASE_PLEASE
<wingo>garr, this time a spurious test failure; when memory limited via rlimit, a failure to spawn the finalization thread
<catonano>what does thhis message error exactly means ? ERROR: Throw to key `match-error' with args `("match" "no matching pattern" #<hash-table 309a660 26/31>)'.
<wingo>catonano: it means that in some (match foo clause ...), no clause matched
<wingo>the object that "foo" evaluated to wasn't handled by any clause
<wingo>ACTION released 2.1.4
<SHODAN>*cheer*
<catonano>wingo: thanks. Also, the <hash-table ... > thing means that I attempted to match against a list containing a hash-table
***captain is now known as Guest33597
<rekado>wingo: woo, nice!
<rekado>I recently learned that early versions of R had an S-expression syntax.
<rekado>Currently, I’m in the middle of a stats course, and I wonder if there are any projects to bring saner syntax to R. Or if it would be possible to implement R on top of Guile…
<rekado>Or to have a compiler from Scheme to R.
<rekado>just something to allow me to avoid R’s syntax.
<wingo>i usually do my stats in scheme, which means that usually i do very lame and limited stats :)
<wingo>r and ggplot2 are kindof amazing
<wingo>also rmarkdown. very nice stuff
<wingo>at work we use hydra to generate rmarkdown runs to benchmark things
<wingo>ACTION looks for link...
<wingo>if i could use guix/cuirass and guile/guile-charting that would be very nice
<wingo>well, snabb hydra seems down for now :)
***tokage is now known as Guest19480
***Guest19480 is now known as tokage
<csed>hoi
<csed>SO UH. I'm compiling 2.1.4
<wleslie>and then this parser walks in and orders a drink
<wleslie>sorry. what's it doing?
<wingo>csed: yeah what's it doing?
<csed>Oh, sorry. I had to get water because it is WARM. Just curious how long it uh, usually takes. Also ha ha I forgot -j in the make.
<csed>On an X250 wif i7-5600U.
<csed>Oh, wait. It hasn't hung. It is outputting things.
<csed>Christ, ThinkPads are horridly warm.
<wingo>csed: what does build-aux/config.guess print out
<wingo>you can run that while your build is still going
<wingo>i wonder if for some reason your system isn't picking up the pre-built .go files
<wingo>it's worth checking that now :)
<csed>wingo: http://paste.debian.net/821341/ womp
<wingo>csed: i mean, run that command
<wingo>i had a problem recently on a debian machine that it was not hitting the prebuilt/ hot paths
<wingo>but i'm not sure if my fix for that made it into the tarball
<wingo>csed: if you run the command it should print somethign like x86_64-unknown-linux-gnu or something
<csed>wingo: Oh was that a command? Thought it was a log file. Yeah, that's what it says.
<wingo>it says precisely that?
<wingo>because on the debian system i ran it on, it said x86_64-pc-linux-gnu
<csed>wingo: x86_64-unknown-linux-gnu
<wingo>ok
<csed>corpy pasted
<wingo>ok well then you're on the hot path i think :) just takes a few minutes then :)
<wingo>a build normally completes in about 5 minutes with -jN
<wingo>on a machine from the last 3 years or so
<csed>wingo: Yyyyeah. I forgot -j. Pretty sure that's it.
<csed>Actually, I can just make clean and try it with -j.
<wleslie>forgot about j
<wingo>um, you're definitely going to want to limit to -jN where N is core count
<csed>wleslie: Poor J. No one thinks about his feelings.
<wingo>you prolly know that :)
<csed>wingo: yurr
<csed>wingo: I did not always know that. Things occurred. I think I tried compiling some Lisp code with -j and it just, borked. StumpWM probably.
<wingo>yeah so make is ridiculous, by default if it can do 100 things in parallel it will try
<wingo>even if you only have 4 cores
<csed>Lel.
<wingo>so you always want to limit to core count.
<wleslie>I discovered by accident that I'm running stumpwm under sbcl again, and it's actually fast now
<wleslie>including startup time
<csed>wingo: Yeah, just set it to 4. Timing it as well out of curiosity.
<rekado>I have a GUILE_LOAD_PATH which also includes a 2.0 directory. When using 2.1.3 I get a lot of errors:
<rekado>;;; WARNING: loading compiled file /run/current-system/profile/lib/guile/2.0/ccache/srfi/srfi-26.go failed:
<rekado>;;; ERROR: In procedure load-thunk-from-memory: No such file or directory
<davexunit>the load path shouldn't include 2.0 stuff
<rekado>Can I tell Guile to ignore incompatible go files?
<wingo>this is something of a faq, we should write it up :)
<rekado>Also, the 2.2 paths are all in front.
<wingo>check your GUILE_LOAD_COMPILED_PATH
<wingo>but for that one it will be found in the system GUILE_SYSTEM_COMPILED_PATH or something as it's part of guile; hmm
<rekado>yeah, that one’s the same.
<rekado>first are the 2.2 paths, then the 2.0 stufff
<wingo>we should have the ability to silence the warnings. but they do indicate an issue that makes it slower to start.
<wingo>i think it's mainly guix people that run into this. if you install guile-2.0 and guile-2.2 to $prefix, no env vars end up set;
<wingo>and if you install to /opt/guile-2.0 etc and have an environment script that sets variables to select that guile, then you're usually in the 2.0 or 2.2 environment and not both
<wingo>but if you have to populate a ~/.guix-profile/... directory full of .go files for both 2.0 and 2.2, then you end up setting environment variables.
<wingo>anyway guile 2.1.4 is out now :)
<paroneayea>wingo: oh, new release!
<paroneayea>I should promote it...
<wingo>it's mostly bugfixes, though http://www.gnu.org/software/guile/docs/master/guile.html/Atomics.html#Atomics is kinda interesting
<davexunit>wingo: the fibers manual is really nice
<davexunit>lots of interesting background info
<wingo>tx :)
<wingo>glad you found it interesting
<davexunit>in particular the contrasts between pthreads, twisted, node, erlang, go, and concurrent ML
<paroneayea>I'm really looking forward to going through fibers
<paroneayea>I probably will while vacationing in london :)
<dsmith-work>Wednesday Greetings, Guilers
<dsmith-work>wingo: Yey!
***captain is now known as Guest59779
<paroneayea>release announced on social netwerks
<rekado>do you know of documentation for how to use autotools with Guile?
<davexunit>has anyone done any GC tuning for certain applications?
<csed>Hm. So: real 109m8.562s
<csed>With -j 4.
<wingo>csed: i think you missed the hot path then
<wingo>for some reason the prebuilt thing was not working for you
<csed>wingo: Huh. Any way to check if/when that happened?
<wingo>csed: run "meta/build-env env | grep GUILE_"
<wingo>and see what paths into prebuilt/ you find
<wingo>and see if those paths actually exist
<csed>wingo: Exists, yeah. But there's like, three MAkefiles there. Or rather Makefile/.in/.am.
<csed>Also, there's only one path that contains prebuilt. In GUILE_LOAD_COMPILED_PATH.
<csed>Also. I did a git clone.
<wingo>ah
<wingo>if you build from a git checkout it takes forever, yes :)
<wingo>everything normal, then :)
<wingo>it's the tarballs that include the prebuilt/ bits
<csed>wingo: Great, good to know. Thanks for clearing it up.
<dsmith-work>real 10m54.271s
<dsmith-work>user 37m47.980s
<dsmith-work>with make -j4
<dsmith-work>on model name : Intel(R) Core(TM)2 Quad CPU Q8200 @ 2.33GHz
<dsmith-work>Not bad as all.
<dsmith-work>(compared to building from git master)
<paroneayea>whee, some emacs soci-el + pubstrate screenshots https://identi.ca/cwebber/note/YfSVMLzyTKeWOVZXuj-QKQ
<paroneayea>nice to have things coming together.
<davexunit>paroneayea: looks great!
<paroneayea>thanks davexunit :)
<davexunit>wingo: so, the fibers manual talks mainly about async behavior with regards to I/O, but is it possible to add in an arbitrary scheduler for other purposes?
<davexunit>I would like to be able to make a fiber yield to a scheduler that will resume after some period of time has passed.
<wingo>davexunit: there is support for sleep()
<davexunit>okay, so bad example. :)
<wingo>:)
<davexunit>how about when one has a different notion of what time is, like in a video game where time is how many iterations the game loop has done?
<davexunit>or any other situation that is domain-specific
<paroneayea>scheduler layered on scheduler? ;)
<davexunit>(let loop () (display "hey/n") (wait 60) (loop))
<wingo>yeah i dunno in general. i think guile should support people that want to build schedulers like that
<davexunit>where (wait 60) means "wait for the game loop to tick 60 times)
<davexunit>"*
<wingo>but i don't know if something like fibers or 8sync should explicitly include support for that, or how that would happen
<davexunit>yeah, perhaps not.
<wingo>the scheduler is here: https://github.com/wingo/fibers/blob/master/fibers/internal.scm
<davexunit>and that's OK, I think. I was just curious.
<davexunit>I have had a coroutine implementation with a simplistic scheduler for several years now, but was wondering if I should drop it and use fibers instead.
<davexunit>but it seems there is still a reason to keep it around
<wingo>is your scheduler deterministic?
<davexunit>yes
<wingo>introducing port i/o to that would make it nondeterministic
<davexunit>okay, makes sense.
<davexunit>in my case I'm not actually concerned with port i/o at all.
<wingo>you might still want channels i guess
<davexunit>I mean, I could be concerned with that at one point, so maybe fibers could be used *in addition to* this other system
<davexunit>wingo: yes, channels are very appealing to me right now
<wingo> https://github.com/wingo/fibers/blob/master/fibers/channels.scm
<davexunit>because I want to have game objects (enemies, projectiles, etc.) each have their own "thread" where they perform their logic
<davexunit>but I want the objects to be able to know what the current state of the world is like and to inform the world of what their state is
<wingo>maybe you don't need atomicity then if you don't use multiple kernel threads
<wingo>and you are focusing on determinism it seems
<davexunit>whilst continuing to use pure functions and persistent data to represent the game objects themselves
<davexunit>yes determinism is very important
<wingo>channels can be more efficient if you don't have to use compare-and-swap, spurious wakeups, etc
<davexunit>I don't need atomicity currently, since I use a single kernel thread.
<wingo>yeah
<davexunit>but the idea of a channel is still relevant
<wingo>sounds like you should keep your own thing but steal ideas as appropriate :)
<davexunit>yeah, that sounds about right.
<davexunit>I need to read more about how channels work
<davexunit>but here's a quick example describing my use-case: a goblin walks in the direction of the player, then waits a few frames, then repeats.
<davexunit>I'd like a (goblin, player)->goblin function to describe this, and a "fiber" that runs in a loop that is able to retrieve the current player object each time the fiber wakes up
<davexunit>does it sound like channels to you?
<wingo>maybe :) i am new at this too :)
<davexunit>:)
<davexunit>okay well thanks for the info thus far
<davexunit>things are a bit less foggy now
<davexunit>but still quite foggy :)
***captain is now known as Guest37922
<amz3`>so channels are like mailbox of erlang?
<amz3`>hmm...
<davexunit>guile on HN front page https://news.ycombinator.com/item?id=12498049
<amz3`><_o/
<amz3`>\\o/
<DeeEff[m]>congrats on Guile 2.1.4
<DeeEff[m]>Still makes me wonder why 2.0.11 is the recommended version and not one of the 2.1 series
<holomorph>DeeEff[m]: guile's odd point releases aren't considered stable
<davexunit>DeeEff[m]: 2.0.12 is the latest stable
<davexunit>2.2 will come along soon enough
<DeeEff[m]>2.0.12 is the latest stable? But the website / download says get 2.0.11...
<DeeEff[m]>holomorph: makes more sense I guess. I just haven't noticed much breakage in my (admittedly limited) use of 2.1
<davexunit>DeeEff[m]: someone needs to update the website
<amz3`>let's compile guile 2.1.4 from git
<amz3`>and try to debug this gnutls thing
<amz3`>civodul: do you still think that tls-wrap should make use of ‘make-custom-binary-input/output-port’
<amz3`>civodul: I'm looking at paroneayea patch from last year, here is the context thread
<amz3`> https://lists.gnu.org/archive/html/guile-devel/2015-09/msg00042.html
<amz3`>seem like there is a follow up thread in guix bug tracker https://debbugs.gnu.org/cgi/bugreport.cgi?bug=20145
<amz3`>I will look at the two commits mentioned in this bug report
<paroneayea><amz3`> <_o/
<paroneayea>that looks delightfully like arm-flexing
<amz3`>paroneayea: exactly
<amz3`>this really looks like something i can not handle
<amz3`>I will just wait to someone skilled enough implements https...
<webshinra>hey people, is their a possibility to use dimensional analysis for physics calculations?
<webshinra>(with guile/scheme)
<webshinra>(to ensure coherency of every operations)