IRC channel logs


back to list of logs

<paroneayea>more flexbox stuff
<daviid>rotty1: fixed it thanks to ebassy on #clutter. folks, now guile-clutter compiles without a single warning and no errors of course, good!
<septopus>hey someone was in here with an alternative to jekyll that was in guile. Anyone know the name of it? Would love to look at how it works.
<xvx>septopus check the log?
<septopus>I just tried, I can't seem to find the search.
<OrangeShark>septopus: do you mean the static site generator haunt?
<septopus>OrangeShark: Yep, that was it! Thanks!
<septopus>is there an easy way to search the logs?
<davexunit>septopus: let me know what you think of haunt. it's early days still.
<davexunit>I need to convert my pelican blog to it and work out more of the annoying parts
<umano>^ I'm stuck trying to get the body of an HTTP response as a string...
<umano>I'm a noob by the way :)
<davexunit>umano: looks like the response is empty
<davexunit>what's the status code?
<umano>Well, actually is 200 and if I run (http-get (string->uri text-url)), the full text of the body shows in the REPL
<davexunit>what's the value of (response-body-port server-response) ?
<umano>it's a port
<davexunit>how about (peek-char (response-body-port server-response)) ?
<umano>ACTION goes to check
<umano>it's taking some time to evaluate that like...
<davexunit>it must be blocking
<davexunit>I see the same behavior
<umano>Yeah, my REPL is still thinking...
<umano>What could this be? I don't understand.
<davexunit>I think it's because it's a keep-alive connection
<umano>It finished now and I get the same error.
<davexunit>and you could write another http request
<davexunit>I guess that's not the case.
<davexunit>I'm not sure what's going on here, actually.
<davexunit>I've certainly used http-get before with success
<umano>I tried without keep-alive and the port of the body is closed and I cannot read it.
<umano>Well, I'll have to follow the course in Python then :P
<umano>But I'd really like to know what going on.
<davexunit>I'm not sure what's up here. I have used http-get in the past...
<umano>But thanks for your help davexunit :)
<nalaginrut>morning guilers~
***michel_mno_afk is now known as michel_mno
<adhoc>is there a guile vector math library ?
<adhoc>is this a good fit? "SRFI-4 - Homogeneous numeric vector datatypes"
<lloda`>srfi-4 is not a math library
<adhoc>lloda`: ok
<lloda`>sorry that wasn't much help, there's no numpy-for-guile so to speak, just scattered libraries and bindings. The main utility of SRFI-4 is to interface with external libraries, if you do array math in that way you should definitely make use of it.
<lloda`>some of my half-done bindings are here
<adhoc>lloda`: so SRFI-4 is really about interfacing to external libraries ?
<adhoc>is that the focus of all the SRFI ?
<lloda`>it's a container library
<lloda`>it defines vectors where the elements are memory compatible with the standard machine types
<lloda`>so I'd say that's the focus, yes
<lloda`>or the whole point, really
<adhoc>i've done some searching for vector math libraries, but suspect that my terminology is off.
<lloda`>what kind of functions do you need? 3d vector algebra, or general linear algebra, or statistics, or...
<dsmith-work>Wednesday Greetings, Guilers
***michel_mno is now known as michel_mno_afk
<paroneayea>hi mark_weaver
<paroneayea>I followed your recommendation and benchmarked hash tables vs alists
<paroneayea>mark_weaver: anyway you were right! alists did consistently outperform hash tables for mappings of 5-20 elements
<paroneayea>mark_weaver: not by 50 times or so as you had guessed, but by a little bit :)
<paroneayea>(but most of the compumentation maybe was caught up in the loop itself, so)
<paroneayea>anwyay alists did outperform, as this relates to the json scheme structure discussion
<paroneayea>davexunit: ^^^
<mark_weaver>paroneayea: well, I guessed 20 times, and that was between vhashes (not normal hash tables) and alists.
<paroneayea>mark_weaver: ah right
<paroneayea>it was vhashes! :)
<paroneayea>ACTION runs the test again with that ;)
<paroneayea>mark_weaver: looks to be about 8 times faster :)
<mark_weaver>ah, okay. I guess I exaggerated :)
<mark_weaver>and surely it depends on what types the keys are
<paroneayea>one or two character strings in this case of testing
<mark_weaver>the terrible thing about hash tables is that they cause you to write code in a very imperative way.
<mark_weaver>where's alists and vhashes both support functional programming
<paroneayea>ACTION nods
<mark_weaver>but the problem with alists and vhashes is that they don't nicely support updating existing entries. really we need purely functional HAMTs as found in clojure, and I believe that there's an implementation of them in ijp's pfd library
<mark_weaver>(pfds = purely functional data structures)
<davexunit>wingo also wrote an implementation
<davexunit>that closely models clojure's approach
<davexunit>using their idea of "transients"
<mark_weaver>ah, good. wingo's one is probably much more performant.
<davexunit>I want them in core guile
<paroneayea>I think the risk with wingo's was he read the clojure code as he wrote it and it was mostly a port of that
<mark_weaver>wingo tends to optimize things very well, whereas ijp focuses more on correctness and portability.
<paroneayea>and the clojure stuff is under the eclipse public license
<paroneayea>gpl-incompatible, for one thing
<paroneayea>there may be some concern there.
<davexunit>I think we're fine there
<mark_weaver>in the worst case, we could reimplement it
<mark_weaver>as long as the API is not tainted somehow.
<mark_weaver>but the clojure folks are not exactly Oracle corporation.
<mark_weaver>but if you're worried, you can use pfds
<paroneayea>mark_weaver: davexunit: and I agree, I'd like this kinda stuff in guile core!
<stis>hej guilers!
<paroneayea>hi stis