***republican_devil is now known as gavino_himself
<Chaos`Eternal>anybody can give me a quick answer which gc we are using: incremental or primitive? <bipt>what do you mean by primitive? boehm gc is incremental by default <bipt>it can also operate in stop-the-world mode, and it supports parallel collection but IIRC that doesn't currently work properly with guile <nalaginrut>Chaos`Eternal: you have to set env var for incremental <nalaginrut>bdw-gc support incremental, but not default, you have to set environment <nalaginrut>Chaos`Eternal: you have to set GC_ENABLE_INCREMENTAL to turn on it <nalaginrut>gavino_himself: not yet, but I saw it in some branch <Chaos`Eternal>so if i don't set that env, will the gc turn into a big GIL? <nalaginrut>gavino_himself: anyway, I wrout a binding myself in a server project <nalaginrut>anyway, artanis is a core part of glow, but it can work self-contains <nalaginrut>if you need a lightweight web-framework, just use artanis, but if you need a full-stack one, use glow(in the future) <gavino_himself>is there anything like www.prevayler.org or cl-prevalnce for ram absed storage fo my website data? <nalaginrut>I'm writing docs, there's a simple doc in README <nalaginrut>gavino_himself: there's no best solution, depends on your need ;-) <nalaginrut>mark_weaver: thank you very much (and shame on my lazy) <mark_weaver>a bit more complicated than I'd like, but it produces a very efficient procedure. <gavino_himself>although I heard some unix wizards said oo is the roman numerals of computing <mark_weaver>I suggest that you all ignore gavino. He's a long-time troll on #scheme, always going on about whether Scheme is capable of replacing high-performance databases, etc. <mark_weaver>nalaginrut: I just implemented the spec that you wanted :) <mark_weaver>nalaginrut: fwiw, if you find that code too complex, I won't be offended if you don't want to use it. but you tend to worry about efficiency a lot, and string templating is actually a case where efficiency can be a concern, if the templates are big. <nalaginrut>mark_weaver: I need to understand it all, and modify something, since the interface design was changed by me <nalaginrut>mark_weaver: it's better than 'format' version, since I know how our 'format' performance is <mark_weaver>well, 'rev-items' is a list of the items to be concatenated, in reverse. <mark_weaver>where each item is either a string (to be copied directly), or a pair of the form (keyword . default) <mark_weaver>nalaginrut: sure, you could, but it won't make much difference in practice. the only cases where it makes a difference is if there's only one string to concatenate, or if the result would be the empty string. <mark_weaver>anyway, what 'optimize' does is to combine adjacent strings in ITEMS into a single string. <nalaginrut>sometimes I'm afraid of GC too, maybe because GCJ ;-P <nalaginrut>anyway, as you said, it depends on your algorithm <mark_weaver>in practice, adjacent strings only happen if there is "$$" in the template. <mark_weaver>if you wanted to simplify the code, you could remove 'optimize' entirely, and replace the one place where it's called with 'reverse' <mark_weaver>well, it also removes empty strings from the list of items. <nalaginrut>mark_weaver: oh, I realized you implemented a simple partial-evaluator inside <mark_weaver>I think calling this a "partial evaluator" is a bit of an exaggeration, but basically I tried to do as much work ahead of time as possible, so that when the final procedure is called, it will have as little to do as possible. <mark_weaver>and as I've said before, Guile's 'string-concatenate' is quite efficient. <nalaginrut>I compared string-join format call-with-string-output string-concatenate <nalaginrut>string-concatenate < call-with-string-output < string-join < format <nalaginrut>so I did many things with call-with-output-string <nalaginrut>if we wrap the fmt into a closure or something like <mark_weaver>well, no matter how good 'format' becomes in the future, it has the fundamental problem that the template will have to scanned every time you want to instantiate the template. <nalaginrut>OK, the "~?" way is easy to implement this, but I don't know it's so slow <mark_weaver>well, for ssql, the templates are generally quite small. <nalaginrut>ssql depends on 'format' heavily, fortunately the relational-mapping has a cache to avoid calling 'format' each time <mark_weaver>I expect that 'make-string-template' could have very large templates.. e.g. entire web pages. <mark_weaver>for that reason, my expectation is that 'make-string-template' performance could be important for the overall performance of artanis. <mark_weaver>but maybe I'm wrong. profiling real-world use cases is the only reliable test. <nalaginrut>I'll change README: Artanis aims to be a guile template collection, GTC in short ;-P <mark_weaver>The funny thing is, I don't advocate using python 3 templates. SXML+quasiquote is a far superior method to create web templates, IMO. <mark_weaver>and yet SXML+quasiquote will almost certainly be slower than even the 'format'-based implementation of python3-style templates. <mark_weaver>so maybe it's not worth worrying about efficiency so much. but you tend to worry about speed a lot, so I did my best to make a fast 'make-string-template' for you :) <nalaginrut>well, that's a question I always want to ask, so sxml->xml is slow way? <nalaginrut>mark_weaver: I tend to worry about speed since my algorithm is always suck ;-/ I'll catch up with that <mark_weaver>the truth is, if efficiency is what you need, then use C :) <mark_weaver>any method of producing xml/html by concatenating strings together is prone to security flaws, because of strings not being escaped properly. getting that right is notoriously difficult. <nalaginrut>I used to mixed C+Guile and enjoy that, but Artanis is a idea to avoid any C <Arne`>nalaginrut: Some people may be violating copyleft. But as soon as those people push towards “now I want *my* work protected”, they actually have to adhere to the copyleft themselves. Just look at Samsung: They broke the GPL of Linux when they created a non-GPL-compatible exFAT module, but since they are dependent on GPL-code for their core business, they were essentially forced to release that module. Otherwise they could have lost all <Arne`>rights to distribute Linux, which would have been quite some blow to their Android sales… <nalaginrut>Arne`: yes, but the examples I said are not huge company like samsung, so it's hard to control <Arne`>nalaginrut: The great part about copyleft is that it uses the power of those who fight against the freedom to share to protect exactly those freedoms. <Arne`>nalaginrut: I would not fret on controlling too much. The fight against parasites often does more damage than the parasites themselves. <Arne`>We do not lose anything, when they violate our copyright. <Arne`>But if their idea succeeds (and we took care of using the right license - for example AGPL for anything web-based), then their core income suddenly depends on adhering to free licenses. Which is why for example I setup my own statusnet instance when identi.ca switched from the AGPL status.net to the BSD pump.io <Arne`>and at that point, they are essentially doing a huge advertisement campaign for our project which we could never have financed ourselves. <nalaginrut>yes, we don't lose anything, but they lose a big chance to study and get improved, there'd be price <Arne`>do you mean those stealing free code lose? <Arne`>in that case: that’s their choice and their price to pay. <Arne`>if we get them to share back at some point, their copyright violation at the beginning might have helped them getting over their mental block, so it might actually turn out to be good. <Arne`>as long as you make sure that your licensing is in sync with your philosophy, you should be on the safe side, I think. That means: “I don’t want people to share back, I just want to spread my own code” → use BSD or MIT. “I want to create a community of people using my code for their own projects” → use LGPL or GPL. “I want to create a community of people working together on a shared project” → Use GPL (for desktop applications) or AGPL <Arne`>I think the great fallacy of some of the BSD folks is complaining that people do not share back while their license explicitely allows not sharing back. Their social pressure (we’ll be angry) and organizational pressure (you will get maintenance hell) is not in sync with their legal pressure (just take what you want). <Arne`>And that’s why I prefer working with GNU software :) *Arne` once was a Mac user. Then came the TPM module — and the Apple Hardware met Gentoo GNU Linux. Years later, Python and Emacs entered the scene :) <Arne`>and The Adventures of a Pythonista in Schemeland led me to learning Scheme — while my fascination for free software got me to decide in favor of Guile. <Arne`>(and in between I started doing news work for the Hurd — thanks to one of our informatics professors who asked us to find the difference between Linux and the Hurd. I could not find the current state of the Hurd in over 1 hour of searching and decided to take up the task of making that easier) <Arne`>nalaginrut: I won’t have time for that in the close future. <nalaginrut>I have to get familiar with hurd first, let alone guile-hurd in close future <Arne`>nalaginrut: Firstoff I want to scratch my own itch: My early exposure to Python makes me shudder at the structure overhead which comes from using indentation and parentheses to encode the same information. Wisp is my attempt to change that. <Arne`>just a preprocessor: add brackets from indentation. <Arne`>nalaginrut: Essentially a guile-hurd would need to provide bindings to the Hurd libraries. And then provide convenience features. <Arne`>nalaginrut: There are already common-lisp bindings, but those depend on libraries which are not packaged in debian… <Arne`>hurd lib should be installed on the Hurd be default. I’ll check. <Arne`>nalaginrut: yes, wisp is like sweet-expressions, but keeps it much simpler. I started working on it when sweet-expressions grew the $ and \\\\ and <* *> syntax… (I was part of the discussion, but others preferred the programmer convenience over the simpler syntax) <Arne`>uh oh… I’ll forward that to #hurd <Arne`>I forwarded the info — this might require action. <Arne`>nalaginrut: compared to the additional syntax elements of sweet-expressions ($, \\\\, <* *>), wisp keeps very clean (: and . — the latter a generalization of using (. a) as a) <Arne`>nalaginrut: essentially wisp is an experiment to see how little additional syntax is actually required to make it possible to avoid as many parentheses as possible while still being readable and exact. And the . is already reserved syntax in scheme: I just added a second way to use it which does not impact the first. <Arne`>No syntax was added for convenience. But once I knew I had to reserve the :, I also knew that I should use it as widely as possible to offset the cost due to reserving the character. <Arne`>nalaginrut: I’m still working on my port of wisp to guile, though (I’m almost there, but it still has a few parser bugs - especially when I try to parse wisp-guile.w with wisp-guile itself). <Arne`>nalaginrut: What I really started to love while implementing wisp in wisp is how if-clauses turn out: <wingo>ffs someone fix the wikipedia page <nalaginrut>I found guile on wiki update timely, who's the hero? <gavino_himself>what kind of websites do you gents have working on artanis sofar? <wingo>please don't assume that we are gents <wingo>also, gavino_himself i know you like to ask questions but i'd appreciate it if you wouldn't ask the same kinds of questions here as you ask in #scheme. thanks :) <gavino_himself>assume gents includes all gentlepeople women men and tranny and othe rlife forms <gavino_himself>well its not fair for me to be restricted by what you want is it? <nalaginrut>gavino_himself: since Artanis haven't had a first release <nalaginrut>anyway, Artanis can replace the server easily, I'll make it configurable <nalaginrut>in case we have more powerful server project later <wingo>i think it would be great if someone would take up the maintenance of that page for a month or so <Arne`>that really had awkward wording… <wingo>make a plan about what it should look like, and incrementally get there <gavino_himself>I noticed something interesting about guile here on archlinux, it does not seem to have readline, to remember commands, so I used rlwrap, and when I did rlwrap already had remembered the commands from the guile seesion I quit <Arne`>I don’t have enough background knowlegde for that <wingo>while it's interesting to talk about the implementation, "compromises" implies that it's a bad setup, which is pretty strange <Arne`>gavino_himself: I added readline with 3 config lines, I think. <Arne`>(use-modules (ice-9 readline)) <Arne`>I think, though, that readline should be enabled by default. <Arne`>Not having readline in a GNU environment is mentally scarring :) <wingo>clisp is gpl, guile is lgpl, readline is gpl <Arne`>wingo: Maybe add a build flag which adds the dependency on readline (and makes the license GPL)? <Arne`>wingo: I would enable that on my Gentoo box by default :) <gavino_himself><--has to read scheme the lanf 4th and sicp and htdp still <<---amateur <Arne`>wingo: On Gentoo there already is a readline use-flag, but it’s not used. <wingo>there already is a build flag <wingo>but that's just to build, not to enable or not <wingo>i'm sure there's a way, but we have to be careful :) <Arne`>wingo: does it already get dependent on readline code when you build with it, or only when using the module? <wingo>Arne`: only when using the module <Arne`>wingo: Is there a systemwide guile-rc similar to the bashrc? <wingo>Arne`: yes, search the manual for "init.scm" <Arne`>C-h i m guile C-s init.scm C-s → nothing found ? <wingo>stat("/opt/guile/share/guile/2.0/init.scm", 0x7fff1b440420) = -1 ENOENT (No such file or directory) <wingo>stat("/opt/guile/share/guile/site/2.0/init.scm", 0x7fff1b440420) = -1 ENOENT (No such file or directory) <wingo>stat("/opt/guile/share/guile/site/init.scm", 0x7fff1b440420) = -1 ENOENT (No such file or directory) <wingo>stat("/opt/guile/share/guile/init.scm", 0x7fff1b440420) = -1 ENOENT (No such file or directory) <wingo>it seems to search the load path for init.scm <wingo>before loading anything else <wingo>tricky though, apparently that happens even before loading boot-9... <Arne`>hm, there is no useflag for readline… <Arne`>wingo: Is there another way to activate readline systemwide? <wingo>Arne`: dunno; if not there should be... probably init.scm was meant to do that <taylanub>Wikip: "One of the goals of Guile is to allow other languages to be translated into Scheme and thence into portable byte-code; thus Guile would effectively be a language-neutral runtime environment. This goal has not been fulfilled yet, ..." sounds very outdated too <taylanub>Also seems wrong to mention SLIB and SXML under "History" .. I'll make some touches. <gavino_himself>it must be fun to read how others code up solutions to similar problem in same language <Arne`>gavino_himself: I like Gentoo: Low person-time for maintenance, convenient choice. <Arne`>wingo: So there is no way to easily enable readline systemwide? <Arne`>hm, it’s under helping out, not under community <wingo>perhaps the whole thing is organized wrong, dunno <taylanub>Is our array module's functionality related to APL ? <wingo>so, gavino is a kind of a troll from #scheme <wingo>the poor fellow asks and asks about things, descending into madness, without ever coding anything <wingo>he has done that for as long as i've been in #scheme <wingo>so we should always be nice to people <wingo>but if you are too curious with gavino it will open the floodgates <wingo>just as a public service advisory :) <wingo>actually i don't believe we should always be nice to people, but it's a good starting position anyway <mark_weaver>wingo: you're nicer than I am. I've lost all patience for gavino. I ignore him, and encourage others to ignore him, so he'll get bored and go away. <taylanub>Would it already be appropriate to call Guile a Scheme compiler ? Wikipedia currently says "interpreter/virtual machine" <mark_weaver>(and I'm not shy to let him hear me say those things, as I did a few hours ago) <mark_weaver>(I don't believe in badmouthing people behind their backs) <mark_weaver>taylanub: yes, as of 2.0 it's definitely a compiler. <wingo>taylanub: i would call it an implementation of scheme <wingo>it includes a bytecode virtual machine <wingo>and a self-hosted bytecode compiler <taylanub>Hrm indeed, the details are verbose and vary throughout history, so the intro should probably just say "implementation". <wingo>if you have any suggestions for guile's web site, they are most welcome! <Arne`>wingo: luckily at some point tschwinge managed to turn the wiki (which I had been improving) into the main website. <Arne`>wingo: simple improvement: Give the community page its own heading, then add a small initial line (like “There are several [mailing lists](#mail) associated with Guile, as well as the [#guile IRC channel](#irc)”). Then add a table of contents (mailing lists, Chat). <Arne`>Also that first paragraph could mention the bugtracker. <wingo>would you mind sending that as a mail to bug-guile@gnu.org? that will open a ticket so we make sure it gets done <nalaginrut>Arne`: alright, the site of hurd in 2008 looks very similar with guile-site, but now hurd-site is better to find more info <Arne`>nalaginrut: We spent lots of time on that site - also to avoid losing any information. <Arne`>nalaginrut: tschwinge ported the whole hurd-wiki to ikiwiki and then setup the static compile to html such that we can use the wiki as staging area for the website. <Arne`>Does guile actually have a wiki? <nalaginrut>Arne`: there's one, but not many things on it, just built for 2 weeks I think <Arne`>If not, we could ask tschwinge whether it would be possible to host an ikiwiki-based wiki for guile on the hurd infrastructure (to be able to reuse his publishing scripts). <nalaginrut>anyway I'm writing a tutorial like "learn Guile in hard way" to show some good practice with Guile <Arne`>nalaginrut: that sounds interesting. <wingo>we have a really wonky web site generator <Arne`>I think it was the same for the Hurd :) <nalaginrut>I can't say Hyde of Chicken Scheme is nice to generate cool pages here... <Arne`>nalaginrut: The advantage of ikiwiki is that people can actually contribute online while others can contribute via DVCS. <wingo>i have forgotten how to use cvs entirely <Arne`>git and Mercurial are supported. Hurd uses git (though I would have preferred Mercurial). <taylanub>Does this sound technically accurate and neutral ?: "Since version 2.0, Guile is a compilation framework and run-time platform that can integrate any number of languages, although it continues to be an implementation of Scheme first and foremost. <wingo>it sounds a bit flowery, but whatever :) <Arne`>“compilation framework and run-time platform” sounds too technical, I think. <Arne`>taylanub: What’s the story about guile you want to tell? <Arne`>→ what should readers see from the first paragraph <Arne`>“can integrate any number of languages” sounds too vaporwarey <nalaginrut>"can provide any number of..." this sounds with air ;-P <Arne`>Since version 2.0, Guile provides a shared execution environment for several different languages, including Scheme, Emacs Lisp, <whatever the xlib XML files are called> and Javascript. <Arne`>but that’s not for the first paragraph. Still much too technical. <wingo>i wouldn't sell javascript too much; maybe just sell scheme and emacs lisp <wingo>our js implementation is horrible and broken <Arne`>the Xorg xml files sounded interesting <Arne`>then do not sell js at all here <Arne`>rather add a heading with a list of languages <nalaginrut>IMHO, selling scheme/lisp means sell nothing to muggles.. <Arne`>you need no muggles there, if you mainly want people to use scheme. <Arne`>Scheme is the reason why I looked at guile in the first place. <Arne`>Is the standard really R5RS? Not yet R6RS? <nalaginrut>but Guile2 support foreign-language-function-calling, which could be a selling point <Arne`>Lets look at 3 user-groups: (1) Schemer wants to see what GNU Scheme can do. (2) GNU enthusiast wants to extend an existing program with a scripting language. (3) Free Software enthusiast thinks about using Guile to learn programming. <wingo>they are somewhat divergent standards, and it's reasonable to pick one or the other <Arne`>Is there someone missing in the target-groups? <wingo>Arne`: language nerd just checking out another language <wingo>or person interested in starting a project, wondering what language and implementation to use <Arne`>wouldn’t the language nerd check scheme instead of guile? <wingo>maybe, yes -- though scheme is so minimal you end up extending it up to a bigger language, and there it makes sense to talk about "guile scheme" <wingo>e.g. racket successfully "pivoted" to consider themselves a language and an implementation <wingo>seemed to work well for them <Arne`>I started to just google for guile when I want to know something about scheme, because scheme has about the worst google foo of all the languages I know. Maybe just short of go… <nalaginrut>Arne`: you're checking out another language, right ;-D <wingo>we don't want to divorce ourselves from scheme, but guile does have language aspects to it <Arne`>nalaginrut: I checked out scheme with Pythonista from Schemeland. Then I looked at GNU Scheme, because I like GNU. <Arne`>(4) programmer plans to start a new project. <taylanub>Second attempt: "Since version 2.0, Guile includes a framework for compiling other languages to a common [[intermediate language]] and eventually [[bytecode]] or [[machine code]], although it continues to be an implementation of Scheme first and foremost." <Arne`>Questions for the user-groups: (1) Schemer: What can guile do better than other Schemes (forein function call? POSIX calls?), (2) Extender: What does Guile offer my program? Why Guile and not Python/Lua? (3) Learner: How easy and how powerful is Guile Scheme? (4) Starter: What’s the advantage of starting with guile? <Arne`>Wikipedia now says R5RS and R6RS <Arne`>taylanup: For where in the article is that? <nalaginrut><del> (5) someone don't want to be muggles </del> <Arne`>wingo: Your article lead me to usergroup (1) :) <Arne`>nalaginrut: That is a valid wish, though. Why is guile the coolest language on the block? <Arne`>Well, it’s scheme and it’s got macros :) <nalaginrut>Arne`: I always want to explain this to other guys, but I realize we lack of projects written with Guile, though assume they believe Guile is most powerful language in the universe, there's nothing they can use or learn from start <Arne`>wingo: what always looked odd to me is that your opinioated guide actually sells guile awfully short: only in emacs and maybe as server-side (but chicken wins) and dynamically linked? <nalaginrut>anyway, it's not the key point why Guile is good <wingo>Arne`: oh, dunno -- i love guile but there are other things out there, and honestly if you are starting a server-side project probably chicken's ecosystem will work better for you <Arne`>can you answer the questions for the usergroups in one sencence each? <wingo>i mean, I'm pretty irrational in my decision-making, but i can't assume everyone else is that way ;) <Arne`>wingo: You missed one part, I think: My scheme to keep → can do all these things, though not necessarily the best choice in each niche. You learn it once and can stick with it. <nalaginrut>I think we may make better advertisement for Guile <wingo>so that article's purpose wasn't to advertise guile, fwiw, just to give some summary that could be given in fairness to someone looking at schemes <wingo>the argument for selling guile is stronger, though there are areas that it doesn't do as well yet <nalaginrut>I don't think we have to do it very very well, then sell it stronger <nalaginrut>if we have more users/contributors, Guile becomes better and better <Arne`> (1) Schemer: What can guile do better <Arne`> than other Schemes (forein function call? POSIX calls?), (2) Extender: <Arne`> What does Guile offer my program? Why Guile and not Python/Lua? (3) <Arne`> Learner: How easy and how powerful is Guile Scheme? (4) Starter: <Arne`> What’s the advantage of starting with guile? <wingo>Arne`: so i guess what i'm saying is that answers to those questions would go on our web site <Arne`>arg… (erc is killing me right now with uneditable text. Sorry for that…) <wingo>but is it appropriate to "sell" like that on wikipedia? <Arne`>nalaginrut: Can you answer the user-questions? One sentence each: <Arne`>(1) Schemer: What can guile do better than other Schemes? <Arne`>(2) Extender: What does Guile offer my program? Why Guile and not Python/Lua? <Arne`>(3) Learner: How easy and how powerful is Guile Scheme? Why Guile and not Python? <Arne`>(4) Starter: What’s the advantage of starting my advanced project with guile? <Arne`>(5) 1337: Why is guile cool? <Arne`>wingo: On wikipedia you do not sell those answers directly. But you should include the keywords for each of the groups. After all, that’s what is relevant about guile. <nalaginrut>Arne`: thanks for these questions, I can't answer them in one day <Arne`>no probs. Take your time - or just answer those you can answer and leave the others to others :) <wingo>yes i would need a bit more time than i have atm to answer them <nalaginrut>well, these are real good questions to think about <Arne`>wingo: I started with the KDE PR team (but they moved at a too high pace for me), then chose to work on Hurd (there I could make the biggest difference with the time I could spend) and Freenet (which I think is desperately needed - and also has horrible marketing). <wingo>it's a rare skill, to organize communication in that way <Arne`>wingo: What I did here was the basic approach I learned from the KDE PR team: for whom could that which we can offer be interesting? What would they want to know? Answer that. <Arne`>wingo: For the Hurd I actually chose a communication-goal: Kill the notion that the Hurd is vaporware. That lead to clear rules for the monthly news: Only provide news about stuff which people can already test (though assume almost unlimited skill level for that). <Arne`>and add a link to every news item: This is tangible. <Arne`>For guile I do not know a communication target, yet: I do not know its biggest marketing weakness (counter that) and its biggest strength (which pond can we conquer with that?). <Arne`>taylanub: for the intro this is still much too technical, I think. <Arne`>It only answers the question why goile is cool. <Arne`>taylanub: If you add a note about foreign language function calls, that answers part of the Schemers question. <nalaginrut>yup, too technical only accepted by profound Schemers/lispers, but they can write their own implementation. But for muggles, they just don't get it <nalaginrut>there's a new phrase in Chinese: sounds-amazing-but-incomprehensible <nalaginrut>which make people can worship but can't take part in <Arne`>that’s a cool phrase :) — and sadly too true… I think free software should be about changing that. <Arne`>(6) Emacs enthusiast wants to know what that guile-emacs is all about :) (no real user-group, but a group of people who might drop by). <Arne`>Here’s an example of a really strong first line on Wikipedia: “Python is a widely used general-purpose, high-level programming language. Its design philosophy emphasizes code readability, and its syntax allows programmers to express concepts in fewer lines of code than would be possible in languages such as C. The language provides constructs intended to enable clear programs on both a small and large scale.” <Arne`>taking that apart: “widely used” → you’re in good company, “general-purpose” → you can use it for your next project, “high-level programming language” muggles: sounds cool (just like low-level) others: for programs not libraries, “code readability” → less dependency on a single developer and easy for newcomers, “fewer lines of code…than…C” → less work (though a bit of cheating: “than…C”, “small and large scale” → gene <Arne`>but stronger: Any kind of program. <nalaginrut>seems we have to claim the design philosophy of Guile <ijp>programmers could do with spending less time philosophising <Arne`>ijp: this discussion is not about programming, but about communicating guile to the outside. <Arne`>nalaginrut: Newbies need to know what makes guile special. <nalaginrut>yes, that's the question I have to answer each time <ijp>just lie, every other advert does it <Arne`>nalaginrut: what do you answer? <Arne`>ijp: we’re in free software. They can use the source. <ijp>use guile and you will lose 50lbs <ijp>or gain 50lbs, whatever <Arne`>ijp: Good marketing ensures that people understand what the project can actually offer, so that those who can benefit from the project actually find it. <ijp>then I have never seen a good marketer <nalaginrut>Arne`: guile aims to interact with C program easily and the expression of Scheme is cool enough to write any complex program, just like this <wingo>too bad; good marketing is really helpful :) <Arne`>ijp: Bad marketing searches for people who want something and then sells those something which does not fit. <Arne`>nalaginrut: This answers “why as extension language” and “why for my next project”. *Arne` needs to remember the user-groups: Schemers, Extenders, Learners, Starters, 1337s. <nalaginrut>the bottom half is: why not choose python/ruby for extension <nalaginrut>anyway, if guile-lua-rebirth done. I can say: well, there's lua on it, and you can interact with other languages <Arne`>but there you might be chasing a moving target, when the lua language changes. <civodul>wingo: did i say that what i looked at yesterday is AWESOME? <nalaginrut>so multi-language should be additional selling point <wingo>civodul: glad you like it :-)) <Arne`>nalaginrut: I meant that it can’t be guaranteed that Guile will support all future versions of Lua - and be faster than the general Lua. <Arne`>It just shifts the question to “why guile-lua instead of the regular lua?” <Arne`>and the answer could be “I want to reuse scheme-code and lua code” <Arne`>which is a cool selling point for free software <nalaginrut>and if you choose guile-lua, you seleted a real cool CPS+RTL compiler <wingo>i would be hesitant to sell guile-lua also, for the same reasons as js <ijp>that parser literally made me want to hurt people <nalaginrut>ijp: you need my guile-lua-rebirth, another mess, and a crap ;-P <nalaginrut>anyway, I think these language are possible to implement, so just answer"oh lua is not ready yet, so try Scheme, when it's done, you can reuse the Scheme part with it <nalaginrut>I wonder any guy tried Scheme for his project will take up other language again... <Arne`>GNU guile is a general-purpose development environment, which focusses on easy interaction with C programs and is used as extension language in several well-known Free Software projects like Gimp, […add 2 more]. Among others it features a full implementation of the Scheme Programming Language along with several extensions for […add specials why it’s cool for schemers and advanced projects]. … <wingo>guile isn't used in the gimp fwiw <wingo>oddly enough they have their own scheme implementation (!) <nalaginrut>and I fixed a buffer overflow with tinyScheme GIMP uses, which may cause something cool for crackers... <wingo>not a whole lot of apps unfortunately <Arne`>TeXmacs, LilyPond, and GnuCash. <wingo>lilypond, texmacs, autogen, gnucash, gnu make <wingo>i wonder if the make guile integration is on by default <nalaginrut>wingo: bingo, that's why many guys want to run Guile2 on hurd <Arne`>guix isn’t that well known outside GNU yet… <wingo>it's ok to give guix some publicity :) <wingo>tbh the "which apps use guile" story is a bit weak, weaker than guile itself <Arne`>Guix does not seem to have a Wikipedia page yet. <ijp>and guile doesn't have an accurate one, such is life <nalaginrut>Arne`: we'd better avoid speak too much for "which apps use guile" story <Arne`>nalaginrut: That story is essential for reaching people who want to extend their project - and a major part of the documentation of guile seems to be about that. <Arne`>I’d just name GNU Cash and Lilypond. <Arne`>Lilypond is the defacto-standard for engraving notes <nalaginrut>Arne`: there's an ancient Chinese phrase, avoid solid and hit the weak <ijp>I prefer the ancient scottish phrase "go for the balls" <Arne`>if you want to market to people, you have to be sure that you can deliver. <Arne`>if you fail to deliver, that will stick. <ijp>I think Guile, of all projects, is acutely aware of that <Arne`>ijp: I did something similar to this for the Hurd. Same problem (weak PR). Same effect (vapor) <Arne`>nalaginrut: We have to show them where Guile already did deliver. <Arne`>nalaginrut: *Then* we can lead them onwards to new features. First create strong base, then use it to launch. <Arne`>So for everyone for whom Guile would be a good choice, we need one strong story. <Arne`>Lilypond is one of these (but it also supports Python it seems). <ijp>the time spent on PR could be spent on code, and it would have probably the same effect <Arne`>ijp: Not if the PR is so much more horrible. <ijp>I think you're trying very hard to avoid a no-true-PR fallacy <wingo>we can have a good story but stories don't tell themselves <Arne`>ijp: The response of people to a project is a function of PR and Quality. If the PR is OK, good quality helps. If quality is OK, good PR helps. If PR is bad, no amount of quality can offset that. And if quality (for the user!) is bad, no amount of PR can keep people there forever (legal methods are a different matter, though). <wingo>especially given the horrible current wikipedia page -- it's both incorrect while also being not right <ijp>Arne`: and I think you are mistaken on both accounts <wingo>i.e. it tells things that aren't really true <wingo>and it doesn't tell the story we want to tell <Arne`>ijp: You mean, a project without PR but with good quality will spread? I experienced many examples of the opposite. <Arne`>ijp: Note that PR does not (need to) mean going into all forums and shouting “we are great, use us!” <Arne`>ijp: The very basic PR means ensuring that people who look for your project find the strengths of your project which are relevant to them. <ijp>taylanub: I believe you are misusing "obligations" <Arne`>ijp: Currently Guile fails at meantioning quite a few of its strengths and for some of them this could be fixed with little effort. <Arne`>taylanub: The beginning of the intro sounds better, but I think it is too densely packed. <nalaginrut> "with good quality will spread" is totally wrong nowadays, we need plan and advertise <Arne`>taylanub: are you in the WP article right now or can I edit? <taylanub>I do believe the mention of the compiler tower deserves early mention, it's quite a central point of Guile 2.0 I believe and a Guile 3.0 that removes it again is not in sight. :P <taylanub>Arne`: in "replacing Emacs's Emacs Lisp implementation with libguile", I think it should be changed to "with libguile's implementation of it" or so to prevent the old confusion that we're trying to replace Elisp, you can do it if you want or I can after you're done. <nalaginrut>well, if so, what will be provided by Guile-3.0, a lightning AOT compiler faster than ASM? <ijp>there is no plan for a guile 3.0 <ijp>please don't get ahead of yourselves <nalaginrut>Arne`: a notable feature is, with multi-langs of guile, users may write plugins with any languages for guile-emacs , in principle <ijp>so you want a web interface? <ijp>that could be arranged <ijp>first things first, we should sort out the 'quit' situation <Arne`>taylanub: I reworked the intro a bit. It still needs massive shortening, but it shoul dbe more readable now. <ijp>remember your citations <ijp>aidalgol: I've added a quit hook, and a quit command, but I'm loath to commit the latter since it's not something that should really be public <ijp>at least until we have some sort of "owner commands" <aidalgol>ijp: That's why we have non-command functions to call from the REPL. <ijp>but quit-irc won't stop the bot <ijp>well, maybe incidentally <ijp>okay, that does seem to work <taylanub>Arne`: I think the phrases "a complete implementation of Scheme" and "additional to the Scheme standard" are a bit problematic because the standards are a mess and R5RS is the only thing we support fully AFAIK. <ijp>aidalgol: I'll push a patch to add a quit hook later <taylanub>My co-workers are discussing whether to make the intern start learning programming with JavaScript or with PHP. *sigh* <ijp>why did you accept an intern that couldn't program? <taylanub>Maybe the German internship system is different than what you're used to, we often take interns as young as 15 years old and teach them stuff. <taylanub>Well that's 2-week school-supplementing internships, and then there's different kinds. <ijp>ah, "work experience" <taylanub>Poisoning such young brains with PHP. :( <taylanub>Ah well, it's not like I was much better, having started with the Bourne shell. <nalaginrut>take it easy, they could change work not to program easier, with PHP based <civodul>wingo: at the GHM José said: "Guix could become the MLDonkey of Guile" ;-) <ijp>I started with a microcontroller BASIC <ijp>and I'm sure we all remember what Dijkstra said about BASIC <nalaginrut>ijp: are you interested on a microcontroller Scheme? <wingo>the wikipedia intro is looking much nicer <taylanub>I think I'll change "the Scheme standard" to "large parts of standard Scheme" for lack of a more precise phrase that's correct and concise. Tell me if you think that sounds bad. <ijp>ijpbot: log this is a test <nalaginrut>"come to use Guile~it's free" oh, freight in full?" *nalaginrut 's last joke before go home... <ijp>ijpbot: log this is a test <ijpbot>Command return value not a string. <ijp>ijpbot: log this is a test <taylanub>I can't wrap my head around the sentence "libguile allows the language to be embedded in other programs, and used as an interface for other languages which allow close integration through the C API" <nalaginrut>hmm...so python could have libguile binding named python-guile <taylanub>I don't think that's what it's meant to say; and even if so, it's way too specific. <taylanub>I'll just change it to "libguile allows the language to be embedded in other programs, and integrated closely through the C API", it is just supposed to explain embedding after all <Arne`>I did not actually change every sentence, but started with the most unclear parts. <Arne`>taylanub: For example I think that the second paragraph should note far fewer features, but instead reference an extra section in the article: Guile Scheme. <Arne`>taylanub: And you might notice that I just copied the general purpose part from python :) <nalaginrut>Arne`: oh, that's the story of "general language" <Arne`>which was intentional: Scheme is actually better at line-of-code reduction than python <taylanub>I thought the wording there might not be suitable for Wikipedia, then checked pages of other languages, and coincidentally Python first. :P *nalaginrut wonder if "general language" is proper for Guile <Arne`>Guile Scheme is a general language. <Arne`>that part is explicitely about “Guile Scheme” <taylanub>"general-purpose, high-level programming language" could even be said for C actually. <nalaginrut>though it is a general language, the original selling point is extension language <Arne`>I was doubtful whether high-level actually fits: How much direct memory access does guile grant? <taylanub>(Platform-neutrality was the original definition of "high level" I believe.) <Arne`>so nowadays it just says “it’s not assembler”? <Arne`>“Examples of high-level programming languages include FOCUS, Lisp, Perl, Python, and SAS.” → so we’re safe <nalaginrut>well for it is a platform, it contains assembler... <taylanub>Arne`: Not nowadays but initially, I think, and only later people started to distinguish non-assembly languages as more/less low-level/high-level. I could be wrong, not very old myself. :) <taylanub>Arne`: After this revamp of the intro, I do believe the mention of 2.0's features is redundant there; it belongs in History only. <taylanub>If you're making changes ATM I'll wait .. <taylanub>.oO( Wikip needs collaborative editing. :P ) <taylanub>Although I know at least two Guile users who dislike it, or at least its current state. <Arne`>taylanub: I saved, your turn :) *Arne` wishes we’d have rudel mode active for this. <Arne`>I’m very unsure about this part: “Additional to large parts of standard Scheme, Guile Scheme includes modularized extensions commonly needed for system programming and interfacing with special purpose C code.” <Arne`>can you provide a better (short) explanation of the purposes of the Guile-specific extensions? <Arne`>The Guile Scheme section is just a copy of the intro <Arne`>This needs some “scheme is cool” spiceup :) <taylanub>Is this kind of duplication common on Wikip, or should I look for a way to work around it ? <Arne`>We should fix it, for example by taking inspiration from the scheme article <Arne`>Also someone in the know might want to add a section “other languages supported by Guile” <taylanub>Currently no other language's implementation is complete so I'm not sure if that's a good idea. <taylanub>(Here I use "complete" in the "complete in its own right" sense, not a standard. :P) <Arne`>I though emacs lisp could run emacs <taylanub>Guile Emacs so far continued to use mostly Emacs's own Elisp, only putting libguile on the side; bipt mentioned just yesterday though that the following weekend ey might properly replace it with libguile. <nalaginrut>for market purpose, you know, companies won't claims things after the product is perfect. <taylanub>(Some fundamental features were missing in Guile's Elisp despite that it apparently run non-trivial Elisp programs like dunnet.) <Arne`>taylanub: I think we could add Emacs Lisp as soon as it runs Emacs (even if there still are some bugs)… <nalaginrut>anyway, we have JS and brainfuck and elisp, it's the truth, no matter it's done <Arne`>Notable stuff about GUile Scheme: Unicode: (define ℂ⇒ℵ 1)(display ℂ⇒ℵ) ← actually works! <Arne`>Is there a limit to the Unicode Charakters Guile Scheme supports? <Arne`>(define ℂ⇒ℵ "math") (define ᚠ "fehu") (define ᚘ "ifin") (define 亂 "chaos") (define グ "gu") <wingo>i believe we are up to unicode 6.2 at this point <Arne`>(define グ "gu") (define ぃ "i") (define ᛚ "l") (define ε "e") (display (list グ ぃ ᛚ ε)) <ijp>I'm not even going to get started on how wrong that is <Arne`>(format #f "~a~a~a~a" グ ぃ ᛚ ε) <Arne`>(and actually useful, think of transforming math into code) *Arne` hopes that you all see most of the symbols :) *Arne` wrote some code using φ, λ, α and a few other symbols. That made it much easier to keep the (somewhat more complex) equation and the code in sync. <Arne`>I could not publish that, though, because the minted latex package did not support the symbols… <taylanub>Is our R5RS implementation fully complete, or 99% ? <Arne`>taylanub: are you editing the article right now? <taylanub>(That "or" was not meant as in "one or either", I'll also consider it "full" even if it's just 99%.) *Arne` will keep the hands off it, then :) <Arne`>The intro also needs a short-list of projects using guile - with an anchor to [[#Programs_using_Guile]]. <Arne`>mcron is written in guile? — and there I always wondered which distinctive feature if offers… <Arne`>wingo: I now wrote the readline-systemwide bug, too. <Arne`>wingo: simple way to improve the website: On the starting page add a pointer to a fitting resource after each section. <Arne`>“Guile is a programming language\\n…\\n → Learn using Guile” <Arne`>“Guile is an extension language platform\\n…\\n → Learn how add guile scripting to your program” <Arne`>then I’d like to add a patch in human language w: <wingo>that's fine, send them in mails to bug-guile@gnu.org <wingo>the hard part isn't the formatting so much as getting the words right <ijp>while we are on the subject of the site, did we add a note about the ideas page being vastly out of date <Arne`>the guide on guile scripting is quite hard to read… <wingo>is that in the manual or the web site? <wingo>we should check the web site into git and add some makefilery that handles committing it to cvs <Arne`>the manual — well, so be it… <wingo>what do you mean "so be it"? <Arne`>with so be it I mean that this isn’t as easy to change as the front-page <Arne`>less “return of investment” :) <wingo>heh, for me it is the opposite :) <wingo>the manual is very easy to fix, you can edit the lovely texinfo files, make, and check out the changes directly *taylanub did another set of improvements to the Wikip page. <Arne`>taylanub: That looks much better than my version - great! <taylanub>Looking at it now, I agree we should probably add an "other languages" section parallel to "Guile Scheme", because other languages are only implied here and there and their implementation only really explained under History. <taylanub>We might also mention Geiser, because why not .. I'm looking at Racket's page and it's very thorough. <taylanub>Also, the "programs using Guile" list is kind of bothering me .. ideally that list would be too long to include in the article. ;P <taylanub>I think the main reason it stings to my eye negatively is that it takes so much vertical space for so little "real" content, though. <Arne`>to achieve that, more developers have to find Guile and stick to it, and at least for the first part, Guile has to look attractive enough that they invest the time to check its quality :) <Arne`>I’d just keep that in there. <Arne`>Better make the rest of the article longer :) <Arne`>I polished the intro a bit more and moved the “core idea” part into the Guile Scheme section. <Arne`>wingo: there’s a bug in my bug report (Learn how use guile ← missing to) shall I file a followup or is it enough to report it here? <wingo>Arne`: reply to the message please <Arne`>to the 15223@debbugs.gnu.org, right? <Arne`>seeing how much changed today, I’m quite happy how it turned out :) <taylanub>Arne`: If you're not making a change ATM I'm making a change to section Guile Scheme. *ijp sings the "psyntax is compiling" song <wingo>that's a song that has been getting longer and longer lately <taylanub>Arne`: OK, reordered paragraphs/sentences in Guile Scheme section somewhat, to be more natural. ("Core idea" shouldn't come last.) <wingo>it's spelled "GnuCash", not "Gnu Cash" <Arne`>Let’s take one step back: Did we include information for all the potential user-groups? (1) Schemers: Yepp (it’s scheme and there’s a section on Guile Scheme), (2) Extenders: Yepp (libguile), (3) Learners: Not yet. We might need a syntax-section with some examples. Also the interpreter should get a notice. (4) Project-Starters: Partly in the “core idea”-part in the section Guile Scheme. It might need one more paragraph showing <Arne`>advantages of the language. (5) 1337s: It is the preferred extension system for the GNU Project. If you’re not that kind of 1337: The Macro-System might profit from getting the “hygienic” attribute :). (6) Emacs users: They got their own section. <Arne`>(4) not advantages of the language, but advantages of Guile which make it especially suited for that. <Arne`>(6) Macros → hygienic Macros <taylanub>Arne`: I think examples for learners wouldn't be appropriate because the syntax is just Schee with slight differences. <Arne`>The interpreter with integrated debugger would be part of that <taylanub>Hrm, Wikipedia discourages "howto-like" content. <taylanub>Remember that it's Wikipedia after all; we started with the intent of removing negative tone, but not turning it into an advertisement. :) <Arne`>taylanub: maybe an extra syntax section which mostly references Scheme <Arne`>it’s not like there’s anything in there which isn’t actually an advantage <wingo>"Macro-System" -> "macro system" <ijp>also remember, just because you put it up, it doesn't mean the wikipedia mods are going to keep it <Arne`>ijp: which is why this must be *useful to WP readers* <ijp>so, keep you'll need an eye on it for a few days <Arne`>ijp: sadly yes… I was part of the dmw war… <Arne`>ijp: Luckily I had already actively used my account for a few years, so they failed in calling me a meatpuppet… though they tried. ***cmatei_ is now known as cmatei
<stis>hey guilers! (and joining in with dsmith), Happy Friday <davexunit>early release at work today for labor day weekend! <shanecelis>I'm using a library that uses threads, that I'm trying write some wrappers for. Can I invoke scm_init_guile() multiple times? <taylanub>It's false that Guile originated from the Tcl wars, right ? Should probably change that on Wikipedia ... <mark_weaver>maybe wait for someone knowledgable with the history to chime in? <taylanub>It's much more detailed than Wikipedia, and quite different .. I'll need to make a bigger rewrite on Wikipedia. Will see how I can sum it up. I'll do this later then, feel free to steal the work while I'm away. :P <stis>Hmm, rtl loops are 30% faster, ,x looks compact :-) <stis>one could skip 3 out of 7 instructions though. <mark_weaver>stis: yes, there are a lot of redundant moves. we need a smarter register allocator. <stis>that + loading constants only once <stis>maybe that's the same thing :-) <mark_weaver>there's a list of needed passes in language/cps/compile-rtl.scm <stis>btw, i'm wondering if we should start wotking on supporting promopt so good that <stis>1. lisp tagbody get's an efficient implementation in guile scheme. <mark_weaver>(andy mostly did it, but there are some bugs and maybe little missing bits) <stis>2. generators and such tool can get an efficient implementation as well. <mark_weaver>lisp tagbody should be well covered by the contification pass. <mark_weaver>regarding generators, I'm not sure what you had in mind, but we'll have to talk about that later. <stis>is it the right time to take on this discussion? <stis>or should we wait for the basics to be ready? <stis>ok! I'll write to the list! at worst case I'll just move some electrons <mark_weaver>if it's similiar to the different prompt semantics you were suggesting a few months ago, I dunno. <stis>it is! it's a generalisation of tagbody compilation that can be effective due to rtl <shanecelis>I mean, it isn't going to replace a mouse, but if you're doing anything in 3D, it could be really cool. <taylanub>As someone who doesn't even use a mouse, imagine how impressed I am. :P <taylanub>Sounds like they made something that could greatly ease the life of 3D modellers, but the rest seems like overly-hyper marketing. *taylanub enters grumpy-old-man mode ***ijp` is now known as ijp
<shanecelis>taylanub: Understood. I'm working with a 3D environment, so the idea of actually being able to specify 6 degrees of freedom with one finger instead of contorting 2D mouse input sounds pretty awesome. <shanecelis>So I've got this leap motion thing working with guile and I'm driving a camera around a scene. <shanecelis>It's really cool! Then I start getting garbage collector hiccups. <mark_weaver>maybe try setting the GC_ENABLE_INCREMENTAL environment variable? <didi>Trivia: In the 4.4 exercise from SICP, it's asked to expand a `or' and `and' expression into a derived one. How would you do it? I can't actually think of any way of doing it using the tools given so far. <shanecelis>mark_weaver: Wow. I come here with these problems that I expect there to be no quick solution to and *BAM*, you tell me exactly how to fix it. <didi>I couldn't find any implementation of it on the web too. <ijp>didi: it's not a macro, you're to add it to eval <didi>ijp: You have to transform the list. <ijp>so what's the problem? <didi>ijp: I can't think of a way to transform the list and respect the `or' and `and' syntax. <ijp>didi: how would you write them as a macro? <mark_weaver>didi: what if I asked you to write a procedure that takes one argument, a list, which should return the first value in the last that's not #f ? <didi>ijp: I don't know how to write macros, I'm afraid. <ijp>didi: it's no different than any other list manipulation <didi>Really. The problem lies in returning a value. <didi>(or x y) is not #t, but x or y. <ijp>and what is the scheme form you use when you want to evaluate a value once, and use it multiple times? <taylanub>Revamped the history section on Wikipedia. <didi>ijp: Ah. We are getting there. <didi>ijp: What about free variables? <taylanub>It lacks citations for some specific claims because most of the content is taken from the Guile manual .. I hope Wikip moderators won't be angry. <davexunit>shanecelis: incremental GC stopped the stutters? <ijp>didi: you can take advantage of the evaluators variables not being the same as the evaluated expresions variables <ijp>(let ((tmp (eval x env))) (if tmp tmp (eval y env))) <taylanub>davexunit: You never tried it before ? (Honestly I didn't know of that environment variable either, though.) <davexunit>I heard about it, but didn't really understand the benefit that I could get. <didi>(let ((temp 42)) (or 7 temp)) <mark_weaver>davexunit: the idea is that it does some GC work every time you allocate, so by the time you run out of memory, there's much less work to do. <didi>ijp: Control your anger, please. <taylanub>From what I know, incremental garbage collection means that the collector follows a strategy that allows it to be interrupted during a mark or sweep cycle, and let the program continue, then pause again and continue from where it left ... <ijp>didi: a sigh is not an expression of anger, but one of exasperation <davexunit>mark_weaver: hmmm. I will have to try it out. <davexunit>can I put the GC into incremental mode via a procedure call? <mark_weaver>it's probably less efficient overall (i.e. more time is spent in GC), but it's more evenly spread out into little bits, instead of one big hiccup. <ijp>the way I showed above is how you do it _not_ as a derived expression <mark_weaver>I can't say for sure how well it will work, but it's worth a try. <ijp>to do it as a derived expression, requires an extra layer of indirection <taylanub>(Well apparently I was following the definition given by Wikipedia; I suppose BDW-GC doesn't follow that definition.) <didi>ijp: Well, I'm interested in knowing how to do it. <ijp>think about it another way, how would you do it as a procedure <ijp>well, setting aside that 'or' isn't a procedure, you want to delay evaluation, so you'd use thunks <ijp>something like (or* (lambda () x) (lambda () y)) <ijp>now, that seems like extra work, but now any variables in or* are private <ijp>so the procedure or* can be (define (or* x-thunk y-thunk) (let ((tmp (x-thunk))) (if tmp tmp (y-thunk)))) <ijp>of course, you can just expand into an applied lambda directly <ijp>(or x y) -> (or* (lambda () x) (lambda () y)) -> ((lambda (x-thunk y-thunk) (let ((tmp (x-thunk))) (if tmp tmp (y-thunk)))) (lambda () x) (lambda () y)) <ijp>so, that's both methods covered. <didi>OK, I'll have to sit and think about it. Thank you, ijp. <ijp>I get there eventually, I just like to choose my route <ijp>incidentally, this is the exact trick used in the rabbit compiler <davexunit>mark_weaver: I can't really notice a difference with the incremental GC. at least not on this laptop. <davexunit>I'm using an old intel GMA graphics chip and my performance is always so all over the place. <davexunit>maybe I'll try it on a machine that I can get more consistent results on. *davexunit needs to get a new laptop. maybe a used thinkpad. ***shader` is now known as shader