IRC channel logs


back to list of logs

<atw>ArneBab: for contrast, I searched I think it might help to consider the audience -- how "beginner" should a tutorial/intro to Guile be? WDYT?
<ArneBab>I think having a tutorial similar to the racket one would be great.
<ArneBab>but we lack polished tools shipped with guile which would make that simple
<ArneBab>and I only have so much time :-)
<ArneBab>I recently wrote a tutorial for using Guile via wisp which is more geared towards beginners:
<ArneBab>atw: I actually wrote that one into my paper-notebook and then typed it down …
<ArneBab>I don’t think it’s perfect, and I’m sure people can do better, but it’s the first I could for example show my son to allow him to hack stuff
<ArneBab>though turtle graphics win by far against it
<ArneBab>(I showed him how to do turtle graphics in Python and he liked it a lot)
<atw>ArneBab: re code on paper: I've done the same to avoid the tyrrany of having to write code that actually evaluates ☺
<ArneBab>in my case I write code which typically evaluates without changes :-) — I love having code which looks like pseudo-code but actually runs.
<atw>there's also the possibility of recommending books, but that does incur the cost of finding and getting the book
<ArneBab>yes, and I think doing that loses at least 90% of people
<ArneBab>especially the ones who can already program and just wont to try whether they might like Guile
<atw>Would Guile be their first Scheme?
<ArneBab>that’s … actually a good question
<ArneBab>clojure users might come to Guile for system-scripting. For them it would be the first Scheme, but not the first Lisp.
<atw>Funny you should mention, my day-job is clojure. Guix brought me in ☺
<ArneBab>I have a co-worker who uses clojure and is interested in Scheme :-)
<ArneBab>what Guix shows nicely: Every great tool needs killer applications.
<ArneBab>that’s why people come
<ArneBab>not because of the great tool itself, though the tool enables them to create more great applications which might allow them to pull in more people
<atw>I asked the first-Scheme question because I think that if Guile is someone's second Scheme, then the interesting thing for them to learn might be what's more unique to Guile. Someone coming from another Lisp might wonder how much metaprogramming happens in practice, and someone with an ML-like background might just be looking for SRFI-1
<ArneBab>that sounds true
<ArneBab>could you write up what you’d have liked to read about Guile when you first came here?
<ArneBab>I actually came from Python and moved towards Guile thanks to The Adventures of a Pythonista in Schemeland:
<atw>hmm, pretty much all of the above! I'm not sure I should be taken as a representative example, but here are some questions I've had: is there a library/builtin function for powerset? What's a record? Is SRFI-9 the only "object" system? How do I map/reduce/etc.? What is call/cc?
<atw>ArneBab: I found recently, which seems really good!
<ArneBab>records where also something it took me a long time to find
<ArneBab>sadly all rights reserved :-(
<ArneBab>but this looks pretty nice:
<atw>Ah, you're right, I didn't even think about thatt
<ArneBab>otherwise we could have turned it into "Teach yourself Guile Scheme in fixnum days"
<ArneBab>though distribution and usage is allowed: — but I don’t see anything about changing
<atw>Could people looking to learn be directed to it?
<ArneBab>looks like the book is free: "Here are some Scheme- and Common-Lisp-related code and documentation. Everything presented here is freely distributable and freely usable, and comes with no warranty of any kind. FS (as in GPL, LGPL) bundlers who require a standard license may use the LGPL to bundle any of these items. Others should find my COPYING file adequate."
<reepca-laptop>what's a nifty way to get the name of the file currently being evaluated?
<reepca-laptop>ah, lucky me, my next guess was "current-filename", and it turns out that's it.
<ArneBab>sneek: later tell atw: bbad = be back another day
<sneek>Will do.
<wingo>ACTION merges in gnu lightning
<janneke>wingo: exciting! (a bit ugly, but i understand there's no better choice right now)
<wingo>janneke: jit will enable more c code to move to scheme
<wingo>so, better for portability i think (e.g. when targetting graal or rpython or wasm)
<janneke>wingo: i didn't catch that implication/dependency, that's so great!
<wingo>janneke: there will still be the interpreter of course and the jit can be disabled
<wingo>the reason some things haven't moved to scheme is partly because no one has done it yet and in some cases because scheme is slower
<wingo>but with jit the latter reason will go away
<wingo>if you have an interpreter-only build then things won't be as fast as they could be, but the amount of C code will be less
<wingo>after things move from c to scheme i mean
<wingo>speed enables the move
<janneke>ah, right!
<ArneBab>wingo: yay!
<janneke>hmm, thinking about the speed issue, i remember how moving equal2? from scheme to C (in Mes) had a significant performance improvement
<amz3>so guile on chez is not something out of the mind
<amz3>janneke: what is the channel of boostrapable effort?
<amz3>got it it's #bootstrappable
<amz3>davexunit: what do you think about immediate mode gui?