IRC channel logs

<please_help>Looks like my framework actually works at last. Just have to figure out how to optimize out the gigantic matrix constructions and it can be actually usable.

<ArneBab>py2guile 0.8: nicer title page and a comment on compile time vs. run time with Python decorators: http://draketo.de/proj/py2guile/py2guile-v08.pdf

<ArneBab>I like how this turns out!

<davexunit>ArneBab: LOL at the cover image

<ArneBab>:)

<davexunit>this is a huge document!

<davexunit>I had no idea you had written so much on the subjet

<davexunit>subject*

<ArneBab>I have a printed version on my desk - and I’m currently doing the last steps to order the second iteration from epubli :)

<ArneBab>this accompanied me for the past year

<ArneBab>I want to try selling this under GPL — essentially selling the ease of just getting the print/pdf/epub format instead of building it from source and the feeling that you’re supporting the author.

<davexunit>ArneBab: page 19: s/simpe/simple/

<ArneBab>fixed - thanks!

<davexunit>np

<davexunit>this is an entertaining read

<davexunit>nice code examples

<ArneBab>thanks :)

<davexunit>I still strongly disagree about the parens. I love 'em. :)

<ArneBab>:)

<ArneBab>(many people do - while many others shudder when they see them ← makes it hard to get a majority to use the language)

<davexunit>yeah(); but(function(they) { dontShudder(whenTheySee(this)); });

<ArneBab>^ they cannot: It’s Javascript or don’t reach the users. And obviously enough people shudder to make them build lots of languages which compile to Javascript

<davexunit>that's true, but the syntax isn't one of those reasons typically.

<davexunit>at least I don't think so. usually people don't like implicit type coercion and the odd behavior of == and how 'this' works.

<duud>ArneBab: I think the main problems of scheme are not the parens but: bad portability, lack of a central repository of high quality libraries, lack of standardized ffi to c.

<davexunit>I don't think of a Scheme as a single language, but rather as a family of closely related languages, so the portability aspect doesn't bother me.

<davexunit>I write Guile Scheme, not Scheme.

<ArneBab>davexunit: I tried to always use “Guile Scheme” in py2guile to make a point of that :)

<davexunit>of course, portable code is good, but only a limited amount of code could ever really be portable without ballooning the Scheme standard.

<ArneBab>duud: the portability is also the aspect which will hit me hardest.

<ArneBab>but with portability I mean: Deploy easily to OSX and Windows.

<duud>davexunit: never searched for a library for guile?

<davexunit>I didn't disagree with that point. I think Guile needs more libraries.

<davexunit>I've hacked on several of them.

<duud>davexunit: portability would help a lot

<ArneBab>(in short: deploy easily so that my real life friends can use it)

<ArneBab>duud: do you see a problem of Guile Scheme which isn’t in the book?

<davexunit>people complain about this a lot, but then no one seems willing to hack on guildhall.

<duud>ArneBab: have to look in to it first :)

<ArneBab>:)

<ArneBab>davexunit: did I already say that I hope to be able to adopt guildhall?

<davexunit>ArneBab: didn't know that. that would be great.

<ArneBab>(had to finish py2guile first - and need to do some essential improvements for pyFreenet)

<davexunit>I just use Guix, but of course guildhall is simpler and easier to port to a new platform.

<davexunit>but once installed, Guix is unmatched for being able to quickly build guile environments.

<ArneBab>definitely yes

<davexunit>but guildhall has a solid niche to fill and I'd like to see it adopted by Guile hackers.

<ArneBab>yepp

<ArneBab>I just ordered my test print of py2guile :)

<ArneBab>I hope it will be the final one

<davexunit>cool!

<ArneBab>(and need to get to bed)

<ArneBab>thanks for your feedback!

<ArneBab>cu and Happy Hacking!

<davexunit>bye!

<duud>davexunit: concerning the ballooning of scheme standard. Big scheme implementations like racket chicken guile and so on are already ballooned but they do the ballooning in different ways. So no implementation benefits from the work of other. A really hope r7rs-large will improve the situation.

<duud>Portability is about efficiency, the situation now is a waste of resources.

<davexunit>duud: I like the small size of the Scheme standard, but again I don't view Scheme as a single language, but a family of different languages with shared roots.

<mark_weaver>duud: I would look at R6RS, SRFIs, and the available R6RS libraries.

<mark_weaver>R7RS-large doesn't yet exist, and frankly I have low expectations for it based on what I've seen so far.

<mark_weaver>R7RS was created by a part of the community that rejected R6RS. R6RS and R7RS are incompatible with each other, and basically they are two forks. IMO, R6RS was more competently designed.

<duud>mark_weaver: available R6RS libraries = libraries coded against the R6RS standard? If so where do I find them?

<mark_weaver>sneek: guildhall?

<sneek>I could be wrong, but guildhall is https://github.com/ijp/guildhall/wiki/Getting-Started

<mark_weaver>duud: if you install this ^^ it provides an easy way to install R6RS libraries packaged for convenient use by Guile.

<mark_weaver>thanks to ijp, a denizen of this channel, for gathering those packages

<duud>mark_weaver: thx, never new about guildhall. Its not mentioned in guiles manual also I didn't see it on guiles homepage. Is somewhat hidden.

<mark_weaver>we've been meaning to set up an official guildhall repo at guildhall.gnu.org, but haven't done it yet.

<mark_weaver>that's the one that would be documented in the manual.

<mark_weaver>but we would take ijp's repo as a starting point

<duud>ok, thx

<davexunit>whoa, didn't realize that guile-xcb was implemented using a reader that transforms the xcb xml specification into a guile object file.

<davexunit>that's pretty awesome.

<mark_weaver>agreed, I hope we can do more bindings that way in the future.

<davexunit>I wish SDL 2 had a specification document that I could do that to.

<davexunit>I want to move on from guile-sdl to a pure FFI wrapper of SDL 2, but it's such tedious work.

<mark_weaver>I suppose that gnome-introspection would allow us to do it for gnome libraries in the future, although that would be a very different approach to our current guile-gnome-platform bindings.

<davexunit>the sdl folks just laughed when I asked for a specification file and told me to parse the header files. :/

<davexunit>oh well.

<mark_weaver>I hope that machine-readable API specifications will become more common, but of course it's a cultural thing and probably most communities think it's silly.

<davexunit>I should have prefaced the question by stating the obvious that I *know* the headers are machine readable, but they're not exactly what I had in mind.

<davexunit>I don't really want to resort to using libclang

<davexunit>to get some sort of AST that I can use.

<cluck>davexunit: well, in their defense the demo scene isn't renowned for their documentation (or for that matter code sharing) and sceners are often indie game coders ;)

<davexunit>I'd like to think the SDL community was a bit better than that, given the many languages that have SDL bindings.

<mark_weaver>I think that guile could really benefit from a proper C language parser.

<cluck>but yeah, sdl's api is "old directx" nuts

<davexunit>but I guess everyone just did them by hand or used clang.

<davexunit>cluck: SDL 2 is much improved, from what I can see.

<davexunit>this brings me back to wanting parser combinators, and writing a GLL parser combinator library being beyond my skill level at the moment.

<cluck>the core devs did a lot of good work but... backwards compatibility (or illusion thereof) is a tough mistress

<mark_weaver>but there'a important information that's not simply not deducable from the C code in the header files, notably things like: who has responsibility for freeing referenced objects.

<mark_weaver>gobject introspection provides that information

<cluck>anyways, it's better now but still lots to do before it can be called nice and clean

<davexunit>mark_weaver: ah, yes. good point.

<cluck>(here's hopping the pyra helps push a better api a little as its forerunners did)

<davexunit>cluck: I use relatively few things from SDL. open window and GL context, get keyboard/mouse/joystick input.

<davexunit>that's about it for the core library.

<cluck>davexunit: i'm not judging

<cluck>davexunit: most of the cruft is there for very good reasons

<civodul>Hello Guilers!

<civodul>wingo: could you comment on http://lists.gnu.org/archive/html/guile-devel/2015-05/msg00005.html ?

<paroneayea>hello civodul

*paroneayea coding django for a client, which is much nicer than coding php for said client was, but looks forward to writing more web applications in guile :)

<davexunit>civodul: is this the libnl you were talking about on guile-devel? http://www.infradead.org/~tgr/libnl/

<davexunit>oh, it's already packaged for guix. must be the right one!

<Tsutsukakushi>avaScript to use full functionality of this site.

<Tsutsukakushi>sowi, forgot i had that tmux bind

<mark_weaver>hmm, glibc-intermediate fails to build on mips in core-updates. I will investigate

<mark_weaver> http://hydra.gnu.org/build/491818/nixlog/1/tail-reload

<ijp>I've pushed the code to a temporary branch at https://gitlab.com/ijp/guile/commits/compile-to-js

<ijp>and I'm writing an update for guile-user at the moment

<paroneayea>ijp: \\o/ \\o/ \\o/

<paroneayea>ijp: oh it says "you need to sign in to continue"

<ijp>gah, I'll fix that in a second

<ijp>okay try now

<mark_weaver>ijp: any reason not to use another branch in the official guile repo for this?

<paroneayea>ijp: works \\o/

<paroneayea>ijp: building

<ijp>I wouldn't, you'll run into limitiations pretty quickly

<ijp>e.g. anything with rest arguments

<paroneayea>ah ok :)

<paroneayea>on another topic

<paroneayea>somehow guile-pg never made it onto my "database options for guile" list, because I didn't know about it http://www.nongnu.org/guile-pg/

<ijp>mark_weaver: I'd feel bad about force pushing all the rewrites I'm going to do on an official repo

<mark_weaver>ijp: it's long been an unwritten policy that branches starting with 'wip-' can be freely rewritten.

<ijp>this is just a courtesy for the people that keep asking for source

<mark_weaver>anyway, as you wish. just curious.

<mark_weaver>(I certainly have freely rewritten the r7rs-wip branch many times, and that doesn't even start with 'wip-' :)

<paroneayea>davexunit: http://www.nongnu.org/guile-pg/doc/Query-Construction.html#Query-Construction

<paroneayea>hm, maybe not what I thought

<paroneayea>or at least, I don't understand the examples

<ijp>I think I need to read that nanopass paper

<wingo>i don't like the nanopass languages much; to me they have too few names and rely too much on local reasoning. maybe i misremember though

<wingo>and is it possible with the nanopass stuff to have optional passes?

<wingo>istr it being that each pass translated between languages and so if you missed a pass you broke the chain

<wingo>but maybe this is all ignorance

<wingo>civodul: to me goops integration is a feature -- not one i use a whole lot but in the absence of struct vtables working transparently as classes (which they should in some day) to me it makes sense to have some sort of goops + foreign integration

<wingo>not sure what the overhead concern is tbh

<wingo>i'll reply to the mail too, tx for heads up

<ijp>I have rest args working

<wingo>woo :)

*wingo working on closure conversion of cps2

<wingo>i think we can get closure sharing working, which is pretty neat

<wingo>we did most of the "optimizing closures in o(0) time" things already, but that was the missing one

<ijp>neat

<wingo>ijp: will you have to write a js runtime in js?

<ijp>if it's in guile's C, I think I'll need to write it in js

<ijp>except for where that doesn't make sense

<wingo>makes sense

<wingo>would be nice if eventually that could be in scheme too, at least partially, to be able to have guile do the tree-shaking

<ijp>I was trying to compile srfi 1 earlier (still need optionals, and probably a few other things) and I noticed it used load-extension :/

<wingo>not that we do that in a cross-module way right now but it wouldn't be hard to do if we restricted guile's semantics

<wingo>ijp: boooo

<wingo>there is no good reason for srfi-1 to load things from c

<wingo>pretty sure all those functions would be faster in scheme

<wingo>anything that's passed a function as an argument will certainly be faster in scheme

<paroneayea>but I heard on the internet that when you want to do things fast you do them in C

<ijp>all of them are marked SCM_INTERNAL, so at least we aren't dealing with it begin leaked to users

<wingo>paroneayea: i thought that for the longest time :)

<ijp>paroneayea: no, you do them in javascript

<wingo>ijp: oh that's good.

<davexunit>it's hard to not think that.

<davexunit>you hear it so much.

<ijp>wingo: the only concern I have is that something may have been fixed in the C code but not in the reference implementation

<taylanub>SRFI are in dire need of test suites

<ijp>SRFTs

<davexunit>well now that there's SRFI-64...

<davexunit>I'm surprised to hear that there aren't test suites

<ijp>hmm, although, since the reference one uses rest arg parsing rather than optionals, I might be able to compile that

*ijp tries

<wingo>ijp: we don't have to use reference impls

<wingo>we can port our impls to scheme

<ijp>wingo: I know, but I'm not sure which would be easier to port

<wingo>yeah

<wingo>well, fix it if you want to, but don't let it be a blocker i guess, dunno

<wingo>i mean, think about it before you do it, if the amount of work is reasonably small then go ahead

<ijp>I'm not, I'll just move to some other module

<wingo>cool

<ijp>srfi 1 just seemed like an iconic one to do

<wingo>indeed

<ijp>~/src/guile $ meta/guild compile -o /tmp/srfi1.js --to=javascript ~/Downloads/srfi-1-reference.scm

<ijp> wrote `/tmp/srfi1.js'

<ijp>muahahahahahahahahahaha

<davexunit>woo!

<ijp>actually, you can't run it because I need to write a procedure to translate scheme identifiers into valid js identifiers, but in theory it would work

<wingo>:-)))

<stis>evening folks!

<wingo>heya stis :)

<sirgazil>Hello everyone :)

<sirgazil>I just wanted to share a logo I did for Guile:

<sirgazil> https://multimedialib.files.wordpress.com/2015/06/2015-06-06-guile-logo-proposal.png

<davexunit>sirgazil: awesome!

<ijp>sirgazil: are you youlysses?

<ijp>I think we discussed this before

<ijp>no pictures at that time

<sirgazil>ijp: youlysses? No.

<davexunit>can we work a lambda into that? ;)

<davexunit>and maybe make it sort of look like the grateful dead logo...

<paroneayea>sirgazil: ooooh

<paroneayea>sirgazil: I really like it

<davexunit>yeah, it's good.

<paroneayea>nice parentheses :D

<sirgazil>I tried something with lambda first, but I didn't like it. Also tried horns as parenthesis, but didn't like it either.

<ijp>davexunit: no lambdas please

<paroneayea>everyone has lambdas

<davexunit>I'm kidding.

<paroneayea>I say that as the person who made the mockup of the current Hy logo http://hy.readthedocs.org/en/latest/ :)

*sirgazil searches grateful dead

<ijp>go on archive.org then, loads of it

<davexunit>sirgazil: I was joking about creating racket's logo http://www.cs.uni.edu/~wallingf/teaching/cs3540/images/plt-lambda.jpg

<paroneayea>ahhhhhhh :)

<davexunit>which is a lambda + grateful dead colors

<davexunit> http://www.eecs.northwestern.edu/~robby/logos/steal-your-face-plt.jpg

<ijp>sirgazil: I'm not as sure of the retracted one, but I like the expanded one

<paroneayea>yeah the expanded one is super slick

<paroneayea>I think the retracted is still good

<paroneayea>but in general using the expanded is great

<ijp>I'll need to look out my logs, I'm sure youlysses and I discussed logo ideas on here

<paroneayea>sirgazil: I think guile giving a bit of breathing room from necessarily a gnu head is a-ok

<ijp>My idea was that the G should be two parens

<paroneayea>there are enough gnu imagery variations, which isn't bad... the guixsd version you did is a great version of that

<paroneayea>but not all gnu needs a gnu :)

<davexunit>"this is a gnu if mc escher drew it!"

<paroneayea>my 2 cents

<paroneayea>davexunit: hahaha

<davexunit>"this is a gnu if my 2 year old daughter drew it!"

<sirgazil>ijp: the retracted version is for use in places where there's no much space (favicons, for example).

<davexunit>I should take this time to plug my new children's book "too many gnus"

<paroneayea>davexunit: not going to point out which, but https://www.gnu.org/graphics/graphics.html could probably stand to be reduced a bit ;)

<davexunit>hehe

<ijp> https://en.wikipedia.org/wiki/Curl-up could be turned into a gnu pretty simply I think

<ijp>re: escher gnu

<davexunit>:)

<paroneayea>ijp: oh fun I hadn't seen that one.

<ijp>he did a few like that

<sirgazil>paroneayea: agree about the GNU head :)

<paroneayea>ijp: have you ever seen the creature on the original ITS emacs manual?

<civodul>sirgazil: nice!

<civodul>though i confess i'm happy with the current gnuish logo

<civodul>i find the "goatee gnu" pretty friendly :-)

<ijp>e.g. they are in https://en.wikipedia.org/wiki/House_of_Stairs

<paroneayea> https://www.gnu.org/software/emacs/its-cover.png

<paroneayea>some day I'm going to model that critter in blender

<paroneayea>I love that image

<davexunit>jar jar?

<ijp>as I understand it, the were based on the idea were that there are no machines with legs and no animals with wheels

<ijp>paroneayea: I have seen it

*sirgazil bookmarks M. C. Escher page

<paroneayea> http://uploads5.wikiart.org/images/m-c-escher/house-of-stairs.jpg hirez

<ijp>I keep a book of all of eschers work beside my desk upstairs

<paroneayea>sirgazil: I love the stuff you're doing to make guile/guix look nicer :)

<ijp>the only artsy thing on a shelf of maths and programming

<ijp>well, except for all the origami

<sirgazil>paroneayea: glad to hear it's appreciated :)

*mark_weaver also has a strange fondness for the current guile logo.

<paroneayea>the current guile logo is cute in a sense, but I also think it looks a bit dated and not as professional as it could

<paroneayea>I like the cute gnu

<paroneayea>but I think some rebranding could help Guile

<paroneayea>(similar things have been said about mediagoblin's branding, full ACK ;))

<sirgazil>civodul: speaking of friendliness. Is Guile targeted at experienced programmers only? I would like to see Guile used to introduce people to programming but I don't know if that would be one of the project goals.

<civodul>sirgazil: i think it could/should be a goal

<civodul>programming should be for everyone

<civodul>freedom only works if people can actually make changes and be as autonomous as possible

*civodul -> zZz

<civodul>ttyl!

<paroneayea>sirgazil: there was a conversation in here a while ago where we discussed goal to make guile more accessible to a general audience

<paroneayea>I promised to email the list with our conclusions, and failed

<paroneayea>:(

<paroneayea>but some of them were:

<paroneayea> - tutorial aiming at newcomers

<paroneayea> - new site design to make guile look more modern/attractive

<paroneayea> - better theme for the docs

<paroneayea>new logo could be a step towards #2 :)

<paroneayea>it's not a site design itself but maybe a step towards thinking of what it could be?

<sirgazil>Yes, my intention was to propose a logo first, and a website design later.

<paroneayea>sirgazil: cooool :)

<ajnirp>paroneayea: i like http://learnxinyminutes.com/ for when i want to get a quick overview of a language

<ajnirp>would be nice to have a guile section there

<paroneayea>ajnirp: I'll take a look at it! Though I'd love to have something on the guile site itself, or in the guile docs

<paroneayea>when I started the recommendations on learning guile were "read Little Schemer and peruse the reference manual and then start on SICP" :)

<paroneayea>which, all good recommendations

<ajnirp>true, that'd be better. the format itself is the important thing, all the tutorials try to keep it short and businesslike

<paroneayea>but not an easy way to get started

<paroneayea>definitely leads to a cutoff of many potential users

<ajnirp>agreed. i suppose i had it easy since it was taught in my uni. there's definitely a need for "crash-course"-style tutorials

<sirgazil>Yeah. I don't have formal training in programming and when I started browsing Guile's website for getting started, I felt as if I was told "Go learn Scheme somewhere else and then come back here." :)

<sirgazil>So I'd like to start learning programming with Guile. It would be great.

<paroneayea>sirgazil: tossed you a small donation for your awesome work :)

<paroneayea>please keep it up!

<paroneayea>you're doing great

<sirgazil>paroneayea: You're very kind, thank you :)

<davexunit>yeah, we should have some way of telling people "start *here*, with Guile"

<ijp>(char<=? #\\a c #\\z)

<ijp>While compiling expression: ERROR: Wrong number of arguments to #<procedure 7f54204eb078 at language/cps/types.scm:1114:0 (typeset t-433270 t-433271)>

<ijp>have I done something wrong, because the two argument version works fine

<ijp>the error says cps, so it's probably one for wingo, who is unfortunately not here

IRC channel logs

2015-06-07.log