IRC channel logs


back to list of logs

<amz3>gnunet_bot: botsnak
<zacts>I still think a guile based simple emacs clone may be a project of mine
<zacts>like using the zile lib or something
<nalaginrut>morning guilers~
<artyom-poptsov>Hello nalaginrut
<amz3>héllo :)
<yvm>configure script of emacs-wip tells that my system has no libjpeg. I can see libjpeg in /usr/lib/x86_64-linux-gnu/ and gcc -ljpeg can see it.
<yvm>The script if very messy.
<yvm>I can see libjpeg check only for mingw32 in it.
<yvm>Getting hands dirty with another package management system just to install brand new emacs? No, thanks.
<yvm>Or maybe yes.
<yvm>Definitely yes. Thanks for suggestion.
<paroneayea>hi civodul! :)
<paroneayea>ACTION about to start implementing error handling in 8sync
<paroneayea>syncbot: hello!
<syncbot>Oh hi paroneayea!
<paroneayea>so the main thing is what to do if you've called code asynchronously
<paroneayea>and it throws an exception, and your procedure is waiting on it
<paroneayea>I'm thinking it might be nice to re-propagate the error to the original process that did the (%8sync (%run (foo))) invocation
<paroneayea>capture unhandled errors in the wrapper procedure/future calling (foo), and re-raise them in the original caller
<paroneayea>I wonder how sane this is
<civodul>futures in Guile do that: they keep the exception around, and re-throw it when you 'touch' the future
<paroneayea>civodul: oh interesting... is there code I should look at?
<paroneayea>civodul: I thought of packaging up the original stack too
<paroneayea>to keep it introspectable
<civodul>(ice-9 futures)
<paroneayea>but that would mean needing to provide some sort of wrapper around the original args
<civodul>yeah, not sure if it's applicable to 8sync
<civodul>for futures you only get the result when you call 'touch'
<civodul>so that's the obvious place for throwing
<paroneayea>civodul: right
<paroneayea>civodul: so the challenge is: if I throw with the original args, I can't "pass in" the stack
<paroneayea>to those args
<paroneayea>I could do something like
<paroneayea>(throw original-exception-tag (wrap-original-args args) (wrap-stack original-stack))
***NeverDie_ is now known as NeverDie
<paroneayea>but then if someone's handler expects different arguments it's possibly bad to have that
<paroneayea>I could (throw '%8sync-remote-error (wrap-original-args args) (wrap-stack original-stack))
<paroneayea>I could (throw '%8sync-remote-error original-exception-tag (wrap-original-args args) (wrap-stack original-stack))
<paroneayea>but that makes other things complex I guess, because I can't (catch) the explicit tag
<paroneayea>and I'm not sure I can re-raise an error without killing the backtrace
<civodul>yeah, you're losing the backtrace
<civodul>maybe that's the price to pay
<paroneayea>so you pretty much have to handle all remote errors at once, or not at all
<paroneayea>if you don't want to keep destroying the backtrace
<paroneayea>syncbot: greet davexunit
<syncbot>Thanks for dropping in davexunit!
<paroneayea>civodul: I'll try a couple things, thanks for thinking about it with me :)
<paroneayea>civodul: one potentially evil option btw
<paroneayea>could append "%8sync-" to the original exception tag...
<paroneayea>how evil is that? :)
<civodul>evil :-)
<paroneayea>civodul: aw ;)
<zacts>civodul: what first got you interested in (scheme)?
<zacts>(just curious)
<zacts>and what was your first programming language?
<civodul>i think Pascal was my first language, a looooong time ago
<civodul>or maybe Basic before that
<civodul>later i discovered that thing call GNU, and looked at Guile
<civodul>the thing i liked the most at the time was GOOPS
<civodul>it took me a while before i started to hate it ;-)
<zacts>oh nice
<zacts>civodul: so I take it you prefer functional programming over OOP?
<civodul>well OOP as in CLOS or Smalltalk has its appeal, because it's consistent and radical
<civodul>but yeah, FP is more appealing to me
<zacts>does guile have a CLOS equivalent? or is GOOPS it??
<civodul>yes, GOOPS
<zacts>so when might you presently prefer OOP over functional programming, for which type of applications?
<zacts>I know that chicken scheme has coops, from what I understand really closely matches what CLOS offers
<zacts>also, I wonder about a more central location for guile libraries
<zacts>perhaps guix will be this place
<zacts>I'm thinking like:
<zacts>and a: guile-install <module-here>
<zacts>or something like that
<civodul>there's Guix and there's the guildhall
<zacts>that would rock perhaps...
<zacts>neat, but it would be nice to make guildhall or something like that more official
<zacts>but I guess that's what guix will be
<civodul>we should mention it at
<paroneayea>hey civodul, what do you think of this:
<paroneayea>as an error handling of remote things syntax mockup
<civodul>i think i would need to look more closely to say something that makes sense :-)
<civodul>i can do it, but later
<paroneayea>civodul: no worries, thanks for your input :)
***holomorp1 is now known as holomorph
<amz3>do macro works inside eval?
<amz3>the answer is...
<amz3>well this opens the door for building a database server
<amz3>I still need to find a glitch in guile
<amz3>maybe... I have one
<amz3>let's explain my sillyness
<amz3>I though that (catch) was only catching errors when the procedure that was erroring was the thunk that was called
<amz3>obviously catch works like you would expect
<roshi_>getting ready to head out for the holidays, and will have limited internet access - if I wanted to learn guile, what resources can I download and take with me?
<amz3>the manual
<amz3>I made a quick tutorial, it ought be nice to get started
<roshi_>awesome, thanks. link?
<amz3>I will push the md files in a minute
<roshi_>ah, kk
<amz3>wait I will copy the markdown somewhere
<amz3>I should add this feature to the blog anyway
<roshi_>awesome, thanks
<roshi_>that'll prove helpful
<amz3>it's really the basic though, it doesn't build complex stuff
<amz3>it's hands on syntax and basic building blocks
<roshi_>ACTION was looking for a Learn C the Hard way to brush up on my C (I'm a python guy, generally), but can't find a pdf or tarball for it
<roshi_>amz3: that's great, as I don't know any scheme dialects and the syntax will be the large portion I need to learn
<roshi_>the rest I can figure out by poking at the std libs and whatnot
<roshi_>ACTION should check if the guile source is in this system package...
<amz3>for instance, it doesn't explain let vs let*
<amz3>where's let* is in general more useful
<amz3>I'm misleading it explains let*
<roshi_>good to know
<amz3>roshi_: for instance, it doesn't explain quote, unquote, quasiquote a those useful in the broader context of scheme, but when you come from another language it's not really the feature your are looking for
<amz3>I advise that you have a look at them in the manual afterward
<roshi_>makes sense
<amz3>roshi_: I think little schemer is another good ressource
<roshi_>little schemer?
<amz3>also try SICP
<amz3>it's a book
<roshi_>downloaded sicp already
<roshi_>i'll exhaust my free resources first then :)
<OrangeShark>here is another book on Scheme
<amz3>IIRC ArneBab has a book on scheme for python people
<amz3>I don't recall the url
<roshi_>oh, nice to meet you all btw
<amz3>you also buy a hard copy if you like it
<amz3>dead paper :))
<amz3>s/dead paper/dead tree/
<roshi_>might have to do that
<roshi_>ACTION loves having actual books
<roshi_>but I rarely travel with them
<roshi_>which might be why I don't like traveling, fewer books
<ArneBab>sneek: later tell roshi_ you can get the book from
<sneek>Got it.
<ArneBab>sneek: botsnack