IRC channel logs


back to list of logs

***janneke1 is now known as janneke_
<dsmith>Happy Fathers day, Guilers
*dsmith of is off to CA for a week.
<civodul>Hello Guilers!
<wingo>heya civodul :)
<civodul>i've gone over the MinGW patches
<civodul>wingo: "Reduce call-with-values to let for singly-valued producers" should be applicable in stable-2.0, no?
<wingo>civodul: perhaps yes, but i introduced it specifically to reduce a dynwind case that we don't see in 2.0
<civodul>ah, ok
<wingo>civodul: it would be fine to port but i am trying to focus a bit more :)
<janneke_>I'm using the webserver from, are there better choices?
<janneke_>It seems to work okay, but I just posted a link to my demo, got 40 users, and it fails somewhere
<janneke_>Just goes unresponsive, nothing in the logs....
<janneke_>Here's the demo itself (a couple more users won't hurt ;-)
<civodul>janneke_: works for me! :-)
<civodul>though i fail to write something
<add^_>civodul: could you repeat the idea ijp had about the scheme->js thingy? I can't really find a log to see what it was..
<civodul>add^_: he just mentioned that an idea would be to write an interpreter for Guile's bytecode in JS
<civodul>so you would compile your .go somewhere, and run it anywhere
<civodul>hmm, that rings a bell
<civodul>"write once, run everywhere"
<civodul>something like that
<add^_>Sounds like java
<civodul>Java is so avant-garde
<civodul>no but seriously, that sounds like a good plan
<wingo>janneke: the web server is pretty ok afaik but it's synchronous
<wingo>i serve thousands of reqs/s from mine, but if you block somewhere that will slow down
<wingo>we need some way to do async responses; i have some works in progress but nothing solid
<janneke_>wingo: ok; yeah i need epoll to do schikkers right so i was wondering about the state of your new server
<wingo>there is a wip epoll branch but it uses a parallel implementation of ports
<janneke_>wingo: in any of the branches other than stable-2.0
<wingo>i didn't merge it because ideally scheme ports would be directly usable
<wingo>i believe that is wip-ethreads
<wingo>in my deployment, i deploy behind apache, which is something i've been meaning to do away with but haven't had the time
<wingo>because my site still runs a python app...
<janneke_>wingo: hehe; i use apache for all static content and then CORS directly to the guile webserver
<janneke_>thanks for the feedback, it seems i just need to do some more debugging/tracing then :-)
<wingo>janneke: depending on the urgency you might want to set up guile as a proxy behind apache
<wingo> has some info on how i do it
<janneke_>wingo: okay thanks. i'm still in the demo phase, so i hope there's no urgency
<janneke_>[did i say that?]
<janneke_>i'd like to run (gtk-main) without DISPLAY etc, etc :-)
<janneke_>but i'm amazed by the power of guile/goops/guile-gnome
<janneke_>oh, i'd also like to run guile in the browser, client side, or translate guile->javascript?
<add^_>janneke_: agreed ;-)
<janneke_>what's funny?
<fbs>add^_: how about .go -> jvm :p
<add^_>We were just talking about guile->javascript :-)
<add^_>Well, mentioning.
<janneke_>add^_: pure coincidence
<add^_>but it was funny :-)
<janneke_>i had been googling for cookie handling in guile and someone asked about that here the next day
<janneke_>couple of months ago
<janneke_>yes, i moved from python, which is reasonably nice, to guile
<janneke_>even though gnome support is not always, ahum, tracking the latest upstream gtk+3.x
<janneke_>and then i decide on a html5 frontend too, and take the fall all the way down to javascript aaahhhhhhh.
<add^_>Hm, I wonder what part of the manual I should look at to learn about Guile's bytecode thingies..
<fbs> the source
<add^_>9.4.6 perhaps..
<fbs>there is one chapter about internals
<add^_>Yeah, found it (in the huge, load-it-all-in-one-page-manual)
<fbs>get ur pdf copy now
<add^_>So, basically I have to learn JS to write this thing?
<fbs>well that would be easy
<add^_>the js can read .go stuff?
<fbs>only if you make it
<add^_>I should have included a couple of "'s
<add^_>what would be easy?
<fbs>does it have to?
<fbs>is there a way to dump .go files in a readable form?
*add^_ sighs
<add^_>I don't understand what your talking about
<fbs>you want some js magic that reads .go files right?
<add^_>"he just mentioned that an idea would be to write an interpreter for Guile's bytecode in JS"
<fbs>if you want that youre going to need some JS that can read the .go files containing the bytecode and execute that
<janneke_>isn't interpreting guile in js just the opposite of what we're doing with emacs?
<janneke_>processing elisp with guile?
*fbs gone
<add^_>Ah well...
<civodul>janneke_: well, we could tell Mozilla, Google, and the likes, to go ahead and use Guile in their browsers
<civodul>but that seems somewhat unlikely ;-)
<civodul>so people have been writing scheme‚Üíjs compilers
<janneke_>civodul: well, if guile interprets js twice as fast, it would become more likely?
<davexunit>guile would need to beat v8
<janneke_>civodul: if scheme->js proves to be faster,
<sneek>Welcome back davexunit, you have 1 message.
<sneek>davexunit, add^_ says: I just realized that what you are making is what I was planning on making, so I guess I wont work on the exact same thing.. Too bad for me :-P
<davexunit>add^_: referring to guile-2d?
<janneke_>davexunit: in this universe, it's: have a challenge or be dead, isn't it?
<janneke_>sneek: why not collaborate? much more fun!
<civodul>janneke_: wingo could tell you what it would take for Guile to compete with v8 ;-)
<wingo>i think it would take about 10 million dollars :)
<janneke_>in my humble experience, love goes much further than $$$
<davexunit>there's so much more man power behind v8
<davexunit>wingo can only give us so much. :P
<janneke_>yes, but is there more <3 <3 <3 behind v8?
<wingo>but simply having full-time hackers would speed things up -- and there are few people that can contribute effectively
<wingo>davexunit: i work on v8 at $dayjob :)
<janneke_>who's opening a v9 branch?
<davexunit>wingo: I inferred that from your blog. :)
<wingo>heh, ok :)
<janneke_>wingo: great, one sabotteur can bring a whole project down
<wingo>janneke: i had a pretty good week in that regard last week
<wingo>most reported chrome crasher, subtle gc bugs, etc... :)
<janneke_>wingo: or, show that guile is faster and hack guile for a $dayjob
<janneke_>so wingo's also been taken by the vortex then? aww man
<wingo>i don't work for google if that is the question
<janneke_>wingo: phew...yes that was my question. now /me is confused
<wingo>the company i work for does contract work, and we found some work around v8. it's been really nice to hack with such experienced vm engineers :)
<janneke_>wingo isn't paid/employed by google and still improves their code...
<janneke_>wingo: ah, great
<add^_>davexunit: indeed
<davexunit>add^_: feel free to help :)
*janneke_ feels so happy seeing people doing all that nasty mingw work for me, and doing it the right way(TM)
*davexunit is trying to learn how to batch draw sprites for guile-2d
<add^_>batch draw?
<janneke_>davexunit: on what canvasL
<davexunit>add^_: batch draw as in efficiently draw thousands of sprites per frame.
<janneke_>davexunit: we used to do that in assembly :-)
<janneke_>well, tens of sprites per frame, but that was in the 80's
<davexunit>I'm not good at opengl stuff that doesn't involve immediate mode.
<davexunit>and I'm sure I need more than that in order to write an efficient sprite batch implementation.