***cluck` is now known as cluck
<nalaginrut>an id named AndreBabe mentioned me, I thought it's you <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_>(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
<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>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>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>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>the test case is compiling assembler.scm <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>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 ;-) <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 <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 <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 <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>healer: I'm sorry, I didn't try it and said something stupid, but I have to leave right now ;-) <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_>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>I have no factorial, so there's no result that I thought it runs <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 <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>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 <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??? ) <wingo>nalaginrut: i think there is somethin in the manual about it *wingo in and out this afternoon, yay springtime in the garden <nalaginrut>wingo: I want it stackoverflow in non-tail-call, I've set stack to very low size, but seems useless