IRC channel logs


back to list of logs

<daviid>I'm asking because it seems to be yourprefix/share/doc/foo/examples fine but examples would then only be installed if the user installs the doc, where as if, i.e., in share/guile/site/grip/clutter/examples/ they would get them anyway, wdyt ?
<daviid>or should it be share/ and installing examples always occurs, even if the user does not install the doc ?
<daviid>paroneayea: hello! will ask the autool channel what they think/do
<daviid>have to go, bbl
<amz3>I do builg ie. blog + build a search engine
<amz3>aahah I made up that word alone :)
<amz3>this will allow me to test the new version of wiredtiger ^^
<amz3>don't hold you breathe though ;)
<amz3>by the way, I started another blog, I plan to have two blog one in english, the other in french (hyperdev)
<amz3>I use haunt for this one
<amz3>I use the vanilla haunt software without much modification, but I lakes I think the ability to use it like use to do
<amz3>I use to have every file inside a directory (images, snippets) and link everything from there.
<amz3>every file for a given post
<civodul>Hello Guilers!
<ArneBab_>amz3: wow, that looks cool!
<ArneBab_>(first impression)
<ArneBab_>regarding the website mockup: I did not like the Logo mockup that much (to sterile, even more in the light of the rest of the design), but the rest is really nice.
<amz3>thx :)
<amz3>(it looks like the new google logo.)
<csed>So the GNU Guile book mentions that Guile is "properly tail recursive". I understand that bit, but does anyone know of an example where a language isn't properly tail recursive?
<csed>And if so, why would it be different from Guile?
<civodul>csed: until a few years ago, GCC did not implement tail-recursion, for instance
<civodul>JS implementations in general are not tail-recursive
<civodul>same for Java, i think
<mark_weaver>GCC still doesn't isn't properly tail recursive. it's quite rare for a language to be properly tail recursive.
<mark_weaver>s/doesn't //
<csed>civodul: So what would that mean, exactly? This is what I'm unclear about. When would a language not be properly tail recursive? When tail recursion doesn't scale properly with the input provided?
<csed>Not really sure is this is a #guile question or general programming, to be honest.
<mark_weaver>csed: "properly tail recursive" means that procedure calls in tail position are *semantically* a GOTO with arguments, which means that the behavior is guaranteed in all cases. in almost all other languages, it is an optimization that can *sometimes* be done, and thus it is called "tail call optimization".
<amz3>csed: if a language implementation doesn't optimize tail recursive code, it will hit the a recursion/stack depth limit, where Guile doesn't
<mark_weaver>when a language is properly tail recursive, you can use syntactic recursion to write loops, and be guaranteed that no matter how many iterations are performed in the loop, the stack space used will be bounded to a constant.
<mark_weaver>ACTION goes afk
<csed>mark_weaver, amz3: Hm, alright. Cheers.
<csed>So this is interesting.
<csed>Good thing I have Geiser. But I'd still like to figure out why this isn't working.
<csed>Any ideas?
<csed>But ice-9 history is there.
<csed>Was this something that had to be enabled at config?
<mthl>Hello paroneayea
<davexunit>wish I could have went to northeastern, but I turned out alright anyway.
<davexunit>"Northeastern offers a unique But see Uniqueness. curriculum on programming. Instead of the currently fashionable programming language, it focuses on explicit and systematic approaches to program design."
<davexunit>they get it
<amz3>How would you know what would happen if you did that school ? :)
<amz3>maybe you would be doing... DrRacket programming :))
<amz3>This: Pair programming forces them to articulate their thoughts so that they can converse about programs.
<amz3>they rationlize the tinkering done during the programming process in figure 1
<amz3>indeed it's good article
<amz3>I think they have a point, I may read their book at some point
<davexunit>I need to have a poke around
<davexunit>I read chunks of SICP periodically, should add this in.
<paroneayea> ha
<zacts>we need comp h4x programming sidewalk colleges
<zacts>there was that hackerschool in NYC that was free
<zacts>but they changed their name
<zacts>I can't remember what they changed it to
<davexunit>paroneayea: awesome
<zacts>it's like a coding workshop
<zacts>they like SICP
<zacts>there is also a european version of it, a european branch/fork of the school
<zacts>it's really an organikally structured mentor project based school
<zacts>I found it!
<zacts>^ check this one out
<zacts>I'm personally considering it sometime
<davexunit>will do zacts
<davexunit>sounds potentially neat
<amz3>funny story, they changed their name because people coming from abroad had to explain at the border "why they came to hack in america" or something
<amz3>good project come out of their
<amz3>the european equivalent of recurse is down
<amz3>Still they are some independant schools, but those are schools. They are a few craftsman dojo in the year too
<amz3>I speak of France
<amz3>dojos are not as intensive as recurse I guess
<thorwil>hi! the earlier logo mockup inspired me:
<daviid>thorwil: with all due respect, i prefer luis's version, although i mentionned, another user als made this comment, that i didn't like the G shape, my 2c [luis, take them too :)]
<thorwil>daviid: well, i started out with trying to make a round G work in a paren shape. no luck and constantly reminded of google's new G
<linas>I have a wild question on combining regex-like concepts with s-expression trees ... anyone done anything like this?
<linas>e.g. I have a list (a b c (d e f (g h) i) (j k l) m))
<linas>and I want to specify a regex-like pattern to match the above
<davexunit>so a pattern matcher.
<linas>e.g. (a * (d * (*) *)
<davexunit>(use-modules (ice-9 match))
<daviid>linas: and look also to match-sxml
<daviid>for inspiration...
<davexunit>(ice-9 match) has what you need
<davexunit>it's a well travelled problem
<davexunit>I use pattern matching constantly
<linas>yes, thanks .. as it happens, I'm working with a completely different system; its not in scheme; it has types, yada ydada, but we need some new ideas
<linas>davexunit: you use it constantly? For what?
<davexunit>destructuring lists, alists, records, etc.
<linas>where does the need for this typically arise?
<linas>I imagine you use it to glue together two very differrent systems, maybe ..
<davexunit>anytime you are trying to extract data from a structure
<davexunit>here's how to grab all the keys out of an alist with 'match':
<davexunit>(match '((foo . 1) (bar . 2)) (((keys . _) ...) keys))
<davexunit>it's a pretty example because you can of course do (map car '((foo . 1) (bar . 2)))
<davexunit>but it should give you the idea of the power
<davexunit>an idea*
<amz3>maybe linas you can explain what you try to achieve, will think together ? :)
<linas>yeah, in scheme I use map and car for pretty much everything :-/ I'm still little better than a novice after all these years
<linas>amz3: heh. the $64 question
<davexunit>if you've ever used things like cadr, cadadr, etc. then you will love pattern matching
<davexunit>another example: here's how to match a list of integers:
<davexunit>(match '(1 2 3) (((? integer? _) ...) #t) (_ #f))
<davexunit>=> #t
<amz3>linas: I've put under my pillow
<linas>I have this *other* system, completely different, it's not scheme; it has a pattern matcher that can simultanously solve multiple patterns
<linas>however it has no concept of globbing, so I'm really looking for effective ways to glob.
<paron_remote>ACTION has https working in his local copy of guile...
<amz3>like (match (many <concept1>))
<linas>well, multiple clauses, all of which have to be simulataneously satisfied
<amz3>hmm, this graph pattern matching?
<daviid>prolog ...
<linas>but that part has been long done .. yes, graph patttern matching
<davexunit>(match 1 ((and (? positive?) (? integer?)) #t) (_ #f))
<linas>(the graph decomposing into a set of trees)
<amz3>I hope I don't add to the confusion, but lately i've been working with gremlin ( for a preview) and it sounds more and more like recursive parser combinators
<amz3>I remember that tinkerpop people talking about validating graph/subgraph using it
<daviid>linas, you may look at guile-log as well then, minikanren too...
<amz3>and indeed it does some kind of glob like: here is a <path specification> follow it until <predicate>
<amz3>s/follow/repeat in the sens, visit the nodes
<linas>yeah, I think about parsing a lot. Looked at minikanren, but at the end, it wa the wrong fit
<daviid>just helping with links, not saying it is the right tool, don't even know what you're trying to do and why would that be not using scheme :) but look at guile-log for inspiration might be good idea. herewe all extensively use match, as davexunit said earlier...
<amz3>guile-log is more that parser combinators
<linas>yeah, the system I'm working with has a long history; it does have a guile api, though
<amz3>the lastest traversal language definition can be found here:
<linas>damned java
<amz3>I made a python implementation but it's incomplete
<dsmith-work>Thursday Greetings, Guilers
<linas>yeah, tinkerpop looks interesting. Wish it were scheme. I have a typed graphical database, I have a pattern-matcher/query-engine for it.
<linas>Its much more sophisticated than e.g. neo4j
<amz3>what do you mean "you have a typed graphical database" ?
<linas>but I can just feel the java folks nipping at my feet
<linas>typed == e.g. usual sense of "types" in compsci, type theory
<linas>graphical database == something that stores a bunch of trees. nodes in the tree have types
<linas>oh, and its quasi-programmable, too; there are ways of having evaluatable expressions
<amz3>is it atomspace? I though it was written in C
<linas>its like an insane mashup of sql and scheme and prolog and caml and haskel and sql and bayesian nets
<linas>and it does each one of those poorly.
<linas>its the atomspace. I hate it except I need it
<amz3>I am lurking around the project, like I said above my plan was to read the chapter about atom space
<paron_remote>ACTION would like to understand the atomspace motivations too
<amz3>because right now I understand that atomspace is meant to be programmable and is (some kind) of hypergraph
<linas>I' happily replace it by an insane mashup of tinkerpop and guile and neo4j and prolog ... if someone else did a better job of it
<amz3>I don't understand what are what do those algorithm
<amz3>the book 1100 pages, it will take time
<linas>atomspace was not orignall meant to be programmable; its just slowly becoming so.
<linas>atomspace was originally just a store for typed trees,
<linas>so, like a graphical database
<linas>the trees encode "facts" about the world, much like first-order-logic encodes "facts"
<linas>or prolog encodes facts. Just a bunch of trees.
<linas>and given a bunch of facts, one wants to do reasoning on them.
<linas>but probabilistically, using probability theory (markov model type reasoning, bayesian-netowrks etc)
<linas>the result is a frankensteins monster
<linas>pehaps a lot like tinkerpop
<linas>which clearly has far more mindshare
<amz3>I don't think the task is comparable
<linas>why not?
<amz3>this is not research
<amz3>it's engineering research not AGI research
<linas>OK, except for me 99% of AGI research is defacto maintaing a tool
<linas>and that tool resembles the kinds of tools that people do engineering research on...
<linas>so its a chicken and egg problem
<amz3>imo the problem is big, bigger that layer several business products with a common api
<mario-goulart>Please report chicken and egg problems to #chicken
<mario-goulart>ACTION trolls and ducks
<davexunit>git clone
<davexunit>I just threw the code I left off in there.
<linas>thanks amz3 it just that, every now and then, it feels like the business products are breathing down my neck
<amz3>by business I meant, stable product
<amz3>linas: there is 800 people a day downloading my program, nobody tells me what they use it for. It' can't be just to have a look at the code at this point. This is the way it is.
<linas>amz3: I missed it: what program is that?
<amz3>linas: it's a graphdb to explore graph data
<amz3>I load conceptnet and study how to to do summaries using graph theory
<linas>ah well, bingo
<amz3>the "develop" branch on github is better, much faster, I takes me 30min to load conceptnet
<daviid>davexunit: great! thanks, will clone and hopefully hack with you on this! [as times allows...
<paron_remote>civodul: ping
<civodul>paron_remote: pong!
<paron_remote>civodul: so! I've mostly ported the https stuff to guile proper
<paron_remote>civodul: but I'd love some clarification on some stuff before I continue further..
<davexunit>daviid: cool! I started it and ran out of steam quick
<daviid>davexunit: ok, cloned, just to confirm, it's fully empty right?
<davexunit>gah, it shouldn't be
<davexunit>one sec!
<davexunit>will fix
<daviid>ok, cool
<davexunit>daviid: sorry, now try
<daviid>ok, got scripts/init.scm noww
<linas>daviid: are you working on guile-log? I would be much better if the first thing you saw wa a description of what it is, rathr than how to build it.
<linas>some sort of over-the-top hype about how great it is for logic, and a sketch how how it coul;d be used
<daviid>linas: no, have to ping stis
<linas>and only then, how-to-build-install
<paron_remote>civodul: alternately I can submit to the list
<davexunit>daviid: cool, add the root of the source directory to your source tree and you should be able to run 'guild init --help'
<linas>no stis on this channel
<civodul>paron_remote: neat!
<paron_remote>oh I should remove that TODO comment, since it does error out early ;p
<civodul>paron_remote: i'd use the same autoload hack as in (guix build download), maybe
<civodul>to avoid 'gnutls-ref'
<daviid>davexunit: ok
<paron_remote>civodul: should we merge together open-connection-for-uri and open-open-socket-for-uri
<paron_remote>civodul: hm, I thought I was told that didn't fail gracefully
<civodul>hmm maybe
<paron_remote>if gnutls was not present
<paron_remote>in this channel!
<paron_remote>hence why I did that
<civodul>oh you were? :-)
<civodul>well i think it's fine, except you get compile-time warnings if GnuTLS is missing
<civodul>but note that it's not just #:autoload, but rather (module-autoload! ...)
<paron_remote> <mark_weaver> what's wrong with the autoload hack?
<paron_remote><civodul> mark_weaver: the autoload hack fails gracelessly when GnuTLS is missing
<paron_remote><civodul> that's fine in the context of Guix, but maybe not in a more general context
<paron_remote><paron_remote> oh :)
<civodul>also 'tls-wrap' leaks file descriptors, see
<paron_remote><paron_remote> civodul: what approach would you suggest then?
<paron_remote><civodul> yeah maybe with some explicit module hackery
<paron_remote><civodul> an explicit resolve-interface + module-ref
<paron_remote><civodul> something like that
<paron_remote>I was only following orders! ;)
<civodul>oh damn it :-)
<paron_remote>the other concern was that gnutls contains guile as a dependency
<paron_remote>so there was a circular dependency risk
<davexunit>oof yeah
<civodul>maybe it fails gracelessly in the sense that it you pass it an https URI, then it'll try to use those symbols, and at that point fail with "unbound variable"
<civodul>oh yes
<daviid>davexunit: perfect, all set. 'just' need to fins some time now :)
<civodul>so, this patch takes the correct approach! :-)
<paron_remote>that's why I did the delay/force stuff
<paron_remote>civodul: good to know, I'll add comments relevant to that?
<civodul>riiight, sorry
<paron_remote>civodul: so the other thing is that it seems strange to have open-connection-for-uri and open-socket-for-uri as separate things
<paron_remote>why not have them as the same thing?
<civodul>instead of (format (current-error-port) ...), it would be nice to raise an exception when TLS is needed but GnuTLS is unavailable
<paron_remote>civodul: it does that
<civodul>in Guile core these two procs could be the same, yes
<paron_remote>I figured that the warning could be there in case it was being "sniffed" but not available
<paron_remote>because if not available, it returns #f
<paron_remote>but the moment the user "needs it" with guile-ref
<paron_remote>it raises the exception
<paron_remote>this way you could see if gnutls-module is there or not
<paron_remote>but I could rearrange it to not have the #f
<paron_remote>just raise an exception
<paron_remote>maybe it's not needed to do it in gnutls-ref, if the user wanted it, it's needed anyway
<paron_remote>no need for "sniffing"
<paron_remote>civodul: yes it sounds like is a problem
<civodul>aesthetically, there could be (let-syntax ((G (syntax-rules () ((_ sym args ...) ((gnutls-ref 'sym) args ...))))) (G set-session-transport-fd! foo bar))
<civodul>something like that
<civodul>yes, the leak is a problem
<paron_remote>uh :)
<civodul>shouldn't be hard to fix though
<paron_remote>ACTION tries to parse the let-syntax
<paron_remote>speaking of let-syntax, if I'm merging together open-connection-for-uri and open-socket-for-uri, what to do about that huge let-syntax that wraps it with with-https-proxy??
<paron_remote>ACTION removes a ? from that last one
<paron_remote>civodul: apologies if this would have been better done via email :)
<civodul>paron_remote: np, but we can continue by email since i'm going to sleep now :-)
<paron_remote>civodul: sounds good!