IRC channel 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

<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.

<amz3>guix?

<amz3>#guix?

<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.

<zacts>lo

<paroneayea>hello

<civodul>hey!

<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>er

<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>yeah

<zacts>neat

<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>ok

<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>?

<zacts>I'm thinking like: http://wiki.call-cc.org/chicken-projects/egg-index-4.html

<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...

<civodul>see https://github.com/ijp/guildhall

<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 http://www.gnu.org/software/guile/libraries/

<zacts>cool

<paroneayea>hey civodul, what do you think of this: http://paste.lisp.org/+3G80

<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

<paroneayea>hm

<amz3>do macro works inside eval?

<amz3>the answer is... https://friendpaste.com/5O6o1cqWqJZDIKrH1YyEpz

<amz3>yes!

<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>nop

<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

<amz3> https://friendpaste.com/5O6o1cqWqJZDIKrH1YY2cg

<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 https://www.gnu.org/software/guile/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> http://hypermove.net/learn-scheme-guile-basics.html

<amz3> http://hypermove.net/learn-scheme-guile-forward.html

<amz3>wait I will copy the markdown somewhere

<amz3>I should add this feature to the blog anyway

<amz3>roshi_: https://gist.github.com/amirouche/f686a7192429d3cd0502

<roshi_>awesome, thanks

<amz3>yw!

<roshi_>that'll prove helpful

<amz3>hopefully

<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

<amz3>exactly

<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_>free?

<amz3>no

<roshi_>i'll exhaust my free resources first then :)

<OrangeShark>here is another book on Scheme http://scheme.com/tspl4/

<roshi_>awesome