00:05:42 -!- Slereah_ has joined.
00:06:11 <Slereah_> I'm on the metamath mailing list?
00:06:33 <Slereah_> I needed to see some old posts.
00:08:19 -!- oklofok has quit (Read error: 113 (No route to host)).
00:10:08 -!- oklopol has joined.
00:15:37 -!- oklofok has joined.
00:16:54 -!- oklopol has quit (Read error: 113 (No route to host)).
01:05:04 -!- timotiis has quit (Read error: 110 (Connection timed out)).
01:18:33 -!- oklopol has joined.
01:18:52 -!- oklofok has quit (Read error: 113 (No route to host)).
01:19:57 -!- tusho has quit.
01:44:56 -!- GreaseMonkey has joined.
01:46:26 -!- Judofyr has quit.
02:06:08 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
02:06:25 -!- oklopol has joined.
02:25:14 -!- Corun has quit ("This computer has gone to sleep").
02:55:20 <psygnisfive> will the evaluator be eager or lazy, for reactance?
02:55:27 <psygnisfive> i think it'd have to be like.. hyper-eager, right?
02:55:59 <oklopol> well, you can have it either way
02:56:03 <psygnisfive> which means no lazy lists or anything like that as data structures
02:56:16 <oklopol> well no, that wouldn't really fit
02:56:36 <oklopol> reactions can be done either laziliy or eagerly
02:56:59 <psygnisfive> any change upstream has to immeditely propogate downstream
02:57:15 <oklopol> when getting the value of y, find all x -> y, get value of x, and set y to that
02:58:01 <psygnisfive> outputting is a reaction like any other :p
02:58:12 <oklopol> you need to get value of y
02:58:51 <oklopol> for printing y, you get the value of y
02:59:15 <psygnisfive> whenever anything upstream changes, it automatically flows downstream
02:59:52 <oklopol> 5 -> x, then find all x -> var, and set all var to x
02:59:55 <psygnisfive> thats "Establish a reaction between y and the output"
03:00:09 <psygnisfive> there is no "get y and put it into @" there
03:00:12 <oklopol> what exactly is the difference in behavior?
03:00:45 <oklopol> 3 -> x has the side-effect of outputting 3?
03:01:43 <psygnisfive> because there's this established reaction that the value of x flows down into @ at all times when x changes
03:02:05 <psygnisfive> and that change instantly propagates down the reactions into the output
03:02:51 <oklopol> sure i did, but i'm still sure we can view this lazily
03:03:26 <psygnisfive> because anything that outputs anything will need to be pushed immediately
03:04:49 <oklopol> it's just in this case the lazy way is the same
03:04:59 <oklopol> you still need to keep track of the old reactions
03:05:07 <oklopol> and update them every time variables update
03:06:53 <oklopol> y -> @; 3 -> x; x -> y; <<< this demonstrates the difference, but keeps the reverseness; y -> @; is simply stored, because "getting y" is impossible yet, then 3 -> x is stored, then x -> y; now y *can* be "gotten", so y -> @ executes, it gets y, which in turn gets x, which is 3
03:07:06 <oklopol> whereas the eager way would be to... well you know.
03:07:37 <psygnisfive> no, y -> @ wouldnt be stored at all, you'd start outputting "undefined"
03:08:04 <psygnisfive> when you set up x -> y the value of y immediately changes to reflect x and you immediately output 3
03:08:38 <psygnisfive> or whatever the equivalent would be in the language
03:08:53 <oklopol> i'll just make you a lazy version of my interp tomorrow, you're obviously tired
03:09:15 <oklopol> why would it output undefined?
03:09:42 <psygnisfive> when you establish a reaction, values flow from the left of the -> to the right
03:09:45 <oklopol> what is different between the lazy evaluation scheme and the eager one?
03:09:55 <oklopol> what's wrong with doing the same lazily?
03:10:26 <oklopol> y -> @; is a kept reaction, it will be triggered each time y gets a new value
03:10:42 <psygnisfive> it LACKS a value but it has the fact that it lacks a value
03:11:05 <oklopol> and what's different between that, and the lazy way of doing it, where you "can't get the value"?
03:11:06 <psygnisfive> what if i want to see if and when y gets defined?
03:11:17 <psygnisfive> i'd need to first know that it doesnt have a value
03:11:38 <psygnisfive> i mean, sure, perhaps in this one case it might be equivalent
03:11:52 <oklopol> don't give me that conceptual crap, give me an example where they differ
03:12:02 <psygnisfive> the first value change output will always occur are the same time i guess, yes ok.
03:12:25 <psygnisfive> because you're outputting constantly, so all changes will immediately propogate to @
03:12:30 <oklopol> err, if y is redefined later, the reaction is triggered again
03:12:56 <psygnisfive> the reaction immediately propogates from x to everything defined in terms of it
03:13:11 <psygnisfive> which means that changing x immediately has to propogate down to y then to @
03:13:24 <psygnisfive> because @ is sort of "constantly getting" y, which is "constantly getting" x
03:13:49 <oklopol> okay, and here we see how they are the exact same
03:14:08 <oklopol> i didn't say a thing i thought i said
03:14:27 <oklopol> but anyway, you need to trigger (y -> @) when x changes
03:14:49 <oklopol> it is, you only need to trigger outputs
03:15:45 <oklopol> yeah, basically, the trigger system is much less efficient
03:16:04 <oklopol> as you can do anything lazily
03:16:12 <psygnisfive> e.g. when you set a value, go through and find all @'s that depend on that value and then go through those reactions?
03:16:50 <oklopol> well i'm thinking just evaluate all (expr -> @) all the time, this is not about efficiency
03:16:59 <oklopol> it's about being able to do it lazily
03:17:41 <psygnisfive> well, part of the thing is that i can't imagine doing anything that doesn't have an -> @ in it
03:17:52 <psygnisfive> i mean, if you never output anything, then the program is pointless
03:18:07 <oklopol> each time you add a reaction, you evaluate each and every (expr -> @)
03:18:35 <psygnisfive> so "laziness" results in constant updating of @'s, which means constantly pushing values from inputs
03:18:38 <oklopol> "get value of expr and output it, unless no variables have changes"
03:21:12 <psygnisfive> we need to consider things like global objects and functions
03:21:16 <psygnisfive> mouse is going to need to be global. keyboard too.
03:21:20 <oklopol> once you get into inputs, laziness has problems, naturally
03:21:29 <psygnisfive> and i suppose as a global function, delay t v
03:21:48 <psygnisfive> well darlin, theres no reason to do reactive stuff without inputs :P
03:21:54 <oklopol> i'm talking about the simple subset with only (expression -> variable | port) reactions
03:21:58 <psygnisfive> because without it, you're just making haskell :)
03:22:58 <oklopol> well, all they really do is force you to evaluate all outputs all the time, which was in my theoretical implementation plan for making laziness work all along
03:23:16 <oklopol> true, given input, laziness as such makes no sense
03:23:41 <psygnisfive> wait, evaluate all outputs at the same time?
03:24:04 <oklopol> hmm, true, still doesn't work
03:24:15 <oklopol> because inputs that don't actually flow into output yet
03:24:24 <psygnisfive> we also need to define the semantics of delays :)
03:25:16 <oklopol> well i dislike the idea of doing them like that, but shure, shure
03:25:57 <oklopol> anyway, do you believe me in that it is possible to have lazy reactions with the same semantics *given no input*?
03:27:58 <psygnisfive> no, because delays introduce another issue.
03:28:03 <oklopol> for delays, i suggest a port whose values oscillates
03:28:43 <psygnisfive> ok, well then without delays and without input sure, i guess.
03:29:07 <oklopol> good, all i wanted was a nod, and "but that would be so inefficient it's ridiculous to even think about"
03:29:45 <psygnisfive> i think i have an idea for a new esolang, btw
03:30:18 <oklopol> well io is really just a convenience
03:30:36 <oklopol> i don't usually use it except for printing out the result of my computation, in say python
03:30:39 <psygnisfive> it's also the whole point of computation :)
03:31:09 <oklopol> well if you don't have implicit io, as in like a repl
03:31:21 <oklopol> then you have to use debugging to see your results
03:31:40 <psygnisfive> no writing to disk, no communicating to a server, nothing at all.
03:31:51 <oklopol> umm, that's basically all esolangs
03:32:04 <oklopol> stdio is enough for anything
03:32:25 <oklopol> the pipes you lead to your prog and out of it
03:32:33 <oklopol> yeah, that's often the case with an esolang
03:32:44 <oklopol> you just have implicit io then
03:32:52 <oklopol> so the program works as a function
03:33:07 <oklopol> yeah, i did that with nopol
03:33:37 <oklopol> but still, you will debug and see it does the computation right, after that there's no need for io
03:33:49 <psygnisfive> The language is of the form S*, where S is the set of all imaginable symbols, and the rules are anything at all.
03:34:00 <oklopol> well that sounds a bit boring
03:34:13 <psygnisfive> when you tell the interpret to interpret a program
03:34:42 <psygnisfive> since you can't get IO, it doesn't matter whether or not the program actual ran, since it makes no difference
03:35:01 <psygnisfive> infact, the interpreter itself doesnt exist, since it would do nothing anyway
03:35:10 <oklopol> of course it makes a difference
03:35:15 <oklopol> no one cares about the result
03:35:21 <oklopol> it's about the computation
03:35:27 <oklopol> the beautiful concept of computation
03:35:46 <psygnisfive> because you dont care what the result of it is, you can simply say "the computation happened."
03:36:01 <oklopol> nopol owns your idea so much
03:36:21 <psygnisfive> its the fastest AND the slowest computer language in existence
03:38:52 <oklopol> http://www.vjn.fi/oklopol/nopol.txt <<< mapping a lambda over a list
03:39:47 <oklopol> that is, interprets the list in a as a lambda
03:40:24 <oklopol> <. a b> is a lambda, when called, the arguments are pattern matched on a, and b is returned
03:40:29 <psygnisfive> so its sort of like... if b = (b1 b2 b3 ...)
03:41:18 <oklopol> <: a b>, in lisp, would be roughly (a b)
03:41:41 <oklopol> anyway, that's pretty much it
03:41:45 <oklopol> except for the negative list
03:41:57 <oklopol> which is the list of the form > a b c<
03:42:19 <oklopol> positive = <>, negative = ><
03:42:31 <psygnisfive> what happens when you run it backwards in time?
03:43:11 <oklopol> anyway, negative lists aren't actually all that pretty, in that they are not the negative of lists
03:43:24 <oklopol> they are *kind of* the negative, but...
03:43:43 <oklopol> <... > a b c< ...> turns into
03:44:04 <oklopol> <<... a ...> <... b ...> <... c ...>>
03:44:23 <oklopol> >...< kinda maps the outer context for each element of it
03:44:43 <oklopol> this let's you do the map operation without actually writing it
03:44:48 <oklopol> doesn't really let you do anything else
03:45:01 <oklopol> but hey, it's kinda cool, and it has an incredibly confusing syntax
03:46:01 <oklopol> (nopol 2 will have negative lists as the perfect negative of lists, just don't know what that is yes)
03:49:32 -!- graue has quit ("Leaving").
04:05:50 -!- HanDongSeong has quit ("잘").
06:23:52 -!- GreaseMonkey has changed nick to [[Nobody.
06:28:17 -!- [[Nobody has changed nick to GreaseMonkey.
06:52:20 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
06:53:50 -!- oklopol has joined.
07:07:35 -!- oklopol has quit (Connection reset by peer).
07:08:08 -!- oklopol has joined.
07:40:45 -!- GreaseMonkey has quit ("Remote closed the previous member app").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:50:54 -!- Judofyr has joined.
09:02:06 -!- Slereah has joined.
09:18:07 -!- Slereah_ has quit (Read error: 110 (Connection timed out)).
09:36:42 -!- timotiis has joined.
09:41:30 -!- kar8nga has joined.
10:07:09 -!- kar8nga has left (?).
10:20:16 -!- olsner_ has joined.
10:21:48 -!- jix has joined.
10:22:16 -!- olsner has quit (Read error: 110 (Connection timed out)).
10:51:21 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
10:51:51 -!- oklopol has joined.
12:16:41 -!- Corun has joined.
12:28:29 -!- kar8nga has joined.
12:48:06 -!- Judofyr has quit (Read error: 104 (Connection reset by peer)).
12:48:39 -!- Judofyr has joined.
13:18:45 -!- oklopol has quit (Remote closed the connection).
13:19:12 -!- oklopol has joined.
13:39:49 -!- Corun has quit ("This computer has gone to sleep").
14:09:51 -!- RedDak has joined.
14:11:10 -!- Judofyr has quit.
14:24:50 -!- kar8nga has left (?).
14:29:52 -!- jix has quit (Nick collision from services.).
14:30:02 -!- jix has joined.
14:52:43 -!- Hiato has joined.
15:15:04 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
15:15:16 -!- oklopol has joined.
15:19:09 -!- RedDak has quit (Remote closed the connection).
15:24:44 -!- puzzlet has quit (Remote closed the connection).
15:24:55 -!- puzzlet has joined.
15:29:37 -!- tusho has joined.
15:30:14 <tusho> The & sign in a book.
15:40:10 <tusho> AnMaster: The ? sign in a book.
15:40:32 <AnMaster> tusho, what on earth are you referring to
15:40:46 <tusho> AnMaster: The , sign in a book.
15:41:25 <AnMaster> so tell me tusho do you try to make any sense or are you just being silly
15:41:36 <tusho> AnMaster: The sign in a book.
15:46:56 <tusho> Deewiant: The ¨ sign in a book.
15:55:04 <tusho> oklopol: The ™ sign in a book.
16:06:59 <AnMaster> Deewiant, do you get the joke?
16:07:11 <AnMaster> and tusho doesn't want to explain
16:07:21 <tusho> AnMaster: The ' sign in a book.
16:07:49 <Deewiant> Just checking if he'd respond differently :-)
16:08:13 <Deewiant> and then I thought about countering with signs until he runs out of ASCII but couldn't be bothered
16:08:13 <tusho> Deewiant: The ƨ sign in a book.
16:09:12 <AnMaster> Deewiant, you need to make him run out of unicode as well, please warn me in advance so I can part the channel if you do that, as I don't want my harddrive filled with such a log
16:09:31 <Deewiant> he wasn't using Unicode at the time
16:11:55 <tusho> AnMaster: The Æ sign in a book.
16:14:02 <AnMaster> The sign for which strlen(0) is true on IRC.
16:17:15 <tusho> The strlen(0) == 1 on IRC.
16:20:22 -!- Hiato has quit ("Leaving.").
16:37:00 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
16:37:17 -!- oklopol has joined.
17:05:27 -!- puzzlet_ has joined.
17:05:59 <tusho> The IRC mechanical mechanism in a book.
17:11:53 -!- Corun has joined.
17:16:55 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
17:22:40 -!- Corun has quit ("This computer has gone to sleep").
17:27:06 -!- puzzlet has joined.
17:27:16 -!- puzzlet_ has quit (Remote closed the connection).
17:29:23 <tusho> oklopol: The cool in a book.
17:34:18 <oklopol> so cool an cool in an book
17:39:16 -!- ais523 has joined.
17:43:16 <tusho> wasn't expecting you today :P
17:43:19 <ais523> I was wondering which channel you were going to say hi in
17:43:25 <ais523> and neither was I, I may have to leave in a bit
17:58:25 -!- Corun has joined.
18:15:11 -!- Corun has quit ("This computer has gone to sleep").
18:30:02 -!- puzzlet_ has joined.
18:30:32 -!- puzzlet has quit (Remote closed the connection).
18:31:47 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
18:32:06 -!- oklopol has joined.
18:38:28 -!- timotiis has quit (Read error: 110 (Connection timed out)).
18:51:41 -!- kar8nga has joined.
19:07:35 -!- oklofok has joined.
19:16:38 <tusho> On an unrelated note!
19:16:45 <tusho> I am going to write a C->JS compiler.
19:16:53 <tusho> (ais523: this means C-INTERCAL in the browser. Fear!)
19:17:15 <ais523> tusho: that isn't quite as insane as one thing I thought of
19:17:15 -!- oklopol has quit (Read error: 113 (No route to host)).
19:17:23 -!- oklopol has joined.
19:17:23 <ais523> writing a BF back end for gcc
19:17:32 <ais523> so arbitrary C programs could be compiled into Brainfuck
19:17:44 <ais523> one issue would be with syscalls, etc
19:17:45 <tusho> Although ... I'm not sure I'll allow arbitary memory access in mine.
19:17:50 <tusho> That is, pointers become references.
19:17:56 <tusho> That'll be more efficient (and practical)..
19:18:09 <tusho> Does C-INTERCAL ever just dereference some memory?
19:18:11 <ais523> so in the end I thought it would be easiest just to make a Brainfuck version of Linux
19:18:16 <ais523> so you only have to implement a CPU
19:18:23 <ais523> tusho: pointers are used a lot
19:18:29 <ais523> even pointers with varargs, on occasion
19:18:35 <tusho> ais523: but, just like:
19:18:52 -!- oklofok has quit (Read error: 113 (No route to host)).
19:18:52 <ais523> well, it throws around function pointers
19:18:58 <tusho> ais523: but no pointer arithmetic?
19:19:16 <tusho> but I'm not implementing a big memory array
19:19:21 <ais523> what about things like ary[-1]
19:19:26 <ais523> that happens on occasion
19:19:28 <tusho> ais523: that won't work
19:19:44 <ais523> tusho: yes it does, because ary is set to array+1 earlier
19:19:53 <tusho> ais523: ah, that'll work then
19:19:59 <ais523> and of course there's the standard *x++ trick
19:20:01 <tusho> int ary[5]; ary[-1]
19:20:11 <ais523> if you can handle that sort of thing, you're probably safely within the C standard
19:20:14 <tusho> ais523: Well, I just want to avoid having:
19:20:21 <tusho> int memory[100mb];
19:20:23 <ais523> as long as you can handle all pointer locations within an array, and 1 past the end
19:20:34 <tusho> And instead implement arrays, etc, as real JS arrays
19:20:39 <ais523> tusho: pointers also have to be castable from ints
19:20:47 <tusho> ais523: that's the bit that won't be possible
19:20:56 <tusho> that might be possible
19:20:59 <ais523> because I use hex representations of pointers as function names
19:21:01 <tusho> but it'll just give you the js object id
19:21:12 <ais523> but the unique -> unique mapping is all that's really needed there
19:22:03 <ais523> tusho: are you planning to run the compiler itself server-side or client-side
19:22:12 <ais523> as in, the C-INTERCAL compiler
19:22:22 <tusho> ais523: client side
19:22:26 <ais523> are you planning to just compile its output into JS, or are you planning to write it in JS too?
19:22:38 <tusho> ais523: the C->JS compiler will probably be in Ruby or Js
19:22:53 <tusho> so you should be able to mush up c-intercal's source into one big thing
19:22:56 <ais523> tusho: it'll have to be in JS if you're using it to run C-INTERCAL client-side
19:23:01 <tusho> use it to compile an intercal program
19:23:01 <ais523> because otherwise its output couldn't be recompiled
19:23:06 <tusho> and then copy its output into the c compiler
19:23:13 <tusho> and then, voila, SLOWNESS
19:23:21 <tusho> ais523: does c-intercal ever do (foo*)anint?
19:23:33 <ais523> it messes about with unions
19:23:40 <ais523> but I think I changed them into structs
19:23:46 <tusho> ais523: yeah, that won't work
19:23:49 <tusho> but if it does structs, that should be ok
19:24:01 <tusho> ais523: really, this is just for the novelty of writing stuff for the web in C
19:24:09 <ais523> the union was being used for the intended purpose of unions
19:24:13 <ais523> rather than for type-punning
19:24:22 <tusho> ais523: Unions will just be structs. :-P
19:24:39 <ais523> tusho: well, /that/ violates the C standard
19:24:44 <tusho> ais523: yes it does
19:24:46 <ais523> because sizeof (union) will be wrong
19:24:48 <tusho> but it's practical
19:25:33 <ais523> hmm... what psychological problem do I have if, after refreshing my email in Firefox and finding I don't have any, I try Internet Explorer to see if it can find any more emails
19:25:39 <tusho> void myOnLoad(void *self) { alert("Hello, world!"); } int main(void) { body->onLoad = myOnLoad; }
19:25:41 <ais523> (the same website's being opened up both times, BTW)
19:25:46 <tusho> void myOnLoad(void *self) { alert("Hello, world!"); } int main(void) { body->onLoad = myOnLoad; return 0; }
19:25:59 <tusho> ais523: the "C-INTERCAL developer" problem, as I think I'll call it
19:26:15 <ais523> tusho: the return 0's implied in C99
19:26:36 <tusho> ais523: btw, I found something awful
19:26:45 <tusho> a JS application that is written in JS, but it's preprocessed JS
19:26:53 <tusho> it's processed to add objective-c features
19:26:55 <tusho> http://280slides.com/Editor/1213027183/main.j
19:27:10 -!- psygnisfive has quit (Read error: 104 (Connection reset by peer)).
19:27:12 <tusho> http://280slides.com/Editor/1213027183/Document.j scary.
19:27:21 <ais523> especially that .j extension
19:27:26 -!- augur has joined.
19:27:32 -!- Hiato has joined.
19:27:45 <tusho> ais523: it's like objective-c's .m
19:27:58 <ais523> tusho: what does .m stand for, anyway?
19:28:02 <tusho> ais523: I wish I knew
19:28:02 <ais523> as in, as an initialism
19:28:17 <tusho> I bet it's something legacy!
19:28:25 <ais523> but seriously, .j is far too ambiguous to stand for JavaScript
19:28:30 <ais523> it could just as easily stand for Java
19:28:44 <tusho> ais523: I am interested in JS preprocessors though
19:28:49 <tusho> because JS is not unfortunately usable for big things
19:28:53 <tusho> it has potential though
19:28:57 <tusho> it's one of my favourite languages
19:29:11 <ais523> tusho: did you jump to the "not usable for big things" conclusion because of Ecmanomic?
19:29:12 <tusho> ais523: I saw a JS preprocessor that added continuations, once
19:30:08 <tusho> ais523: unfortunately, CPS is gonna be really inefficient with JS
19:30:24 <ais523> tusho: CPS isn't something you write in, it's something you compile into
19:30:42 <ais523> unless you're in a lang which doesn't support function returns for some reason yet supports continuations
19:30:48 <tusho> ais523: inefficient to run in a browser.
19:30:49 <ais523> esolang idea right there!
19:31:02 <ais523> tusho: what I'm saying is why use CPS?
19:31:12 <tusho> ais523: ajax, and similar
19:31:18 <tusho> you have to use callbacks with it in JS
19:31:21 <tusho> which are really ugly
19:31:24 <tusho> you can block the browser
19:31:45 <tusho> uglyShit(..., function(r) {alert(r)})
19:31:54 <ais523> JS callbacks aren't ugly, I find
19:31:57 <tusho> ais523: Anyway. http://neilmix.com/narrativejs/doc/index.html <-- NarrativeJS, which adds an extra operator for continuations [so it's only partially CPS, which is more efficient but a bit ugly]
19:32:09 <tusho> http://chumsley.org/jwacs/ jwacs, which is amusing for being written in lisp
19:32:29 <ais523> tusho: from the name it sounds like someone's tried to compile Emacs into JavaScript
19:32:36 <ais523> now that would be impressive and somewhat worrying
19:32:40 <tusho> Javascript With Advanced Continuation Support
19:33:22 <tusho> ais523: here's what narrative JS does
19:33:30 <tusho> foo->("bar", "baz")
19:33:35 <tusho> that means 'continuation call'
19:33:40 <tusho> stays the same, BUT
19:33:47 <tusho> x(foo->("bar, "baz")); abc;
19:33:59 <tusho> foo("bar", "baz", function (r) {x(r); abc;});
19:34:46 * tusho makes a mockup of a nicer JS object system
19:34:49 <ais523> apply-continuation is perfectly acceptable as an operator, I find
19:34:59 <tusho> ais523: yes, quite
19:35:02 <tusho> unfortunately this won't work:
19:35:03 <ais523> but that's not what -> is doing here
19:35:11 <ais523> if it was applying a continuation it would never return
19:35:27 <tusho> ais523: I was explaining the translation...
19:35:33 <tusho> from js+apply-continuation to js
19:35:41 <ais523> tusho: well, I'm trying to figure out what -> actually
19:35:52 <tusho> Anyway, [[ function blahblah(x) { return blahblah2->(x); } blahblah(x); y ]]
19:35:56 <tusho> since it's function-scoped
19:36:00 <ais523> ah, it's translating function calls into CPS
19:36:02 <tusho> (Obviously, otherwise the whole program would have to be CPS'd)
19:36:24 <tusho> ais523: basically, you can do [[ alert(ajax->("blah")); ]]
19:36:29 <tusho> without having to transform the whole program
19:36:48 <ais523> -> means "allow continuations inside this function call"
19:36:59 <ais523> you'd have to call that function with -> too
19:38:16 <tusho> ais523: hmm, a JS preprocessor is seeming like an even nicer possibility each second
19:38:27 <tusho> because it could lead JS as a good way to write server-side code too
19:38:32 <tusho> on e.g. Spidermonkey
19:38:45 <tusho> JS is so close to being a near-perfect language for client & server-side
19:39:01 <tusho> so using a slightly improved version on both sides, that still takes advantage of existing implementations, is very good
19:39:22 <tusho> ooh, keyword arguments could be done too
19:39:24 <tusho> yes, that'd be nice
19:45:54 <tusho> ais523: ooh, I had an idea for -> functions
19:46:04 <tusho> how about just making every function call an actor thingy
19:46:13 <tusho> and excluding -> is an implicit block until it returns
19:53:26 <tusho> ais523: I think I'll write this -> translator thingy.
19:53:45 <tusho> the rewrite isn't that hard...
19:53:51 <tusho> Any expression involving func->(...)
19:54:05 <tusho> func(..., function (r) { The expression, with the func->(...) replaced with 'r' });
19:54:17 <tusho> Of course, I have to pick an unused name. But apart from that..
19:56:13 <tusho> ais523: Does that look right to you?
19:56:42 <ais523> also, one easy but crazy way to generate unqie names is to make them longer than the original program
19:56:53 <tusho> I think I'll stick to AST analysis.
19:57:19 <tusho> If anyone makes a variable named __ContRes_1
19:58:30 <ais523> tusho: Overload had a nice solution to this
19:58:40 <tusho> ais523: Allow arbitary objects as variable names?
19:58:43 <ais523> system reserves all variable names starting with exactly one underscore
19:58:52 <ais523> more than one underscore is for libraries
19:59:06 <tusho> ais523: You know what, I think I'll just name them __cont_res_1
19:59:13 <tusho> Because if someone names a var that, they WANTED to get at that variable.
20:00:35 <ais523> unless someone else writes a competing continuation library
20:00:46 <ais523> or you try to bootstrap it on itself for some reason
20:00:49 <tusho> I might just use Narrative JS. It is, after all, exactly what I'm describing. :-P
20:01:30 <tusho> ais523: Oh darn. Narrative JS is written in Java.
20:01:50 <tusho> Wait ... No it's not.
20:01:51 <ais523> tusho: that's easy enough to solve, I believe there are Java -> JS compilers floating around somewhere
20:01:52 <tusho> It's written in JS.
20:02:07 <tusho> ais523: No, it's in JS. It just uses the Rhino JS interpreter.
20:02:09 <tusho> Which is written in Java.
20:02:18 <ais523> does it work on other interps too?
20:02:21 <tusho> There is one Java bit.
20:02:24 <ais523> like the ones browsers use?
20:02:35 <tusho> ais523: Don't think so
20:02:41 <tusho> Obviously that'll be done server side anyway
20:03:06 <tusho> ais523: Yeah, it doesn't
20:03:12 <tusho> it uses things like 'java.lang.System.exit(1)'
20:03:19 <tusho> and java's IO stuff
20:03:20 <ais523> pity, browser-based JS interps are at least easy to come by
20:03:41 <tusho> ais523: Besides, this just means I can use Rhino as the server-side JS solution.
20:03:47 <tusho> Which is fortunate, because the Java library is useful.
20:04:00 <tusho> (SpiderMonkey, while blazes faster, lacks in the library department. Because it has none.)
20:04:45 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
20:05:24 <tusho> I still need a little thing to make JS coding nicer, though.
20:05:30 <tusho> Ah, I think jQuery has something
20:06:22 <Slereah> Why was the syntax of wiki cyclic tag erased?
20:06:42 -!- ais523 has quit.
20:08:17 -!- oklopol has joined.
20:09:04 <tusho> Slereah: Go into history.
20:09:08 <tusho> Click the better revision.
20:09:28 <tusho> Put in a summery of 'revert vandalism', too
20:10:41 -!- oklopol has quit (Client Quit).
20:10:58 -!- Corun has joined.
20:11:49 <AnMaster> hrrm, why is it that if a unit needs n non-rechargeable batteries, you can only find n-1 batteries?
20:11:52 <AnMaster> In this case n is equal to 4 AA batteries
20:12:20 <Slereah> AnMaster : Because you're poor
20:12:25 -!- Corun has quit (Client Quit).
20:13:23 <AnMaster> Slereah, nah I think it's Murphy's first law of batteries
20:26:13 -!- Hiato has quit ("Leaving.").
20:40:31 -!- B|u35un has quit (No route to host).
20:41:06 -!- B|u35un has joined.
20:51:11 -!- timotiis has joined.
21:09:47 -!- kar8nga has left (?).
21:27:28 -!- oklopol has joined.
21:37:01 -!- Corun has joined.
21:44:19 -!- RedDak has joined.
21:49:21 -!- GregorR has joined.
21:50:09 <GregorR> http://www.codu.org/jsmips/ // jsmips next-generation actually works! :)
21:50:51 <GregorR> As it turns out, all the problems I was having came down to JavaScript's lack of true integers ... overflow an integer when calculating an integer and your results are as expected, overflow a FLOAT while calculating an integer and *boom* massive failure.
21:54:07 <GregorR> A simulator for MIPS in JavaScript.
21:54:22 -!- puzzlet has joined.
21:54:40 -!- puzzlet_ has quit (Remote closed the connection).
21:54:47 <GregorR> Which is to say, a way of running .c programs in your browser, eventually :)
22:20:24 <tusho> GregorR: Inferior to my c2js.
22:21:04 <augur> why would i want to run C in my browser? :P
22:21:19 <GregorR> tusho: WTF, you have a C2JS?
22:21:25 <GregorR> augur: vim in the browser! :P
22:21:28 <tusho> GregorR: Well, I have the design for one.
22:21:35 <tusho> You can't do funky pionter artihmetic but it will be fast.
22:21:37 <augur> gregor, it's not like JS is all that different from C
22:21:39 <GregorR> That's very different from actually HAVING one.
22:21:39 <tusho> GregorR: I.E., no huge heap array
22:21:43 <augur> except, say, pointers
22:21:46 <tusho> it actually uses regualr js objects
22:22:01 <GregorR> My goal is to take C programs that were never intended for running in a browser and running them unmodified.
22:22:10 <tusho> GregorR: Rite, mine can do that too.
22:22:11 <GregorR> That is, it's explicitly NOT to create a new language.
22:22:12 <tusho> Just write 'printf'.
22:22:21 <GregorR> <tusho> You can't do funky pionter artihmetic but it will be fast.
22:22:33 <tusho> GregorR: Well, not many programs do funky pointer arithmetic
22:22:35 <tusho> I mean things like this:
22:22:39 <tusho> int test[3]; test[-15]
22:22:52 <GregorR> Oh, you really do mean /FUNKY/ pointer arithmetic :P
22:22:58 <GregorR> OK, well, I'll believe it when I see it ;)
22:23:05 <tusho> GregorR: BTW, I advise testing jsmips in Firefox 3.
22:23:09 <tusho> It's blazin' fast!
22:23:15 <GregorR> Ohyah, I hadn't gotten around to FF3 yet :)
22:23:24 <tusho> GregorR: The example runs in less than a second.
22:23:28 <tusho> With no lag on startup
22:23:35 <tusho> The page loads quickly, I press start, less than a second goes by and no browser hangup
22:25:10 <tusho> GregorR: I CAN'T WAIT FOR MOLASSOS
22:25:31 <tusho> GregorR: Hmm. If you used twm it could actually work.
22:25:43 <tusho> e.g. write an ultra-optimized <canvas> gfx driver
22:25:53 <tusho> and then make twm extremely stripped down
22:25:58 <tusho> and use rxvt instead of xterm
22:26:01 <GregorR> That's a very future-y consideration ;)
22:26:05 <tusho> and you _might_ be able to get something kind of usable
22:26:19 <tusho> GregorR: Can I halp develop jsmips. :P
22:26:24 <tusho> Even though I don't know anything about MIPS!
22:26:35 <GregorR> You don't need to, the MIPS core is totally done.
22:26:44 <GregorR> (MIPS is a very small architecture)
22:26:44 <tusho> GregorR: It might need teh optimizations.
22:26:53 <tusho> GregorR: Please tell me you have a git repository. :-P
22:27:16 <tusho> GregorR: Better than rodger's - "Uploading a zip file is superior to any VCS!"
22:27:30 <tusho> Set up a push location somewhere or something. :-P
22:27:47 <GregorR> I'll switch to git when it works on Windows *shrugs*. Mind you, I don't use Windows, but I still don't want to use something that limits 95% of desktop users ...
22:28:10 <tusho> GregorR: What portion of people interested in developing jsmips do you think will be using Windows without cygwin? :-P
22:28:17 <GregorR> Unfortunately, it's not publicly accessible right now, but I'll create a new repo on codu.org. Please hold.
22:28:26 * tusho holds the nearest thing.
22:29:31 <tusho> GregorR: WHAT IF I WAS REALLY TALL AND SOMEONE ELSE WAS ON STILTS HUH?
22:29:33 <tusho> STOP ASSUMING THINGS.
22:32:23 <tusho> GregorR: MY IMPATIENCE MANIFESTS IN EATING PEOPLE
22:32:29 <GregorR> http://www.codu.org/cgi-bin/hg/hgwebdir.cgi/jsmips/
22:32:44 <tusho> GregorR: But what about push access
22:32:48 <tusho> Do you not love me enough
22:33:08 <GregorR> If you register at http://www.codu.org/cgi-bin/ploftrac.cgi/ I can give you push.
22:33:41 <tusho> GregorR: I registered, but like, with sex appeal.
22:33:47 <tusho> If that makes sense.
22:34:51 <tusho> GregorR: O, and what gcc setup do I need.
22:34:53 <tusho> Cross compile to mips rite
22:35:09 <tusho> YAY. MACPORTS HAS MIPS-ELF-GCC
22:35:14 <tusho> ^__________________________________________________________________________________________________________________________________^
22:35:39 <tusho> GregorR: So where do I push.
22:35:43 <tusho> IF YOU KNOW WHAT I MEAN.
22:36:20 <GregorR> OK, you should have push access now. Same URL (sorry, I've been having issues with https - I should be able to fix it soon, but for the moment, http push :( )
22:37:32 <tusho> It's ok. I just love sending my password out in the clear!
22:38:07 <tusho> GregorR: Oh, and can I point you to http://no-www.org?
22:39:26 <tusho> GregorR: What are you trying to say?
22:39:32 <tusho> I am saying that www. is obsolete
22:39:42 <tusho> foo@email.corp.com is silly
22:39:43 <GregorR> Feel free to strip off the 'www.' part :P
22:39:53 <tusho> GregorR: Don't link people to www. then :P
22:40:25 <tusho> also, the people on the xkcd forums fail at british humour and mornington crescent
22:40:43 * GregorR never reads forums associated with web-comics ... or most anything else.
22:41:14 * tusho watches mips-elf-gcc install
22:42:24 <tusho> GregorR: Can I change Gregor Richards to The JSMIPS Project. It's sillier, and more legally correct as soon as I touch a bit. :-P
22:43:02 <GregorR> No, add your own copyright if you make significant changes.
22:43:16 <GregorR> It's not more legally correct unless The JSMIPS Project exists as a legal entity, which it does not.
22:43:34 <tusho> GregorR: It can if you include a file CONTRIBUTORS defining The JSMips Project
22:43:58 <GregorR> OK, I suppose that's true *shrugs* ... but it muddles the question of who owns any given file.
22:44:16 <tusho> GregorR: Why would someone own a given file? Curious :P
22:44:28 <GregorR> There is no logical reason, but the law's the law.
22:44:58 <tusho> GregorR: We should move to #esotericia and make the legal system a nomic.
22:45:04 <tusho> Then we could just fix copyrights by proposal.
22:45:20 <tusho> And declare wars on both Germany and Agora.
22:46:22 <GregorR> So, did you use my patches to make your cross compiler? I just noticed you said mips-ELF-gcc, but actually some changes are needed to the basic mips-elf-gcc configuration >_>
22:46:51 <tusho> GregorR: Shit. No.
22:46:55 <tusho> I just installed MacPorts'
22:47:11 <GregorR> Making your life more difficult since 1986: Gregor Richards!
22:47:22 <tusho> GregorR: SHY DOES IT NEED A PATCH
22:47:26 <GregorR> Unfortunately, mips-elf-gcc's built-in specs file will be wrong with respect to newlib.
22:47:49 <GregorR> Also, so I can #ifdef _JSMIPS :P
22:48:13 <tusho> GregorR: If I give you shell access will you build it for me
22:48:21 * tusho goes and downloads gcc
22:48:39 <GregorR> But do you trust me with shell access? :P
22:48:58 <tusho> GregorR: Pledge in agora not to abuse the privileges.
22:49:11 <tusho> After all, what's more devastating than an Agoran criminal case?!
22:49:41 <GregorR> My pledges are meaningless, I routinely backstab people.
22:49:52 <tusho> GregorR: I said agoran pledge
22:50:08 * GregorR isn't part of Agora, nor does he want to mix himself up in all that :P
22:50:31 <GregorR> (Nor does he know how an agoran pledge is any different from a non-agoran pledge >_> )
22:50:40 <tusho> GregorR: An agoran pledge looks like this:
22:51:13 <tusho> [[I agree to the following: {This is a pledge. This is a private contract. Parties to this contract MUST not abuse SSH privileges on ehird's machine.}]]
22:51:24 <tusho> If and only if I agreed to that contract, I leave it.
22:53:40 <tusho> GregorR: What need patching?
22:53:46 <tusho> I mean, what can I just install normally
22:56:18 <GregorR> Well, you may be able to frankenstein with mips-elf-binutils, but unfortunately, for everything to work properly it needs to have the name "mips-jsmips-..."
22:56:36 <tusho> I just want to know what I have to patch
22:56:43 <tusho> Just the stuff in patches/
22:58:55 <tusho> GregorR: What patch command, again?
22:58:58 <tusho> I can never remember how to use patch
23:00:44 * tusho figures out how to configure binutils
23:00:48 <tusho> ./configure --target=jsmips or someting?
23:01:37 <tusho> --build=BUILD configure for building on BUILD [guessed]
23:01:37 <tusho> --host=HOST cross-compile to build programs to run on HOST [BUILD]
23:01:38 <tusho> --target=TARGET configure for building compilers for TARGET [HOST]
23:03:09 <GregorR> First off, you have to be in a separate build directory
23:03:20 <GregorR> Then ../configure --prefix=<whatever> --target=mips-jsmips
23:07:17 <GregorR> GCC will also need --with-newlib --disable-libssp. binutils and newlib should both work with that.
23:07:31 <tusho> GregorR: So I have to compile newlib before gcc?
23:07:34 <GregorR> Erm, that is, binutils and newlib just need --prefix and --target, GCC also needs --with-newlib --disable-libssp
23:08:08 <GregorR> --with-newlib is a misnomer
23:08:16 <GregorR> It means something more like --without-c-library
23:10:25 <tusho> GregorR: I notice you used the last gpl2 gcc.
23:12:11 <GregorR> Actually, I used the latest no-dependencies GCC.
23:12:20 <GregorR> The fact that it's also the latest GPL2 is a coincidence.
23:34:35 <tusho> GregorR: Burn! I have a core 2 duo and that's good enough for me
23:34:50 <tusho> Also quad core macs are like the most expensive thing on earth
23:35:12 <GregorR> Oh, I just started GCC compiling and then went to grab a soda, and it was done by the time I got back (mind you, not /drink/ a soda, just physically remove it from the refrigerator)
23:35:34 <tusho> GregorR: Meh. I'm not really fussed with this machine's performance. It's miles better than what I had before :P
23:35:56 <tusho> Of course being a mac it cost too much for the specs, but I don't care because I like it.
23:36:18 <GregorR> Got the cross-compiler? (Sorry that making a JSMIPS cross compiler is such a PITA, but there's really nothing I can do about that :( )
23:36:49 <tusho> GregorR: About to compile gcc
23:37:32 <tusho> GregorR: ../configure --prefix=/opt/jsmips --target=mips-jsmips --with-newlib
23:40:22 <GregorR> (libssp will try to compile and fail because there's no libc ... stupid GCC should have a --with-no-libc option that figures that all out)
23:42:35 <tusho> GregorR: I think I will write a ./mkcrosscompile.sh PREFIX
23:44:21 * GregorR is too used to making cross-compilers for his own good ...
23:48:58 <tusho> GregorR: gcc is slowwwwwwww to compile.
23:49:24 <tusho> GregorR: Also, autotools sucks so damn hard.
23:49:40 <tusho> I lol at when warnings show up because there's no way you could catch them with all the drowning output
23:51:31 <tusho> Also stallman is a hobo. :-P
23:51:41 -!- AnMaster has quit ("Away for a few days without internet").
23:53:48 <tusho> GregorR: CHRIST. IT'S SLOW.
23:53:53 <tusho> Does make j=3 work
23:54:21 <GregorR> Although that's not the right syntax ...
23:54:43 <tusho> GregorR: I thought autotools didn't support -j
23:56:11 <tusho> ../../../libiberty/regex.c:51:25: error: sys/types.h: No such file or directory
23:56:14 <tusho> ../../../libiberty/regex.c:158:25: error: strings.h: No such file or directory
23:56:14 <tusho> In file included from ../../../libiberty/../include/xregex.h:26,
23:56:14 <tusho> from ../../../libiberty/regex.c:193:
23:56:18 <tusho> ../../../libiberty/regex.c:196:20: error: ctype.h: No such file or directory