IRC channel logs


back to list of logs

<aleogen>Hey there.. To the emacs users, is it possible to write an emacs application in guile-scheme?
<davexunit>aleogen: no, but it's possible to write a guile application using emacs. :)
<aleogen>davexunit: true, though perhaps favorable to others.
<aleogen>Thanks :D
<civodul>hey there! :-)
<civodul>wingo: the other thing we need to get 2.2 in Guix is the patch to skip incompatible .go files (like what janneke submitted)
<civodul>both for 2.0 and 2.2
<wingo>heya :)
<wingo>hoo yeah that's a confusing one
<wingo>civodul: wdyt about changing .go for .so ?
<wingo>since the files are ELF now, though not like ABI-following ELF
<wingo>that would "fix" the problem, though it would introduce problem with people's build systems i guess
<civodul>wingo: yeah, i think it would make people angry because all the build systems would break
<civodul>and it would be much harder to have a build system that works for both 2.0 and 2.2
<civodul>so i'd prefer to keep .go
<wingo>i think this punts the problem down the line a bit, surely when we do native compilation we should make .so's
<wingo>but i'm fine with punting it down the line :)
<civodul>heh :-)
<civodul>the extension doesn't matter though
<civodul>it's not entirely clear to me that we "should" use .so when we do native compilation
<civodul>it's more of a psychological effect we're talking about, no?
<wingo>civodul: i dunno :) to me a shared object that has native code and whose container is ELF should probably be named .so, just feels right; but that could be a bogus instinct :)
<wingo>and .go does conflict with the go language, to an extent
<wingo>if people see a .so they more or less know to expect some kind of binary artifact that's included in other binary programs
<civodul>wingo: yeah, i think you're right
<civodul>but let's punt until 2.2, IMO :-)
<wingo>sure, fine :)
<civodul>so that means we should merge a patch akin to what janneke submitted
<wingo>the one other thing i want before a 2.1.3 is some idea about how to do async i/o -- i think i'll have something soon. i had to research windows a bit, blah -- though it turns out their async i/o facilities are better than ours (!)
<wingo>i have some free time this upcoming weekend
<wingo>wdyt about aiming for a 2.1.3 on saturday?
<civodul>sure, why not
<civodul>i won't be available this saturday, but i don't think i'm really needed at this point? :-)
<wingo>yeah i think i'm good to get it out, i just wanted to suggest a time-frame :)
<wingo>did you see btw -- guile 2.1.2 is looking great!
<civodul>it should have this .go compatibility thing, IMO
<civodul>ACTION looks
<wingo>the 2.1.2 perf is strikingly better than 2.0
<ecraven>wingo: it sure is ;)
<wingo>ecraven: thank you! and thank you for the benchmarking, it is fun :)
<ecraven>:) mostly not my work, all the benchmarking code already existed
<ecraven>I just tried to add more Schemes :)
<civodul>wingo: often close to Chicken, which i think is a good sign!
<wingo>civodul: i think when we get native compilation we will be able to grab the occasional first prize :)
<civodul>sometimes better than Stalin already ;-)
<civodul>Bigloo remains annoyingly good
<wingo>you're just annoyed at bigloo ;)
<civodul>there's some truth in it ;-)
<civodul>but yeah, thanks ecraven!
<civodul>and thanks wingo for making 2.2 routinely twice as fast as 2.0!
<ecraven>if you know of any options to make things run faster for any scheme, please tell me :) mejja yesterday gave me options to make stalin a lot faster than with only "-On"
<hckiang>Hi, I am Haochi Kiang from Hong Kong and Macau, and I am interested in joining you and start contributing to Guile. I have been programming for 7-9 years, did a CS degree, and is a free software fan. May I know what are some very first things I can help, and where should I get started from? :-)
<nalaginrut>hckiang: Guile manual is very good to read for new comer
<davexunit>hckiang: the best way to find a way to get involved is to first try to write something in Guile that solves a real problem that you care about.
<taylan>hi hckiang :) there's a bug tracker at in case you'd like to squash bugs
<dsmith-work>{appropriate time} Greetings, Guilers
<civodul>ADTs in Ruby:
<civodul>Someone will have to write crazy macros to do that in Scheme
<davexunit>civodul: are you saying that this is something easier implemented in Ruby than Scheme?
<davexunit>(having written a lot of Ruby and Scheme, it's hard to believe, ;)
<civodul>davexunit: no, i don't think so, but i find the result quite convincing
<civodul>i'm guessing it would be useful and fun to implement it in Scheme
<davexunit>oh okay, then I've misread
<davexunit>"crazy macros" through me off
<kwrooijen>Is there a nicer way to write (lambda (x) (cons 1 x)) ? Feels like I'm missing something simple
<davexunit>kwrooijen: could you explain why the above is not nice?
<davexunit>seems nice to me.
<kwrooijen>davexunit: Well I thought maybe there's just an easier way to write it. For exmaple Clojure has the lambda shorthand #(cons 1 %)
<kwrooijen>Thought maybe was a shorter way to write anon procs
<kwrooijen>there was*
<taylan>you can use SRFI 26: (cut cons 1 <>)
<davexunit>cut is cool, but it's definitely not as clear as the original example
<kwrooijen>Doesn't really feel like that's a very standard way of doing these types of things though
<taylan>SRFI 26 is somewhat widespread AFAIK. I'm not a fan myself though.
<davexunit>kwrooijen: SRFIs are pretty standard ways of doing all sorts of things.
<davexunit>ACTION anticipates the coming "standard Scheme" storm and steps away
<kwrooijen>I was thinking more of what the community likes to use, based on your reaction. But I'm still new here so :)
<davexunit>many people use SRFI-26. it comes with Guile.
<davexunit>I use it sometimes, even.
<davexunit>when I want brevity.
<kwrooijen>taylan: Thanks for the link
<kwrooijen>All right, thanks for the help :)
<ArneBab>aleogen: however you might want to look at guile emacs: (packed in guix)
<civodul>davexunit: "crazy" in "crazy macros" is to be understood as "fun & clever" ;-)
<davexunit>ACTION once again mulls over a scheme(ish) -> GLSL compiler
<davexunit>does anyone know of a good explanation of hygiene for the non-Scheme programmer?
<davexunit>trying to critique some Ruby code that does some very unhygienic dynamic class lookup by transforming a symbol into a class name.
<davexunit>would look like to point them at a resource explaining the logic behind hygiene.
***holomorph is now known as anyone
***anyone is now known as holomorph