IRC channel logs


back to list of logs

<rlb>nb. removing HACKING from the upcoming Debian packages since it also appears to be non-DFSG: "...and that any new or changed statements about the activities of the Free Software Foundation are approved by the Foundation"
<sneek>Welcome back rlb, you have 2 messages.
<sneek>rlb, daviid says: 'make' worked fine but 'make check' remains in 'Running sandbox.test' for ever when commenting thse three gc-benchmark/larceny file we were talking about yesterday, so that approach won't work 'just like that', it might still work but would need a bit more then just commenting these in the
<sneek>rlb, daviid says: I recommend you send an email to guile-devel and posibly copy it to guix-devel as well, because it is 'holiday time' i europe and I'm not sure (all) maintainers will see and respond to our irc conversation and attempt to solve it asap for you to introduce 2.2 in debian unstable... better email I think
<rlb>daviid: thanks, and I should probably summarize all this to the liast once I'm finished, but I'm not blocked. I'm just removing the files from the source package. For now I just removed gc-benchmarks/ altogether, assuming we don't actually need it, though I haven't tested the build after that yet.
<dsmith-work>rlb! Greetings
<rlb>dsmith-work: hey!
<mbuf>Is it possible to use Guile on Chez Scheme compiler?
***gour_ is now known as gour
<gour>hello, i'd like to learn some elisp in order to be able to tweak Emacs better, so wonder if Elisp-knowledge is somewhat transferable to Guile for the need of customizing Gnucash's reports?
<gour>i was (am) also interested to learn some Racket which might be closer, but not sure whether my free time will allow me.
<gour>i also wonder if Guile is going to be able to replace Emacs' Elisp some day?
<random-nick>well, a big part of learning elisp is learning emacs' APIs
<random-nick>but guile does not implement emacs APIs since guile is not a text editor
<dsmith-work>Happy Friday, Guilers!!
<random-nick>someone did try to make a version of emacs which uses guile's implementation of elisp
<random-nick>but the development of that stalled
<dsmith-work>gour: I learned elisp before guile. I was suprised (and pleased) at some of the basic differences.
<dsmith-work>gour: The list stuff is mostly the same, but with differences in important details.
<rekado>gour: some idioms differ a lot
<dsmith-work>Scheme is properly tail recursive, while elisp is not, so you have a lot more imperative looping contructs in elisp.
<dsmith-work>You can take the car or cdr of an empty list in elisp, which is an error in scheme.
<gour>random-nick: i'm aware of emacs' part of elisp...too bad that prpject is stalled
<gour>dsmith-work: thanks
<dsmith-work>gour: So while they are really very similar, the details are often different.
<gour>ok, will consider that while exploring both
<gour>what are some of the significant changes to be brought in 3.0 release?
<manumanumanu>gour: there has been talk of generating native code, which would be cool
<gour>ACTION nods
<manumanumanu>2.2 is already much faster than 2.0, and native code would speed it up even further
<manumanumanu>It is great fun look at the output of ,opt and try to learn how to write fast code
<manumanumanu>Speaking of ,opt: anyone knows any good resources on reading the disassembly?
<dsmith-work>gour: Also possibly combining .go files into a single executable (like a linker).
<gour>dsmith-work: something ala racket?
<stis>manumanumanu: ,x -fkn-name- ?
<dsmith-work>gour: No idea.
<dsmith-work>gour: Wingo posted an email at one time with a list of things.
<stis>manumanumanu: I used module/system/vm/assembler.scm a lot
<dsmith-work>stis: Do you have a link to that hacking task list?
<stis>no, sorry. Should have bookmarked it.
<mwette>good source of info:
<amz3>héllo all :)
<amz3>OrangeShark: hey, it looks like guile-git is live in guix
<stis>hi amz3!
<amz3>hey stis, how do you do?
<amz3>I look at racket to see whether I can implement my framework in it
<amz3>the good thing is that they have a super nice manual, I mean the look'n'feel aka. css is great
<amz3>there search engine works great
<amz3>it doesn't support posix threads and racketscript doesn't plan to support call/cc
<amz3>POSIX thread thing is can be replaced in racket with Future and Places (which seems like something like a processus (or like python's 'multiprocessing'))
<amz3>my understanding is that a Place in racket does spawn another kernel processus and communication can ONLY happen over serialized datastructure
<manumanumanu>amz3: racket has threads
<manumanumanu>oh. posix threads :(
<amz3>AFAIU racket threads are equivalent to fibers
<amz3>coming from Python and Guile, understanding racket way of doing was kind of diffuct
<amz3>When I started GNU Guile, it was clear to me the mapping to do between Guile's modules vs Python's packages
<amz3>in racket, it's weird
<amz3>It's like its own world!
<amz3>another planet :)
<amz3>that said, I discovered something that might interest people here, the creator of minikanren is going to speak @
<amz3>as usual the conf website is... beautiful, my taste anyway
<amz3>also, I re-implemented my forward.scm frontend framework in javascript and things are much more complicated which makes me think that BiwaScheme (and scheme) has a great learning curve, it's easier to jump into forward.scm than the equivalent in JavaScript
<amz3>much easier
<amz3>much much easier
<amz3>this lead me to have deeper look at GraphQL, basically GraphQL has nothing to do with graph in particular or SQL outside the fact that's "yet another query language"
<amz3>I hope you see where I am going
<amz3>GraphQL is DSL that aims at replacing REST endpoints
<amz3>it will be the default API of github AFAIK
<amz3>knowing that scheme is great at DSL, I am wondering how this could be translated to GNU Guile
<manumanumanu>So. My for loops are ready to be battle tested. If anyone wants to, please try my loops:
<manumanumanu>docs here:
<amz3>«Compared to the output of srfi-42 you notice one thing: no safety checks. It is up to the programmer to check the arguments.» great!
<amz3>manumanumanu: what do you use for the generating the documentation?
<manumanumanu>amz3: org-mode, of coures :D
<amz3>that's neat!
<manumanumanu>I would never leave the comfort of emacs for something other than irc
<amz3>code highlighting is very nice
<manumanumanu>and web banking, but that is never comfortable
<manumanumanu>amz3: you need to get the org from melpa. the one included does not support it
<manumanumanu>newest version, export to html. voila
<manumanumanu>Now, people, how do you write your unit-tests?
<amz3>manumanumanu: regarding your project, do you recommend using it whenever I can or something else? it's there a specific usecase where it makes sens? sorry if it's a silly question
<manumanumanu>amz3: well, i am pretty satisfied with it. The looping constructs have zero or very close to zero runtime costs. I'd rather use racket-style for loops than hand-rolling my loops
<manumanumanu>they are mighty comfortable
<amz3>I use srfi-64 and a simple macro
<amz3>if remove the 'with-directoy' form, it's a 10 line macro for doing tests
<manumanumanu>amz3: and when you start having to hand roll something similar to the for*-loops, then for* is not only cleaner, but less error prone
<amz3>I defined 'test-begin' and 'test-end' also to keep track of whether a suite is successful or not. TBH srfi-64 does the job
<amz3>manumanumanu: ah
<amz3>that's a good argument
<manumanumanu>The only real downsides are: 1. you depend on a third party library. 2. compilation times increase.
<amz3>(for* ([a '(1 2)) b '(x y)]) ...) does the product of of A and B, right?
<amz3>srfi-64 is builtin guile afaik
<amz3>iirc I mean
<manumanumanu>amz3: correctly formatted, that code would loop 1 : x y; 2: x y.
<manumanumanu>amz3: my macros produce slightly faster code than srfi-42, and takes less time to compile
<amz3>I don't understand the example with 'x', 'y'
<manumanumanu>amz3: look in the docs under 3. Conventions
<amz3>the caveat I see, with 'for' is that it makes scheme less minimal somewhat, that said it allows to avoid bugs
<manumanumanu>amz3: on the contrary! this is created by building on a strong set of well-defined primitives. Very schemey :D
<amz3>tbh, I don't plan to dive further in your project, right now, if someone chime in my project and tell me a one of the named-let I use can be replaced with a for-loop I will gladly make the change
<manumanumanu>amz3: probably most of your named lets can be replaced without any performance regressions other than at compile time
<manumanumanu>that is my sales pitch :)
<manumanumanu>I am pretty happy with how the loops turned out
<manumanumanu>and it should be pretty portable :)
<daviid>manumanumanu: mozilla public license v2? is this compatible with GPL v3+?
<solene>hello, I'm trying to use sxpath but I'm really lost. I want to get the content/value/text of a td which has a certain class. but all I can get in return of sxpath is the class that match the class I need. like (sxpath '()// td @ class (equal? "theclass")) returns ("theclass" "theclass") if there are 2 td with this class
<amz3>solene: for instance: ((sxpath '(// td *text*)) xml) returns ("win!" "lose") with the following sxml ((*TOP* (body (table (tr (td (@ (class "foo")) "win!") (td (@ (class "no")) "lose"))) (div "b")))
<mwette>solene: try (sxpath '(// (td @ class (equal? "theclass"))))
<amz3>I am trying to understand how sxpath does query over another xml axis
<amz3>solene: try: ((sxpath '(// (td ((@ (class (equal? "foo"))))) *text*)) xml)
<amz3>solene: with the same example you gave me
<amz3>I've been trying to solve this problem for quite some time
<solene>amz3: that doesn't work for me
<solene>mwette: this returns ("foo")
<amz3>here is a permalink
<solene>amz3: thx that works, I think I did an error while copy/pasting
<amz3>solene: tx for asking! I was wondering how to do this for months...!
<amz3>I never got into trying again
<amz3>now i can improve sxpath doc
<solene>amz3: I'm struggling with guile doc, I'm new to scheme and guile so I assume this is me. I'm reading the documentation by little everyday, everything is well documented but it's hard to understand how to use it when you discover it
<amz3>solene: I never read the doc, I mostly look up things in the procedure index for things and ask question when I need
<amz3>solene: like I said, before now, I did not know how to do the query you asked for