IRC channel logs

<youlysses>This convo was awhile ago -- but what's the deal with Guile and SDL2? Are the binding being or planned to be rewritten, or just being left as-is for now?

<davexunit>happy caturday, guilers.

<davexunit>I'm trying to brainstorm some ways in which I can create a declarative way to define how a game functions in guile-2d.

<davexunit>a game scene has state and render/update/keydown/keyup/etc callbacks.

<davexunit>right now, guile-2d is too procedural in this regard.

<taylanub>davexunit: Do you know of "reactive programming" ?

<taylanub>Or "functional reactive programming", FRP, is the full name I think.

<ijp>on the game level, it's a bit more obvious, since you have a state machine with states corresponding to scenes. Within a scene seems more problematic.

<davexunit>ijp: yeah

<davexunit>I guess I'm looking for a way to describe a scene in a nice way.

<davexunit>a scene would have a name, render/update/key input procedures, and some state

<davexunit>some kind of define-scene macro.

<davexunit>taylanub: I have heard of it, but I don't know anything about it.

<davexunit>I saw the DSL that guix provides for describing packages and I think it's fantastic.

<taylanub>If I got it right, FRP is similar to the "constraints system" used in 3.3.5 of SICP. The basic idea is that you define some relations between objects' state such that mutating any one object will induce a chain reaction that also updates all other related objects.

<davexunit>taylanub: hmm, I should look into that.

<taylanub>I recently heard of it a lot in #iphonedev since it's a paradigm that lends itself well for GUI programming, and I think you could benefit from it too.

<ijp>which you say, even though you didn't have any idea what it is

<davexunit>time to do some learning.

<taylanub>ijp: I tend to rely on my intuition a lot. :P

<ijp>good thing computers understand what you mean, right??

<taylanub>Explaining it to them is the boring part!

<taylanub>That's why I like Lisp so much .. more thoughts, less typing. :P

*ijp loads his ld50 and ODs taylanub.

<ijp>I have no idea what that one refers to, but meh

<taylanub>Apparently lethal-dose-50% is the dose required of a material to kill 50% of a population under test conditions.

<ijp>taylanub: I don't consider myself to be the world's greatest judge of character, but somehow I saw the #emacs kerfuffle 25 minutes ago, and no-one else did

<taylanub>Excuse me ?

<ijp>spot the statistical fallacy

<taylanub>I'll look up "kerfuffle" first of all.

<taylanub>Ah, I see what you mean.

<taylanub>The statistical fallacy ? That you conclude that no one else did ?

<ijp>well, basically, I can only observe the people that did actually respond. Not the sensible ones who stayed quiet.

<davexunit>taylanub: I found a language called Elm that describes FRP: http://elm-lang.org/learn/What-is-FRP.elm

<davexunit>I think this kind of thing is exactly what I want to implement

<davexunit>it will keep me out of callback hell for sure.

<taylanub>ijp: Eat that!

<taylanub>:D

<ijp>tastes like chicken

<taylanub>Hmm, I had Asian chicken stuff yesterday, it always makes me wonder how they can cook it *so* soft.

<taylanub>And why the rest of the world didn't adopt that style of preparing chicken.

<davexunit>taylanub: also found this http://christophermeiklejohn.com/frp/javascript/clojurescript/2013/06/13/functional-reactive-programming.html

<davexunit>I do web dev as my day job and the video gives examples in JS

<taylanub>.oO( Wow, so many 1-3 letter words. )

<didi>ijp: Thank you for the Rabbit reference. call-by-name is brilliant.

<davexunit>I'm curious as to how some of these JS FRP libraries work.

<davexunit>you can do something like: var foo = Mouse.position

<davexunit>and when Mouse.position changes, somehow the variable foo changes as well?

<taylanub>I don't think one can change variable-declaration and assignment semantics in JS so it probably requires the binding to be made explicitly and the usage of an alternative assignment function.

<davexunit>yeah, I'm a bit confused as to how it works.

<ijp>davexunit: I expect Mouse.position is an object?

<davexunit>surely, in Scheme, we could make something like this work? (define foo (mouse-position))

<davexunit>and foo would yield the current mouse position as a pair or something.

<davexunit>and somehow the variable reference would be automatically updated so that we can treat foo as a regular variable?

<taylanub>One could do it with mutation but it would probably be cleaner if the retrieval of a value were through a procedure call. Either like parameters, where the parameter itself is a procedure, or through a `value-of' procedure that takes such an object.

<davexunit>there will be mutation *somewhere*

<davexunit>somewhere the current value of the mouse pointer would need to be stored.

<davexunit>do have some psuedo-scheme that this would look like?

<taylanub>SICP has actual Scheme of it. :P

<taylanub> http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-22.html#%_sec_3.3.5

<ijp>the constraint solver is not really the same thing

<taylanub>I'm trying to find out differences ...

<ijp>for a start, it works in multiple directions

<taylanub>Does this one disallow auto-mutation of a cell that was explicitly given a value ?

<ijp>reactive programming is more like an extension of streams

<davexunit>so I suppose I should learn how streams work first?

<ijp>davexunit: you've used pipes before?

<ijp>same idea

<davexunit>oh okay.

*davexunit goes to read the stream docs

<didi>Is it possible to always ,pretty-print?

<ijp>it should be possible, but I don't know if it's easy

<ijp>hmmm

<ijp>this is sort of what the 'print' option does, but you can't just pass in pretty-print, since it expects different arguments

<ijp>try (use-modules (ice-9 pretty-print)) (define (pp repl val) (pretty-print val)) then ,option print pp

<ijp>might need a call to newline in pp

<didi>While executing meta-command: ERROR: unknown repl option print

<ijp>what version are you using?

<didi>2.0.7

<ijp>that might be a 2.0.9 addition

<didi>Ah.

<didi>Oh well.

<ijp>hmm, yes, it is

<ijp>it's probably still possible, just with more hoop jumping

<didi>Nah, that's fine. Thanks.

<ijp>hmm, I'm not sure you can put that behavior in your .guile though, since the repl isn't started until after your .guile is evaluated

<ijp>at least, I think

<ijp>(ice-9 command-line) confirms

***sneek_ is now known as sneek

<sjoerd`>Guys, i just attempted a rebuild of 6871327, and got a nasty error guile: uncaught throw to misc-error: (load-thunk-from-memory expected p_filesz == p_memsz () #f)

<sjoerd`>Anyone aware of this?

<davexunit>has anyone worked with http://elm-lang.org before?

<youlysses>davexunit: Nope, looks pretty cool though.

<youlysses>I lived in St.Louis for 20 years and I'm probably moving back after I graduate ... but I never heard of "strangeloop" -- ironically, quite quuer. :%U

<davexunit>youlysses: I'm trying to bring some functional reactive stuff to guile.

<youlysses>davexunit: Ah, yeah -- that would be pretty cool. :^)

<davexunit>I feel like I could get a naive version of it working.

<davexunit>I'm currently trying to learn how to use streams

<davexunit>and what exactly they are for.

<ijp>someone, I forget who, did something that was supposedly frp a while back (maybe jan), but I didn't really understand what made it frp

<davexunit>ah.

<ijp>good thing I have this great memory, eh?

<davexunit>would a use case of a stream be something like representing an infinite series?

<ijp>well, yes

<ijp>for instance, I have infinite streams of primes and rationals

<ijp> https://github.com/ijp/ijputils/blob/master/streams.sls

<davexunit>you mentioned using streams as the basis for frp, and I think it makes sense.

<davexunit>very cool, ijp

<ijp>the rationals implementation makes very little sense if you haven't read the paper

<davexunit>yeah that is over my head

<davexunit>I'm just looking at the use of streams in general.

<davexunit>fibonaccis is cool

<davexunit>very interesting compared to an iterative version that computes the first n fibonacci numbers.

<ijp>the in-crowd call it “corecursive”

<davexunit>oh. neat.

<davexunit>so much to learn.

<ijp>well, streams is just applying the notion of lazy evaluation to the creation of data

<sjoerd`>corecursive, nice word

***linas__ is now known as linas_

<ijp>you may not want it all, and it might be expensive to compute, so should only evaluate what is necessary

<davexunit>ijp: yeah. figuring out how to apply that to say: mouse cursor updates

<sjoerd`>ijp: could you help me with the question posted about 1.5 hours ago?

<ijp>davexunit: I think the best thing to do would be to play with the existing ones in elm (as you saw) and haskell, and asking on the relevant irc channels

<ijp>a simple event stream for mouse movement is probably simple enough, but when you start adding in user events and so on, I imagine it gets really complex

<davexunit>ijp: sure.

<davexunit>thanks.

<ijp>sjoerd`: is that master or stable?

<davexunit>I feel like if I can get something like mouse/key input then I will be well on my way.

<ijp>if it's master, I'd need to do a rebuild

<davexunit>unfortunately I don't know haskell so reading the syntax is a bit tough.

<sjoerd`>ijp: hang on

<ijp>I see it, top of master

<sjoerd`>it's the master branch, for sure

<sjoerd`>The error appears to happen (at least on my parabola system) at attemting to run guilec on a certain .scm file

*ijp groans

<sjoerd`>ijp: specifically psyntax-pp.scm