IRC channel logs


back to list of logs

***cluck` is now known as cluck
<nalaginrut>morning guilers~
<ArneBab_>moin nalaginrut
<nalaginrut>ArneBab_: heya
<nalaginrut>ArneBab_: is that your tweet?
<nalaginrut>well, on twitter
<nalaginrut>it's the channel I talk to muggles
<nalaginrut>ArneBab_: oh, no, just similar id...
<ArneBab_>nalaginrut: which tweet? ☺
<nalaginrut>an id named AndreBabe mentioned me, I thought it's you
<nalaginrut>but it's not, that guy is in HK
<ArneBab_>ah, no… what’s your twitter ID? (mine is ArneBab)
<nalaginrut>it's the same with my IRC id, but I do lot of trash talk everyday, you don't want to follow ;-P
<ArneBab_>nalaginrut: also I’d hit the translate link all the time ☺
<nalaginrut>ArneBab_: haha, if you do so, it's just like C users translate Scheme to C then learn what it said...
<ArneBab_>nalaginrut: I mostly know the translation quality for japanese (I follow some anime creators, and understanding the translation requires lots of guesswork), is it similarly bad for chinese?
<nalaginrut>ArneBab_: Modern Chinese would be a special case to make things worse
<nalaginrut>ArneBab_: well, I should say, modern simplified Chinese
<ArneBab_>why? does the language currently change a lot?
<nalaginrut>people invented lot of metaphor and slang to avoid kind of political censor
<ArneBab_>oh… I can imagine that that’s hard to translate…
<nalaginrut>and the simplified Chinese are created because of some political reasons, so it's far from the old Chinese
<nalaginrut>modern Chinese became verbose and lack of elegant compared to ancient Chinese
<ArneBab_>what kinds of political reasons?
<ArneBab_>(and how much is verbose? In german many people nowadays take care to use both sexes when speaking about groups - is it like that or much more?)
<nalaginrut>ArneBab_: it's stupid reason, taiwan uses traditional Chinese, for proving mainland is the real traditional, they invented a new simplified version
<nalaginrut>this is the radical reason, although some people argue that simplified characters is better for learning
***Guest7947 is now known as Cork
<civodul>Hello Guilers!
<ArneBab_>It looks like software transactional memory in pypy¹ is taking shape. There is quite a bit of information about parallel execution² in the guile manual, but I did not find a high level overview. Can guile do something like pypy with STM? ¹: ²:
<ArneBab_>from my limited understanding it sounds like the effects of STM could be replicated by using fluids for any global value some code accesses, but I don’t know enough about fluids to be sure.
<wingo>whee, fixed range inference in the new compiler
<wingo>before it wasn't inferring anything from a < <= >= > test
<wingo>now it's precise.
<wingo>so i made a local experiment to represent cps programs as instead of being a nested term with $letk instances at some appropriate scope position, to being a map from label -> term
<wingo>and no $letk
<wingo>instead we rely on dominators to sort out what terms are used and where they should go in the output code
<wingo>this test branch uses intmaps and intsets
<wingo>which are based on array-mapped tries, the data structure that clojure uses a lot
<wingo>one of them anyway
<wingo>unfortunately the perf has been terrible.
<wingo>originally something like 4x as slow as the original.
<wingo>because of data structure overhead, basically, though there are some other differences.
<wingo>i have golfed it down to 1.6x as slow.
<wingo>still a bit discouraging
<wingo>we'll see i guess
<wingo>the test case is compiling assembler.scm
<wingo>which is a fairly big term.
<wingo>and actually these numbers are just for the simplify pass
<ArneBab_>wingo: does that mean only the compiler is slower or the code is slower?
<wingo>hard to know what a full-pipeline conversion would be
<wingo>ArneBab_: compiler slower
<ArneBab_>what is your goal with the experiment?
<wingo>three things really
<wingo>one is to reduce recursion, because recursion with the evaluator isn't subject to the same safe-for-space guarantees as with compiled-code
<wingo>so i was hoping that could reduce bootstrap memory usage
<wingo>instead this branch uses functional worklists
<wingo>another was speed, because having a label->term map obviates the need to compute such a map
<wingo>which other passes in the compiler do often
<wingo>and finally was to make more optimizations possible -- scope is an approximation of the dominator tree, and not all transformations that would be valid on a dominator tree are actually valid on a scope tree
<wingo>so a few more involved passes end up doing gymnastics to rewrite the scope tree, or to not make certain transformations if they would not preserve scope
<wingo>scope is basically an embedded proof that values and continuations are defined before they are used
<wingo>but the compiler doesn't really need to maintain such a proof in its work, and having to rebuild the proof in addition to the term is extra work.
<nalaginrut>I know it's slower after I updated several weeks ago, but when I tried to write something, it's still faster than many languages, little slower than C. Maybe it's related to what you write and your implementation. Anyway, I have full confident to expect good result ;-)
<nalaginrut>little slower than older 2.1
<ArneBab_>wingo: did memory usage decrease?
<wingo>ArneBab_: hard to tell right now
<ArneBab_>I ask because it sounds like you could have achieved 2 of 3 objectives
<wingo>excessive memory usage is mostly a problem when bootstrapping, and i would need to convert more of the compiler to try that out
<wingo>still poking around to see if i can golf away the perf
*nalaginrut like this jargon
<wleslie>nice to have it on one page
<wingo>golf is nice too tho
<ArneBab_>golf sounds less like “blowing up this code to make it faster” and more like “scoring additional improvements”
<wingo>well in golf you always want to make fewer strokes
<wingo>(or throws in the case of disc golf!)
<wingo>so aiming to get the same job done in fewer moves
<wingo>is how i think about perf
<ArneBab_>that’s what I like about the name ☺
<ArneBab_>wingo: though as dark side, golfing to me (non-native speaker) also sounds like “applying learned techniques to the problem and keep the ones which work”
<ArneBab_>are there tools to analyze the length of scheme programs by something like the number of symbols?
<nalaginrut>oh, auto grow stack of guile-2.1 seems bring me some happy trouble ;-)
<nalaginrut>the problem is the test case should end when calling a non-tail-call function, then it's the expected PASS result. But when I write it with Guile, the tests blames there's a result rather than crash...
<healer>The pasted code snippet will not run under debian
<nalaginrut>it's not tail-call, so the stack was killed
<ArneBab_>healer: does it run if you put the content of the third line after the content of the second line?
<healer>it runs if the third line is on the same line as the second
<healer>but this is not stated in the docs, is it a bug?
<nalaginrut>my happy trouble
<nalaginrut>healer: I'm sorry, I didn't try it and said something stupid, but I have to leave right now ;-)
<ArneBab_>healer: the meta switch only works for the second line: see
<ArneBab_>The newline character terminates the sequence of arguments, and will also terminate a final non-empty argument. (However, a newline following a space will not introduce a final empty-string argument; it only terminates the argument list.)
<ArneBab_>^ quote from the docs
<ArneBab_>healer: it’s not that easy to find, though
<nalaginrut>I don't know what's the problem, but I can run it under guile-2.1+
<ArneBab_>nalaginrut: I guess the third line is silently ignored.
<nalaginrut>ArneBab_: ok
<nalaginrut>I have no factorial, so there's no result that I thought it runs
<nalaginrut>anyway, I'll go home, see you later
<healer>The point is that the meta-switch is stated to allow additional arguments until the !# line
<b4283>i've found two solutions to my own question the other day about reading big chunk of file quickly
<b4283>it's a shame i hadn't realize it was there within guile
<b4283>one way is through (read-string!/partial), strange name but does the trick
<b4283>almost as fast as C counterpart, and with encoding conversions
<healer>What is the state of guidhall nowadays?
<healer>Has anyone thought of embedding guile in apache-http server?
<b4283>the other is through (get-bytevector-all)
<b4283>also fast but only gets you a #vu8()
<b4283>healer: if you mean a mod-guile, that would be an interesting idea indeed
<healer>I mean compiling lib-guile into apache
<healer>Providing guile as an extension language from within apache; it might no longer be apache as we know it
<healer>Extending apache with guile
<healer>right from the inside
<wingo>b4283: there is some other function that does that for strings
<wingo>you can (read-delimited port "")
<wingo>b4283: (ice-9 rdelim) read-string
<wingo>lol not that one ;)
<wingo>hoo, that is an inefficient function
<wingo>b4283: i guess get-bytevector-all is the thing, and convert to your encoding as needed. not so nice tho!
<b4283>wingo: yep, going through utf8->string
<b4283>still, it's good enough
<healer>ping nalaginru
<paroneayea>hei wingo
<paroneayea>what's going on in wingoland
<paroneayea>wingo: while sick the last few days I printed out JAR's capability essay, and your blogposts on it, as well as the Eros essays
<nalaginrut>wingo: how can I disable stack increase temperately? IIRC there's a env var
<paroneayea>( wingo: then I had nightmares that someone broke into my systems and I was arguing with someone whether a capability based system could have helped mitigate it??? )
<paroneayea>the nightmares probably due to fever :)
<paroneayea>anyway :)
<dsmith-work>Tuesday Greetings, Guilers
<wingo>nalaginrut: i think there is somethin in the manual about it
<wingo>paroneayea: hehe funny :-)
*wingo in and out this afternoon, yay springtime in the garden
<nalaginrut>wingo: thanks!
<nalaginrut>wingo: I want it stackoverflow in non-tail-call, I've set stack to very low size, but seems useless
<nalaginrut>wingo: oh, it's done!