00:00:01 <ehird> then, write a specializer for that language
00:00:03 <ehird> (tuned to the interpreter)
00:00:16 <ehird> that way you don't have to deal with the foibles of regular languages
00:00:49 <pikhq> Then, crap out a specialiser. And an interpreter and compiler.
00:01:08 <pikhq> Crap out a compiler. And an interpreter and specialiser.
00:01:19 <ehird> pikhq: stop confusing him
00:01:53 <nooga> i've got language FOO and interpreter for it written in FOO and then i make something that takes interpreter of language FOO and a program in language FOO and i get a compiler for that program in FOO
00:02:57 <oerjan> um they _don't_ have to be all the same language, i think
00:03:14 <oerjan> otherwise it might indeed be somewhat ridiculous
00:03:22 <ehird> nooga: here's what you do:
00:03:29 <ehird> you've got a language foo and an interpreter for it written in bar
00:03:49 <ehird> then you take something that takes that a program in language foo and an argument to it
00:04:01 <ehird> and you get the result as an optimized program just doing that calculation
00:04:08 <ehird> that's the specializer
00:04:10 <ehird> so the compiler is
00:04:15 <ehird> specializer(interpreter,program)
00:04:59 <nooga> ehird: then you take something that takes that a program in language foo and an argument to it << where's the interpreter here?
00:05:19 <ehird> the specializer doesn't need an interpreter; it understands the language
00:05:26 <ehird> just like a compiler or an interpreter has innate knowledge of the language
00:05:29 <ehird> nooga: i wrote it wrong
00:05:39 <ehird> you've got a language foo and an interpreter for it written in bar
00:05:45 <ehird> then you make something that takes that a program in language bar and an argument to it (its input)
00:06:00 <ehird> and returns the result as an optimized program just doing that calculation with that input written in language baz
00:06:05 <ehird> that something is the specializer
00:06:09 <ehird> to make a compiler
00:06:16 <ehird> specializer(interpreter,program_to_compile)
00:06:25 <ehird> and it spits out a — hopefully fast — version of the "interpreter" mangled to just use that program
00:06:35 <ehird> — with branches eliminated, constants folded, loops unrolled based on the structure
00:06:39 <ehird> and whatnot, to make it an efficient output program
00:09:14 <pikhq> In other words, it has magically acted as a compiler.
00:09:31 <ehird> nooga: of course, specializers don't really have much literature on them — but you could write an okay one
00:09:35 <ehird> and it'd be fun to play with
00:09:41 <ehird> nooga: for your case, you'd haev
00:09:57 <ehird> bar=one you invent for this project; simple but usable
00:10:09 <ehird> nooga: and you can write the specializer in any language you feel comfortable with; c, ruby, etc.
00:10:48 <pikhq> Writing the specialiser in a language it understands would be amazing, of course, but you don't need to...
00:10:50 <nooga> s i am supposed to invent a language that could interpret sadol?
00:11:12 <ehird> make it simple with, preferably, lots of structural hints to utilize in the specialiser
00:11:30 <ehird> pikhq: that's the case in the theoretical examples
00:11:39 <ehird> pikhq: you do crazy shit like specializer(specializer,specializer)
00:11:45 <ehird> which is \x.specializer(specializer,x)
00:11:55 <ehird> which is \y.specializer(x,y)
00:12:00 <ehird> and that's something like a compiler-compiler
00:12:06 <pikhq> ehird: Yeah. That's crazy shit.
00:12:15 <ehird> but you only need one projection for this SADOL project
00:12:55 <ehird> http://www.google.com/squared/search?q=4chan+memes
00:12:59 <ehird> Protip: No value found.
00:13:46 <ehird> It's like Alpha without the alpha.
00:13:51 <ehird> Or the computation.
00:14:58 <oerjan> well if you have square, you have half of a specializer don't you? >:)
00:15:26 * oerjan didn't consider that a pun
00:15:46 <ehird> oerjan: what did you mean?
00:16:32 * oerjan notes this is the second time today someone laughed after not getting what he said...
00:17:05 <nooga> i'm too stupid for that specializer thingy
00:17:21 <oerjan> ehird: those specializers take two arguments don't they?
00:17:21 <ehird> nooga: just read it a few more times
00:17:25 <ehird> draw some diagrams methodically for it
00:17:26 <nooga> can't imagine how i would implement that in practice
00:17:29 <ehird> oerjan: assume f(x,y) = f x y
00:17:40 -!- olsner has quit (hubbard.freenode.net irc.freenode.net).
00:17:41 <ehird> for my specializer(specializer,specializer) example
00:18:00 <ehird> nooga: first, invent a simple language with a lot of structural hints (i.e. rich control structures and the like to express what the code is trying to do)
00:18:06 <ehird> then, write a SADOL interp in it
00:18:12 <ehird> and a simple, really-stupid interp for the language in anything
00:18:18 <oerjan> anyway (X, Y) is cartesian product, thus a square
00:18:19 <ehird> then, you can think about a specializer
00:18:42 * oerjan may change his opinion about it being a pun
00:19:14 <ehird> oerjan: also specializer(specializer,specializer) = specializer^3
00:19:19 <ehird> but I didn't realise at first
00:19:22 <nooga> ehird: and a simple, really-stupid interp for the language in anything << and that interp will magically turnn sadol programs into anything?
00:19:37 <ehird> stop thinking about specialization
00:19:56 <pikhq> The specialiser comes after the language and interpreter.
00:19:58 <ehird> nooga: but no thats not how a specializer works
00:20:03 <nooga> okay, so i need one language and 2 interpreters
00:20:08 <ehird> one interpreter, one specializer
00:20:13 <ehird> stop thinking about specializers until the interp
00:20:57 <nooga> todo for now: invent a language, implement that language, write a sadol interpreter in that language
00:21:40 <ehird> nooga: s/language/language with lots of structural hints/
00:21:42 <pikhq> Strictly speaking don't need to implement aforementioned language, but it'd probably help. A lot.
00:21:43 <ehird> very important :-P
00:21:47 <ehird> but it helps the specializer later
00:21:55 <ehird> well you have to implement it
00:22:06 <ehird> compiler != interpreter != specializer
00:22:08 <ehird> but all are implementations
00:22:25 <nooga> so i need to write another interpreter for (language with lots of structural hints)
00:22:34 <coppro> Why does banker's rounding exist?
00:22:34 <pikhq> ehird: Well, y'know what I mean. :p
00:22:36 <nooga> in ruby for instance
00:22:44 <ehird> nooga: here's your todo:
00:23:14 <ehird> invent a simple language with some structural hints, implement an interpreter for that language, write a sadol interpreter in that language, utilizing the control hints as much as possible (if you can't use many, add some more)
00:23:32 <ehird> coppro: it's flatter, statistically
00:23:47 <ehird> coppro: so's your mom
00:24:05 <oerjan> coppro: http://en.wikipedia.org/wiki/Rounding#Round-to-even_method
00:24:06 <coppro> making [1.5,2.5] round to 2 and (2.5,3.5) round to 3, etc. does not improve distribution
00:24:22 <nooga> ehird: interpreter for that simple language can be written in ruby?
00:24:28 <ehird> nooga: sure; anything
00:24:32 <ehird> nooga: it won't be used for the specializer
00:24:37 <ehird> it's just to get you something that works, for testing, etc
00:24:39 <nooga> i won't need to process ruby code
00:25:24 <nooga> i'll replace sadol with something simpler
00:25:36 <ehird> but this saves you writing a sadol compiler
00:25:59 <pikhq> nooga: Brainfuck. :p
00:26:03 <ehird> the nice thing is that this language doesn't need to do much more than interpreter stuff
00:26:12 <ehird> you can skimp on everything but structural stuff, a rich control structure set, string handling and a bit else
00:26:16 <nooga> ehird: but the compiler will compile sadol to what?
00:26:18 <pikhq> Or maybe just straight lambda expressions.
00:26:30 <ehird> nooga: nothing; there is no compiler
00:26:31 <ehird> just specializations
00:26:36 <nooga> to something that's interpretable by my interpretter written in ruby
00:26:44 <pikhq> nooga: You won't make a compiler. You will use the specialiser as a compiler.
00:26:49 <nooga> i'd like sadol->MACHINE CODE!!!!!!1111111
00:26:50 <ehird> nooga: remember when i said stop thinking about a specializer because it's muddling your mind?
00:26:58 <ehird> nooga: it will do sadol→LLVM in the end
00:27:05 <ehird> but stop thinking about it, it doesn't matter atm
00:35:43 -!- oerjan has quit ("Good night").
00:38:14 <nooga> the hard thing is to design the language
00:38:33 <nooga> i started doing that and i came up with something that looks like sadol pretty much :D
00:39:19 <ehird> nooga: sadol doesn't have many structural hints
00:39:27 <ehird> nooga: I know this because you keep talking about inferring and partially evaluating and the like
00:40:45 * pikhq wants to see a Brainfuck specialiser. :p
00:40:53 -!- olsner has joined.
00:40:55 <pikhq> Useless? Well... Yes...
00:40:57 <nooga> i've added formal types
00:41:41 <nooga> i need: loops, stacks (or recursive functions), arrays, if-else, types (char, int, float) and IO
00:43:01 <pikhq> Actually, a Brainfuck specialiser might not be too hard to do. Hmm.
00:43:31 <ehird> pikhq: rather trivial; you only have one input stream
00:43:37 <ehird> pikhq: and you just have to evaluate it for a while
00:43:53 <pikhq> Yeah, actually, it wouldn't be tricky, come to think of it.
00:43:58 <ehird> pikhq: offset start of tape, change , to (move to correct tape length)
00:44:04 <ehird> put initialization of input at start of program
00:45:26 <pikhq> And you could use that for the first projection.
00:46:13 <ehird> nooga: stack based, incidentally, is terrible for this kind of thing
00:46:25 <ehird> as it has very little structural information even about what goes to which function!
00:46:45 <Patashu> and what the function actually does
00:46:47 <nooga> sadol is not stack based
00:46:50 <Patashu> can be changed depending on the state of the stack
00:46:59 <ehird> pikhq: the only difficult part about doing this in bf would be changing the ,s
00:47:06 <ehird> and even that would be quite easy, pikhq, EXCEPT
00:47:16 <nooga> Patashu: consider it as a retarded lisp without ( )
00:48:06 <nooga> !sadol :a3 :b2 :o"1* !`+o+a+"1 b
00:48:09 <pikhq> ehird: Varfuck, then? ;)
00:48:19 <ehird> pikhq: but the whole idea is using esotope to eliminate the cruft
00:48:26 <ehird> although esotope would have to be bf→bf to take true advantage
00:48:32 <ehird> just write a bf backend
00:48:41 <pikhq> Not hard to do at all.
00:54:46 <pikhq> Now, a Brainfuck->Brainfuck specialiser in Brainfuck... That'd be a tour de force. :p
00:55:05 <ehird> pikhq: compile esotope to BF
00:55:11 <pikhq> s/tour de force/$EXPRESSION_INDICATING_AWESOME/
00:55:17 <ehird> yes, it'd be slow; so use your specializer
00:55:48 * pikhq has something to hack on
00:56:10 <ehird> pikhq: yeah, I'm tempted now
00:56:19 <ehird> pikhq: might work with something a little more featureful though?
00:56:22 <ehird> variables would help immensely.
01:07:00 -!- Patashu has quit ("Patashu/SteampunkX - MSN = Patashu@hotmail.com , AIM = Patashu0 , YIM = Patashu2 , Googletalk = Patashu0@gmail.com .").
01:14:33 -!- inurinternet has quit (No route to host).
01:43:50 <nooga> http://pastie.org/499863
01:44:04 <nooga> i'm sure it can be done shorter
01:47:17 <nooga> !sadbf +++++++++[>+++++++++++++<-]>-.
01:47:20 <nooga> !sadbf +++++++++[>+++++++++++++<-]>-...
01:47:36 <nooga> looks like it works
01:49:47 <EgoBot> 126 ++++++++++[>+++++++>++++++++++>++++>+<<<<-]>++.>+.+++++++..+++.>++++.------------.<++++++++.--------.+++.------.--------.>+.>. [158]
01:51:21 <GregorR> !sadbf ++++++++++[>+++++++>++++++++++>++++>+<<<<-]>++.>+.+++++++..+++.>++++.------------.<++++++++.--------.+++.------.--------.>+.>.
01:52:22 <nooga> i forgot to change mem length
01:52:30 <nooga> it's only 10 cells
01:53:07 <nooga> does !addinterp overwrite?
01:53:33 * GregorR is trying to figure out how to build a croquet mallet out of PVC pipe and mortar.
01:54:09 <GregorR> I can't find the weight per cubic whatever of mortar ...
01:54:51 <nooga> how to update interp in EgoBot
01:55:20 <GregorR> A real interp or a userinterp?
01:56:10 <nooga> !sadbf ++++++++++[>+++++++>++++++++++>++++>+<<<<-]>++.>+.+++++++..+++.>++++.------------.<++++++++.--------.+++.------.--------.>+.>.
02:01:53 <nooga> !sadbf >+++++++++[<++++++>-]<...>++++++++++.
02:07:40 <nooga> :M$0 :d:i,45000@>i-01(2]M0:i-i1:S$0:C;3:l#C-01:p:m0@<pl(2?=#Cp"1+:#Mm%+#Mm1,3255?=#Cp"1-:#Mm?<-#Mm10,3254-#Mm1?=#Cp"1>:m%+m1d?=#Cp"1<:m?<-m10-s1-m1?=#Cp"1.!'2#Mm?=#Cp"1,:#Mm'1;0?=#Cp"1[]S-p1?=#Cp"1]?=#Mm00:p[S0:p+p1
02:07:52 <nooga> SADOL isn't very innovative and well designed
02:08:00 <nooga> but the code looks ugly for sure
02:26:35 <nooga> ehird: SADOL is parsed to neat AST and has really simple flow control, with strict typing it would be easy to mangle and specialize
02:34:22 -!- bsmntbombdood_ has joined.
03:00:40 -!- Corun has joined.
03:07:52 -!- boily has joined.
03:10:53 -!- bsmntbombdood_ has quit (Read error: 110 (Connection timed out)).
03:11:37 -!- bsmntbombdood_ has joined.
03:12:53 <pikhq> Hahah. I just discovered a partial evaluator for Tcl.
03:15:09 <pikhq> Not very good, mind.
03:23:15 -!- boily has quit ("leaving").
03:31:35 -!- bsmntbombdood_ has quit (Read error: 110 (Connection timed out)).
03:43:50 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
03:46:18 -!- bsmntbombdood_ has joined.
04:04:11 -!- Corun has quit ("Leaving...").
04:05:09 -!- nooga has quit (Remote closed the connection).
04:29:55 -!- bsmntbombdood_ has quit (Connection timed out).
04:31:02 -!- bsmntbombdood_ has joined.
04:34:57 -!- coppro has quit (Read error: 104 (Connection reset by peer)).
04:50:34 -!- amca has joined.
05:10:16 -!- bsmntbombdood_ has quit (Read error: 110 (Connection timed out)).
05:33:23 -!- Patashu has joined.
06:03:48 -!- bootscats has joined.
06:05:07 -!- bootscats has left (?).
06:21:43 -!- kar8nga has joined.
06:33:39 -!- Gracenotes has joined.
06:39:02 -!- bsmntbombdood has joined.
07:22:42 -!- kar8nga has quit (Remote closed the connection).
07:25:59 -!- Sgeo has quit (Read error: 110 (Connection timed out)).
07:57:18 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:17:58 -!- bsmntbombdood__ has joined.
08:19:00 -!- bsmntbombdood__ has changed nick to bsmntbombdood.
08:32:38 -!- bsmntbombdood has quit (Read error: 60 (Operation timed out)).
08:54:23 -!- Slereah has joined.
10:47:51 -!- nooga has joined.
10:50:16 <nooga> nigger nigger nigger nigger nigger
10:51:31 <nooga> Poland, we've got tlds like perl script extensions :D
10:56:39 <Slereah> YOU FORGOT POLAND DERP DERP
11:06:55 -!- nooga has quit (Read error: 54 (Connection reset by peer)).
11:27:44 <AnMaster> hm... does anyone know a way to tell google you actually want a misspelling? When I'm googling for something that is almost the same spelling as a common word, apart from one letter it seems to return both what I wanted and results matching the common word instead...
11:28:13 <fizzie> Adding quotes around the word (even if it's just one word) seems to sometimes help, but maybe not always.
11:30:36 -!- oerjan has joined.
11:31:31 * oerjan sees AnMaster and hurries to IWC
11:31:43 <AnMaster> oerjan, wow, I just did the same when I saw you
11:45:17 -!- KingOfKarlsruhe has joined.
11:47:00 -!- GregorR-L has joined.
11:51:21 <oerjan> try #haskell next door
12:10:19 -!- GregorR-L has quit (Read error: 60 (Operation timed out)).
12:37:24 -!- Sgeo has joined.
12:37:57 <Slereah> Where does the zombie-brain thing come from anyway?
12:38:11 <Slereah> What pulp piece of shit started that trop
12:40:34 -!- puzzlet has quit (Read error: 60 (Operation timed out)).
12:40:50 -!- puzzlet has joined.
12:41:05 <oerjan> Slereah: http://en.wikipedia.org/wiki/Return_of_the_Living_Dead
12:42:00 <Slereah> "Return's interpretation of zombies has influenced cultural interpretations of zombies, particularly with regard to their hunger for brains and their constant vocalization of this hunger."
12:47:38 -!- puzzlet has quit (Remote closed the connection).
12:47:49 -!- puzzlet has joined.
12:48:47 -!- Corun has joined.
12:54:46 -!- amca has quit ("Farewell").
12:58:08 -!- puzzlet has quit (Read error: 60 (Operation timed out)).
12:58:21 -!- puzzlet has joined.
13:00:45 -!- bsmntbombdood has joined.
13:13:20 -!- Corun has changed nick to Corun|away.
13:22:19 -!- Corun|away has changed nick to Corun.
13:25:55 -!- ais523 has joined.
13:31:31 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
13:33:29 -!- nooga has joined.
13:38:05 -!- Judofyr has joined.
13:39:33 -!- oerjan has quit ("leaving").
13:45:36 -!- Patashu has quit ("Patashu/SteampunkX - MSN = Patashu@hotmail.com , AIM = Patashu0 , YIM = Patashu2 , Googletalk = Patashu0@gmail.com .").
14:16:55 * ais523 wonders how defend7 can /still/ be third on the BF Joust leaderboard, after all this time...
14:17:07 <AnMaster> ais523, I'm running on that hello world again to see how much better it is now. Btw to be able to process it I have to do ulimit -v $((512 * 1024)) first... Otherwise it will swap trash (the ulimit ends up forcing erlang's GC to run more often...)
14:17:28 <ais523> I love the idea of swap-trashing when you try to compile hello world
14:18:31 <AnMaster> ais523, I think it happens when it changes all those initial adds to create the "every third cell" pattern from adds to sets...
14:19:00 <ais523> gcc-bf swap-trashes when trying to remove the run-length encoding from that bit, I think
14:19:05 <ais523> which is why I have to output in RLE
14:19:12 -!- KingOfKarlsruhe has quit (Remote closed the connection).
14:19:46 <AnMaster> ais523, well I don't. Once I saw that I decided to parse it directly as combined nodes. Instead of first expanding it then combining it again in the combiner pass.
14:20:17 <AnMaster> generated file size is now 928K
14:20:33 <ais523> the triumph of #esoteric engineering: getting hello world to less than a megabyte
14:21:04 <AnMaster> ais523, depends on WHAT hello world :P
14:21:18 <ais523> you're ruining the joke!
14:21:22 <AnMaster> those generated by !bf_txtgen and such I can constant fold of course
14:21:40 * AnMaster wonders what on earth that is for
14:21:51 <ais523> AnMaster: probably saving registers on the stack
14:22:03 <ais523> that wouldn't be the saving itself
14:22:08 <ais523> but the deallocation of stack elements once it was done
14:22:19 <ais523> so actually, that's restoring, not saving
14:22:24 <AnMaster> huh. I just can't see how that would deallocate anything
14:22:55 <ais523> and stack storage is marked as allocated or not via a flag stored in every sixth tape element
14:23:10 <ais523> which also doubles up as stack pointer and a stack of frame pointers
14:23:12 <ais523> just to complicate things
14:24:34 <AnMaster> ais523, well I can't yet figure out how much a [>>>] will move or such. I have some ideas about how you could do it for some cases. But most programs won't gain much from it. Not even lostkingdom. And GCC-BF code is not really a priority for me, since I can't download gcc-bf myself currently.
14:25:05 <ais523> AnMaster: it's the only really sane way to implement pointers in Brainfuck
14:25:29 <fizzie> "really sane way" for some values of sane, surely.
14:25:31 <AnMaster> ais523, interestingly enough, that hello world doesn't have a lot of balanced loops that can be folded into polynomials it seems
14:25:57 <AnMaster> like [>++>+++<<-] into p[1]=2*p[0]; p[2]=3*p[0];p[0]=0;
14:25:58 <ais523> why would you expect it to?
14:26:07 <ais523> polynomials aren't a particularly good way to implement things
14:26:09 <AnMaster> ais523, well, lostking has a lot of them
14:26:13 <ais523> there are polynomials, but they go /sideways/
14:26:24 <ais523> as in, moving values along the tape a specified, variable, distance
14:26:41 <AnMaster> ais523, variable distance.... How do you encode it
14:26:41 <ais523> most values are more than 8-bit in C
14:26:47 <ais523> and I encode it as separate bytes
14:26:56 <AnMaster> I mean, some way to detect such loops and figure them out
14:27:20 <ais523> AnMaster: do you still have gcc-bf source from last time I pasted it?
14:30:29 <AnMaster> ais523, hm I guess this could be optimised quite a bit: http://pastebin.ca/1447552 but I don't really know how to detect that in a program...
14:30:55 <AnMaster> somehow that needs an else for the if
14:31:59 <ais523> I wonder what my 32-bit addition code looks like when compiled to C?
14:32:09 <ais523> for all I know, that might be it
14:32:13 <ais523> although I think it's a bit longer than that
14:32:23 <AnMaster> ais523, that is just a short section
14:33:17 <AnMaster> [.>] would be "output nul-terminated string" wouldn't it? Assuming current cell is known to be non-zero. Otherwise same but in a "if".
14:33:35 <AnMaster> that could possibly be optimised somehow...
14:34:19 -!- Corun has quit ("Leaving...").
14:36:42 <Slereah> Can you do an arc with the picture package of latex?
14:37:35 <Slereah> Owait, they have a "marking angles"
14:38:59 <AnMaster> ais523, when looking at the generated output my conclusion is that there are many ways to optimise it, but most of them are hard with my current design.
14:39:15 <ais523> AnMaster: perhaps I should send you the annotated output?
14:39:35 <ais523> bfrle (my BF interp designed specifically for debugging gcc-bf) can read special notations in comments to check that the program's behaving as intended
14:39:42 <ais523> it specifies the tape location the pointer's meant to be at
14:39:44 <AnMaster> oh and is "(%999999999 Assertion error)" for
14:39:55 <ais523> yep, it's an assertion that can't be met
14:40:09 <ais523> so when running under BFRLE, the program would crash with an error at that point
14:40:13 <ais523> meaning that I'd made a mistake in my code
14:41:19 -!- Corun has joined.
14:41:21 <AnMaster> annotated output could be useful yes. But in general it is hard to map source to output for non-trivial files. Even if I did try to store some position info it wouldn't help a lot as the the code has been resorted a lot and so on.
14:41:38 <AnMaster> "sorting by offset" is one of the key passes really.
14:41:41 <ais523> well, knowing where the pointer is is very useful in optimising
14:41:58 <ais523> although it's rather hard to prove that the annotations aren't lying
14:42:14 <AnMaster> yes sure. But I can't do any optimisations that won't work for normal BF...
14:42:18 <ais523> without knowing the basic rules for a gcc-bf tape (every sixth space does the same thing, etc)
14:42:38 <AnMaster> I can do the special parsing sure in a module
14:42:39 <ais523> so I think a really really hyperoptimising BF compiler would deduce the tape structure used by the program
14:42:56 <ais523> most BF programs, after all, reserve, say, every second tape cell as temp, or something like that
14:43:08 <ais523> a compiler that could figure out that the program was doing that could optimise much better than any that didn't
14:43:24 <fizzie> Are you trying to make [AnMaster's bf-optimizer generating C code](gcc-bf(X)) an identity transformation?
14:43:25 <AnMaster> ais523, that is very hard to do in general. Correct results is most important. Otherwise I would end up somewhat like G++, where program behaviour often change depending on if -O0 or -O2 is used...
14:43:43 -!- Corun has quit (Client Quit).
14:44:11 <ais523> fizzie: that would be ideal, but probably impossible
14:44:15 -!- Corun has joined.
14:44:23 <ais523> although idioms for, say, 32-bit addition, might be recognisable
14:44:32 <AnMaster> ais523, I suspect (but don't know) that figuring out and proving the "reserved cells" bit is in general not computable...
14:44:47 <AnMaster> ais523, yes they might be. If I knew them
14:44:50 -!- fungebob has joined.
14:45:00 <ais523> incidentally, Europeans here, have you remembered to vote in the elections?
14:45:23 -!- Corun has quit (Client Quit).
14:45:26 -!- bsmntbombdood has joined.
14:45:37 <ais523> (they are today across Europe, I assume?)
14:45:39 <AnMaster> Idioms I special case (and variants of them of course): [-] [>] [>+>+<<-]
14:45:51 <AnMaster> ais523, can't you "pre-vote" in US? Or whatever they call it
14:45:58 <ais523> the first is mov, the third is tadd2
14:46:04 <ais523> so they're ABI instructions
14:46:18 <ais523> AnMaster: ABI = gcc-bf's intermediate format
14:46:31 <ais523> two of the three idioms you mentioned appear in the asm
14:46:44 <ais523> yes, with a constant 0
14:46:57 <ais523> mov only does constants in gcc-bf
14:47:04 <ais523> you have to use transfer-addition to copy variables
14:47:08 <AnMaster> ais523, ah.. my compiler calls < and > mov
14:47:30 <ais523> AnMaster: but ABI == asm
14:47:34 <ais523> or at least, it's designed to look like it
14:47:40 <ais523> because gcc expects to output in asm
14:47:45 <fizzie> Er. Our election-days are next Saturday and Sunday.
14:47:57 <ais523> fizzie: elections are on the weekends for you?
14:48:05 <ais523> they're always on Thursdays in the UK
14:48:14 <fizzie> 6th and 7th were also the days in Italy, if I understood the TV programming right.
14:48:22 <AnMaster> +- = add <> = mov [ = loop , = in . = out
14:48:32 <AnMaster> ] never shows up after the parsing.
14:48:59 <AnMaster> ais523, anyway you said you were going to paste an annotated version
14:49:13 <ais523> and I'd better not from this connection
14:49:19 <ais523> because large uploads tend to fail mysteriously
14:49:27 <ais523> and yes, it's slightly larger than the non-annotated version
14:49:30 <ais523> due to having annotations in
14:49:36 <fizzie> "The European Parliament elections began on Thursday in Britain and the Netherlands -- Irish people -- would vote on Friday. In Italy and the Czech Republic the voting process will continue from Friday to Sunday. Elections will begin Saturday in Latvia, Cyprus, Malta, and Slovakia, while in all the remaining 18 EU members the elections will take place on Sunday."
14:50:02 <AnMaster> ais523, anyway [>] [>>] and so on are "seek" for me.
14:50:07 <ais523> so why did AnMaster say he'd already voted?
14:50:08 <AnMaster> and gcc-bf contains quite a lot of them
14:50:22 <AnMaster> ais523, "pre-vote". Can't you do it there? I don't know if that is the right English word
14:50:29 <ais523> AnMaster: they have postal votes
14:50:47 <ais523> but many people don't trust them, parties are accused of rigging them every now and then
14:50:56 <fizzie> We've usually done the pre-voting thing (in the local post office) but now we were in Italy for the pre-voting day. So next Sunday it is.
14:50:58 <AnMaster> ais523, well, here they aren't at the post offices.
14:51:06 <ais523> they're done via the postal service
14:51:07 <AnMaster> the one I went to was at the local library.
14:51:28 <ais523> the idea is that they're for people who are too ill/old/in a completely different part of the country to go to a polling station
14:51:38 <ais523> you get a ballot paper sent to you by post, and send it back by post
14:51:46 <AnMaster> it doesn't work like that here
14:51:55 <ais523> well, there are several problems with the UK way of doing it
14:52:02 <ais523> it defeats the point of secret ballots, for one thing
14:52:07 <ais523> if there are any non-secret ways to vote
14:52:30 <AnMaster> ais523, anyway gcc-bf *does* contains lots of the [>] idiom
14:52:40 <ais523> [>] would be incredibly unusual
14:52:52 <AnMaster> ais523, or variants. Like [>>>]
14:53:02 <ais523> [>>>] and [<<<] are used to go between addresses known at compile-time and addresses that aren't
14:53:30 <ais523> whereas [<<<<<<] and [>>>>>>] are used to jump between registers, the top of the stack, and the bottom of the frame
14:53:55 <ais523> [[>>>>>>]>>>>>>]<<<<<< goes from a fixed cell near the registers to the top of stack marker cell, for instance
14:53:57 <AnMaster> ais523, anyway. I consider [>>] and [>] and [<] variants of the same idiom
14:54:00 <ais523> and the top of stack data is just next to it
14:54:11 <GregorR> <ais523> it defeats the point of secret ballots, for one thing // howzat?
14:54:24 <AnMaster> same as [>+>+<<-] [>+<-] [>>>>+<<<<-] and so on are also variants
14:54:36 <ais523> GregorR: if there's any method of voting via which you can proved which way you voted (such as postal voting, showing someone the ballot before posting), you can be bribed to use it
14:54:56 <ais523> secret ballots are meant to block bribery/extortion by setting things up so that there's no way you can prove what your vote was
14:55:06 <AnMaster> the key is: "index cell is changed with +/-1, a variable number of other cells are changed with +1 (if index cell was -1) or -1 (if index cell was +1)
14:55:41 <AnMaster> that pass isn't used a lot any more, since the polynomial pass can now handle that.
14:56:04 <AnMaster> So nowdays it is just a special case of the polynomial code.
14:56:39 <AnMaster> so probably going to use general polynomial only for that one in the future
15:01:08 <AnMaster> ais523, anyway using gccbfrle parser is now trivial: ./in-between -p hworld1.bfrle
15:01:23 <AnMaster> ./in-between -p gccbfrle hworld1.bfrle
15:03:38 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
15:04:55 <AnMaster> ais523, tell me when you plan to upload that annotated version
15:05:04 <ais523> probably not for a while
15:05:12 <ais523> not even my email is working atm
15:08:28 <AnMaster> hrrm. Is propagating polynomials a good idea? I mean for example: p[0] = 2*p[1] + 5*p[4]; p[-1] = 2*p[0]; could possibly gain from setting p[0] in the second to the expression of the former. But if the value of p[0] was used in several other polynomials it might be worse to do that for each
15:08:36 <AnMaster> ais523, any idea how to figure out if it is a gain or a loss?
15:08:43 <ais523> AnMaster: try both and compare
15:08:58 <ais523> when in doubt, benchmark
15:09:06 <AnMaster> ais523, it could differ from case to case
15:09:16 <ais523> well then, get your compiler to autobenchmark
15:09:29 <nooga> AnMaster: then draw cool charts
15:09:51 <fizzie> Yes; when in doubt, draw a chart.
15:11:53 <AnMaster> ais523, how does gcc handle something like: int a = y + 3*x; int b = 8*a; int c = 4 * a;
15:12:08 <ais523> AnMaster: probably depends on the rest of the program
15:12:10 <AnMaster> and what if the assignment to c wasn't there?
15:12:17 <ais523> but as this is gcc, "badly" is most likely the resulting guess
15:12:28 <AnMaster> ais523, lets assume a better compiler then?
15:12:51 <AnMaster> is clang better for C code yet?
15:13:13 <AnMaster> sometimes faster than gcc, sometimes slower than gcc
15:13:20 <AnMaster> sometimes no significant difference
15:14:29 <AnMaster> I really need to get that "convert to directed graph" pass done...
15:14:40 <AnMaster> but I still have no clue how to handle loops in that.
15:16:38 -!- myndzi has joined.
15:22:51 -!- FireFly has joined.
15:27:29 <tetha> do you have interesting ideas on this matter? I am currently toying around with a little backtracking language (it is basically backtracking via assigning a range of possible values to variables and looking for the fixed point of a rewrite system).. but now I need something for composite types
15:27:54 <AnMaster> tetha, interesting ideas about backtracking? Hm
15:28:04 <tetha> so basically you could say "my variable x can take all combinations of {confused, sane} and {liar, truth}"
15:28:12 <AnMaster> not really. Haven't used backtracking a lot really.
15:28:26 <tetha> or as in einsteins puzzle, like "this house has an inhabitant which comes from this set, and a pet from this set, ..."
15:28:27 <AnMaster> always thought I should try prolog some day though
15:28:34 <tetha> hehe, I dislike prolog
15:28:41 <tetha> too many really akward quirks to make it highlevel imo
15:28:56 <ais523> I like Prolog because it's a really interesting sort of tarpit
15:29:16 <ais523> the whole language can be implemented in terms of its, syntax, comma, and :-
15:29:25 <ais523> s/its, syntax/its syntax/
15:30:43 <tetha> it just grows really annoying if you have to start doing things like f(x,y) :- foo is bar, bar is baz, foo(baz, qux), y is qux, andsoon. and probably I have written down an endless loop due to the order
15:31:13 <ais523> tetha: you could create a version of Prolog which had return values as syntactic sugar easily enough
15:31:17 <ais523> but I'm not sure that would add to the language
15:31:26 <ais523> the symmetry of predicates is one of its nicest features
15:32:09 <tetha> na, I just dislike the need for explicit binding
15:32:36 <tetha> my intuition says that fac(n,i) :- fac(n-1,i/n). or something like that should work
15:32:52 <AnMaster> ais523, btw if you want to mark some bit of code as unreachable, in-between could benefit from there being a easily detectable infinite loop at that point. It can then figure out that "if we don't get here due to a loop/if/whatever not being taken, then we don't need to consider anything in here for constant propagation purposes (or for other passes either)"
15:33:06 <AnMaster> I think esotope-bfc could benefit from that too
15:33:09 <ais523> why would I generate unreachable code?
15:33:23 <ais523> AnMaster: I don't know they're unreachable
15:33:25 -!- myndzi\ has quit (Read error: 110 (Connection timed out)).
15:33:27 <ais523> that's why there's an assert there
15:33:34 <ais523> at least, they ought to be unreachable
15:33:38 <ais523> but I don't know for certain
15:33:38 <AnMaster> ais523, if they are reached, what do you do now?
15:33:58 <AnMaster> I mean. it seems fairly hard to get out of there
15:34:01 <ais523> AnMaster: by setting the IP to 0 and doing another iteration of the main loop
15:34:11 <ais523> it's pretty easy to get out of anywhere, no matter how deeply nested it is
15:34:29 <AnMaster> ais523, how much is this a compiler to bf, and how much is this a compiler to something with a bf VM?
15:34:30 <ais523> set cc0/1/2/3 all to zero, a couple of flag elements to appropriate values
15:34:37 <ais523> and you'll fall right out of the loop
15:34:39 <ais523> and it's a bit of both
15:34:54 <ais523> it's basically a processor emulator in BF, memory-wise
15:34:58 <AnMaster> ais523, that's rather confusing
15:35:03 <ais523> imagine a processor with BF microcode
15:35:24 -!- bsmntbombdood has joined.
15:35:28 <ais523> it's a separate code/data architecture
15:35:34 <ais523> the data is stored in an emulated processor
15:35:38 <ais523> whereas the code is purely BF
15:35:43 <ais523> the processor emulator is also BF
15:35:55 <ais523> but it's just used to jump between bits of memory
15:37:06 -!- BeholdMyGlory has joined.
15:37:43 <AnMaster> ais523, btw, I think in-between can do at least one thing esotope-bfc couldn't last I looked: turn some unbalanced loops into ifs.
15:38:36 <AnMaster> not sure if lifthrasiir handles that now
15:42:23 <tetha> one of the codespikes from yesterday btw looks like this: http://nopaste.org/p/a2MmTTHxl
15:42:34 -!- ehird_ has joined.
15:43:16 <tetha> ais523: I basically wrote down some code which I figured should work and examined if it can be parsed, evaluated and makes any sense at all
15:43:33 -!- pikhq has joined.
15:44:36 -!- ehird has quit (Read error: 104 (Connection reset by peer)).
15:44:50 -!- ehird_ has changed nick to ehird.
15:50:43 <AnMaster> ais523, does this seem sane to you: http://pastebin.ca/1447639 ?
15:50:52 <AnMaster> I don't know enough about this sort of stuff
15:51:03 <AnMaster> and I don't know how to handle some of the cases
15:52:02 <ais523> AnMaster: looks like you're halfway to inventing monads already
15:52:20 <AnMaster> ais523, hm? It is just representing a bit of bf code as a directed graph
15:52:34 <ais523> AnMaster: monads are more ubiquitous than you might think
15:52:55 <AnMaster> currently in-between often isn't able to figure out optimisations across long stretches of irrelevant code
15:53:07 <AnMaster> ais523, do you mean about the IO ordering?
15:53:09 -!- bsmntbombdood has quit (Success).
15:53:48 <AnMaster> ais523, well my plan is that this should allow me to do DCE as well.
15:54:38 <AnMaster> dead stores is what in-between currently is worst at eliminating for non-trivial cases. Due to it being far back in the linked list already, so going back would often be a pain.
15:55:10 <AnMaster> I do try to have some passes scanning backwards, but that doesn't work too well except for trivial cases.
15:55:31 <AnMaster> ais523, anyway, any idea how to handle ifs and similar?
15:56:26 <pikhq> AnMaster: Working on a specializer, or just a compiler?
15:56:44 <AnMaster> ais523, and should I have edges both ways, or just in one direction (that is: either "this is reached by" or "this reaches", or both)?
15:56:58 <ais523> AnMaster: I'm not an expert on such things...
15:57:11 <AnMaster> ais523, anyone here good at it? Or any good resource to read about this?
15:57:35 <tetha> in doubt, the dragon book
15:57:52 <tetha> the dragon book is the holy bible of compiler construction
15:59:04 <tetha> because the cover images usually are dragons of different color
15:59:27 <tetha> dragons and knighs to be precise
16:00:07 <tetha> with LALR-parser-generator-lances
16:00:40 -!- Slereah_ has quit (Read error: 110 (Connection timed out)).
16:01:00 -!- Slereah_ has joined.
16:02:06 <AnMaster> ais523, really what I'm trying to make is a dependency graph...
16:02:46 <tetha> do you mean a control flow graph?
16:04:16 <AnMaster> tetha, possibly dependencies between memory stores. Basically representing BF code as a graph so I can work on that so I can eliminate dead stores and such
16:04:37 <AnMaster> and propagate values/constants and such
16:04:44 <tetha> I think you want to lookat SSA forms and optimizations on such
16:04:49 <AnMaster> currently I have scanning optimisation passes, that just scans forwards.
16:05:20 <AnMaster> tetha, hm... How would one represent a BF loop still? I'm pretty sure I have to end one graph at an unbalanced loop and start a new one after...
16:05:36 <AnMaster> it might be possible to do something
16:05:55 <tetha> loops and ifs in the SSA-form are branches and joins or cycles
16:06:02 <AnMaster> (which are just loops that I previously figured out will run at most once)
16:06:12 <tetha> together with phi-nodes which join the values depending on the edge you come from
16:07:01 <Sgeo> DO_PROCESS [#6236]: [setq(0,u(num_to_exit,rand(1,4)))][u(open,%q0)][switch(rand(0,1),0,u(open,u(next_exit,%q0)),1,u(close,u(next_exit,%q0)))][switch(rand(0,1),0,u(open,u(next_exit,u(next_exit,%q0))),1,u(close,u(next_exit,u(next_exit,%q0))))][switch(rand(0,1),0,u(open,u(next_exit,u(next_exit,u(next_exit,%q0)))),1,u(close,u(next_exit,u(next_exit,u(next_exit,%q0)))))][switch(u(player_x),u(dest_x),switch(u(player_y),u(dest_y),u(do_win)))]
16:07:24 <Sgeo> I could have written that to be less ugly, but it works as is
16:07:37 <AnMaster> tetha, so how does one represent SSA best? The compiler I'm working on is written in Erlang, which is functional and single-assignment...
16:08:22 <AnMaster> there is a built in "digraph" module for directed graphs.. So it would possibly be useful if I could somehow use that.
16:09:14 <tetha> take a look at the article on wikipedia, it's not that bad
16:10:08 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
16:11:35 -!- pikhq has joined.
16:12:37 -!- Slereah has quit ("Leaving").
16:15:43 <AnMaster> tetha, you mentioned control flow graph too. Forgive my ignorance, but when do you use such?
16:18:50 <tetha> you can use it to make statements about the execution of program statements, so for example "i dont need this program statement until that program statement happens, so I can move the first program statement into this branch and thus remove some required computation from before the branch"
16:19:06 <tetha> and moving things into a branch (for example) could improve runtime
16:20:52 <AnMaster> I do similar things for a few simple cases, but not using a graph.
16:22:05 <AnMaster> tetha, ok, I can see how to represent ifs in SSA form. Not sure about loops in general though...
16:22:59 <tetha> how are brainfucks semantics with respect to unbalanced loops?
16:24:01 <pikhq> Work just fine. (making loop unrolling a tiny bit tricky)
16:24:03 <AnMaster> tetha, well I meant "Not sure about balanced loops in general". For unbalanced loops/ifs it probably isn't possible at all. I don't plan to handle those. Rather I would begin a new block after such cases.
16:25:36 <AnMaster> pikhq, for unbalanced loops you can't solve the issue in general. You can possibly figure it out in a few cases. Like +>+>[-]<<[>] will end up at the just zeroed cell.
16:25:56 <AnMaster> in general, it would be TC to figure out where it ends up
16:42:16 <AnMaster> ais523, tell me when you paste that annotated version
16:55:50 -!- BeholdMyGlory has quit (Remote closed the connection).
16:56:15 -!- BeholdMyGlory has joined.
17:04:00 <ais523> nooga: single static assignment
17:04:08 <ais523> instead of a = a + 1 increasing a
17:04:24 <ais523> it creates a new variable (say, a1), does a1 = a + 1, and replaces all uses of a with a1 in the rest of the program
17:04:31 <ais523> looping is left as an exercise to the reader
17:08:39 <AnMaster> ais523, an exercise I fail to figure out
17:09:00 <ais523> AnMaster: lambda binding, to generate infinite new variables
17:09:04 <ais523> nooga: various purposes
17:09:14 <AnMaster> ais523, hm. Not sure what you mean with that
17:09:16 <ais523> it makes implementation a lot easier; some compilers (such as gcc) compile via that form
17:09:35 <ais523> although gcc doesn't use SSA for loops, just for basic blocks
17:10:19 <AnMaster> ais523, I have it figured out for basic blocks and for balanced ifs. Not for anything else though...
17:10:33 <ais523> imbalanced ifs, it's obviously impossible
17:10:38 <ais523> balanced whiles should be easy though
17:10:55 <ais523> AnMaster: same way as ifs
17:11:04 <ais523> a while loop is equivalent to an infinite chain of igs
17:11:25 <AnMaster> ais523, so phi(var-before-loop, var at end of loop) at the beginning of the loop?
17:11:43 <ais523> I'm trying to debug TAEB's Sokoban spoilers
17:11:52 <ais523> AnMaster: as in, I don't particularly care, because I'm working on something else
17:11:57 <AnMaster> ais523, what was the lambda thing you mentioned btw?
17:12:10 <ais523> AnMaster: looping via recursions
17:12:18 <ais523> because an SSA progam can't loop via iteration
17:12:19 <AnMaster> ais523, as for ifs I meant "balanced ifs with no loops inside"
17:12:39 <ais523> a while could use infinite variables
17:12:52 <ais523> I mean, while(1) {a++;} doesn't have an SSA form
17:13:06 <AnMaster> ais523, so what do you do when you hit a loop like that
17:13:25 <ais523> if you want to be really insane, you could replace while loops with state machines
17:13:31 <ais523> but decompiling them afterwards would be a pain
17:13:35 <ais523> and it wouldn't work on unbalanced loops
17:13:42 <AnMaster> such as [+] (except I would have converted that to a "set" already)
17:14:22 <AnMaster> but surely there are more complex ones I haven't handled already
17:15:07 <AnMaster> ais523, how would you handle that example in SSA?
17:15:25 <ais523> AnMaster: you can't, there are clearly an infinite number of variables
17:15:33 <ais523> normally people break SSA slightly at such points
17:16:10 -!- MigoMipo has joined.
17:16:23 <ais523> AnMaster: something else
17:16:31 <ais523> ordinary imperative-style, for instance
17:16:41 <AnMaster> ais523, what if you know the loop is finite, but don't know number of iterations. Like ,[>++>,.<<-]
17:16:42 <ais523> put it this way: you can't SSA an entire program without some form of recursion concept
17:16:59 <ais523> AnMaster: if you know max iterations, you could unroll it
17:17:02 <ais523> probably not worth it though
17:17:19 <AnMaster> ais523, yes I realise I have to give up on unbalanced loops. But question is, do I have to give up on balanced ones too?
17:17:35 <ais523> you don't have to, but possibly you should
17:17:49 <ais523> you can rely on the fact that variables max out at 255 to work out the max number of iterations
17:17:58 <ais523> then convert to a chain of ifs
17:18:16 <AnMaster> ais523, that would be pessimsation
17:20:05 -!- impomatic has joined.
17:20:12 <AnMaster> ais523, how does SSA form relate to control flow graph btw. Do they coexist for different bits... or do they somehow conflict?
17:20:31 <nooga> http://nopaste.org/p/a2MmTTHxl < does it work?
17:20:33 <AnMaster> and how would one implement control flow graph for bf in general..
17:21:10 <AnMaster> nooga, why not test it yourself. You haven't even told us what language it is in...
17:22:24 <AnMaster> then what do you want us to do about it
17:23:25 <nooga> someone pasted it previously
17:23:30 <nooga> i thought he's still here
17:24:04 -!- KingOfKarlsruhe has joined.
17:24:11 * pikhq goes off to futz with his specialiser.
17:24:14 <Deewiant> tetha's still here, for certain values of "here"
17:24:27 <pikhq> The hard part is, of course, the freaking loop unrolling.
17:24:48 <AnMaster> pikhq, it isn't too bad when loop is balanced.
17:29:02 <AnMaster> I don't think I can currently handle [->[->++<]<] for example.. it ends up as something like: while(p[0]) { p[0]-=1; p[2]+=2*p[1]; p[1] = 0; } unless I can figure out iteration count of the outer loop.
17:29:06 -!- MigoMipo has quit ("http://www.mibbit.com ajax IRC Client").
17:31:30 <nooga> pikhq: writing a specializer? :D
17:42:26 * AnMaster considers a C processor. Not sure how
18:01:43 -!- AnMaster has quit (Connection timed out).
18:03:14 <ais523> hah, bing's autocompletions for "linux" are hilarious
18:03:35 <ais523> "linux", "linux windows", "linux microsoft", "linux vista" are the first four
18:17:19 <ais523> Gracenotes: I checked less than 20 minutes ago
18:17:24 <ais523> so I'd be surprised if it wasn't
18:17:59 <Gracenotes> I suppose they're not too concerned about the well-publicized screenshot. Not like they would be
18:18:46 <Sgeo> Do not pull off your head to avoid dissolution. It never works.
18:19:51 <Gracenotes> anyway, Linux Vista is my favorite OS!
18:20:53 <Deewiant> Why should it change? It'll adapt to the users
18:22:20 <ais523> the worrying thing is, people will see the famous autocomplete and do the searches it suggests out of curiosity
18:22:24 <ais523> so it's a self-reinforcing loop
18:30:05 -!- inurinternet has joined.
18:34:58 -!- AnMaster has joined.
18:37:03 <pikhq> My specialiser is currently doing as little loop unrolling as possible...
18:39:17 <nooga> you specialize bf interpreter written in C?
18:39:39 <pikhq> Nah, hacking it together in Tcl.
18:39:46 <pikhq> And... Specialise BF interpreter? Wha?
18:42:58 <nooga> i mixed your specializer with AnMaster's compiler
18:43:43 <pikhq> If I wanted a good specialiser, I'd probably start by forking esotope...
18:43:53 <pikhq> As it is, meh. I can hack something together rather quickly.
18:44:39 <nooga> AnMaster: decompiler?
18:44:48 <AnMaster> pikhq, esotope-bfc is in python btw
18:44:56 <AnMaster> nooga, what are you talking about. Notice I just joined
18:45:21 <pikhq> AnMaster: Yeah, I know. I've read it.
18:46:29 <AnMaster> pikhq, and what is your specialiser taking as input and generating as output? I know what a specialiser is in theory. But I assume you need to take some specific input format still
18:47:17 -!- jix_ has joined.
18:48:09 <pikhq> AnMaster: Part of stdin, generating Brainfuck code.
18:49:22 <AnMaster> pikhq, so the original program you are specialising is in BF? And the output is a specialised bf program?
18:49:39 <AnMaster> also wth is it that is disk trashing every few seconds..
18:49:52 <pikhq> Not exceptionally useful, I know. ;)
18:57:23 <nooga> instead of writing specializer i'd just write sadol->exec compiler in ruby
18:57:33 <nooga> then rewrite the compiler in sadol
18:57:51 <nooga> and i'd end up with sadol->exec compiler in sadol
18:58:15 <nooga> that would be able to compile itself
18:58:59 <pikhq> A specialiser is much more interesting, though.
18:59:12 -!- jix has quit (Read error: 110 (Connection timed out)).
18:59:41 <nooga> but it makes my brain sore
19:00:09 <pikhq> That's because you fail.
19:02:26 * pikhq observes that LostKingdom doesn't get much out of his method of specialisation
19:02:53 <pikhq> ... Since it kinda has a "Would you like to play again?" thing at the end.
19:05:17 <AnMaster> <pikhq> Not exceptionally useful, I know. ;)
19:05:39 <AnMaster> what about a bf interpreter written in bf, and a bf program
19:06:14 <AnMaster> pikhq, also... why would the "Would you like to play again?" prevent anything if you answered n ?
19:06:33 <AnMaster> pikhq, and one of the best things for lostkingdom is to do dead code elimination
19:06:39 <ais523> the save could also confuse things
19:06:53 <ais523> AnMaster: it saves to memory
19:06:59 <ais523> but you can reload from the same bit of memory
19:07:29 <AnMaster> ais523, but isn't that a bit pointless. Or can you ask it to dump it so you can write it in a file?
19:07:55 <ais523> but it's useful for going back when you've made a mistake
19:08:01 <ais523> to prevent having to restart whenever you die
19:08:19 <ais523> I do have actual save files of Lost Kingdom, but only because I wrote a serialising BF interp
19:15:38 -!- kar8nga has joined.
19:20:17 <AnMaster> ais523, what about pasting that annotated one btw?
19:24:22 <ais523> AnMaster: <http://filebin.ca/wtdmcm/hworld.annotated.bfrle>, enjoy
19:24:27 <ais523> the annotations are comments starting with %
19:24:37 <ais523> which are actually comments, they don't affect the program, just comment on it
19:25:50 <pikhq> AnMaster: My specialiser does dead code elimination, just because it's trivial.
19:27:56 <pikhq> If LostKingdom didn't have that "Would you like to restart" bit, it could trivially generate a version of LostKingdom without long or short output...
19:28:49 <pikhq> ais523: Hmm. So, GCC-BF works to some extent?
19:28:56 <impomatic> Was BF Joust inspired by any other programming game? I haven't seen a capture the flag game before.
19:29:08 <ais523> that hello world was doctored until it worked
19:29:14 <ais523> impomatic: it was loosely inspired by corewar, I think
19:29:30 <ais523> capture-the-flag wouldn't really work in most langs, I imagine
19:29:39 <pikhq> Also, Brainfuck Mode... Hmm.
19:29:47 <ais523> and it's only half of capture-the-flag, as you don't have to transport the flag back to your own base
19:32:41 * pikhq might want the source for that Brainfuck mode
19:33:13 <ais523> pikhq: it's floating around on pastebin somewhere
19:39:34 -!- tetha has quit (Read error: 60 (Operation timed out)).
19:43:01 -!- tetha has joined.
19:43:01 -!- KingOfKarlsruhe has quit (Remote closed the connection).
19:43:01 -!- BeholdMyGlory_ has joined.
19:43:52 <ais523> AnMaster: it introduces annotations
19:43:55 <ais523> which show tape positions
19:44:03 <ais523> %2512 means "the pointer is definitely at tape location 2512"
19:44:16 <ais523> and bfrle will dump tape if it isn't, to aid in debugging
19:44:24 <AnMaster> ais523, anything else that might mess up parsing if you just discard these?
19:44:43 <ais523> AnMaster: it means that the pointer is currently at the mark
19:44:49 <ais523> which is a memory location which can be moved to and from easily
19:45:06 <ais523> the mark is marked by writing a 0 in the line of 1s that's at every third location, and that I go to so much trouble setting up
19:45:07 <AnMaster> ais523, there isn't anything describing those idioms your mentioned though
19:45:16 <ais523> so I can jump from the mark to the left end of the tape using [>>>] [<<<]
19:45:26 <ais523> well, one or the other, depending on which way I'm going
19:45:52 <AnMaster> (or whatever it was you mentioned before)
19:46:12 <AnMaster> stuff that will not mess up for other bf programs that aren't from gcc-bf.
19:46:18 <ais523> there's a text file somewhere, but it's wrong and out of date
19:46:19 <pikhq> When GCC-BF works moderately well, I think I'll have to write a Brainfuck specialiser in C. ;)
19:46:32 <AnMaster> ais523, Hm. Since I don't have a local copy of the source...
19:49:08 -!- kar8nga has quit (Remote closed the connection).
19:49:18 <AnMaster> ais523, So. Any chance of getting a copy of it?
19:49:29 -!- BeholdMyGlory has quit (Success).
19:49:38 <ais523> AnMaster: not right now, I'm busy
19:49:51 <ais523> and it doesn't work properly yet, although you're free to try to make it work by yourself
19:50:14 <AnMaster> ais523, well. Knowing the idioms would be potentially useful in any case
19:50:20 -!- BeholdMyGlory_ has changed nick to BeholdMyGlory.
19:50:27 <ais523> I don't even know how many are correct
19:50:39 * AnMaster wonders about some generic way to represent special cased idioms that won't require updating all the optimiser passes
19:51:13 <ais523> AnMaster: something like OIL?
19:51:57 <AnMaster> ais523, hm? I mean if I add a "32 bit addition" node I need to add code to all the optimiser passes to tell them how to handle it
19:52:11 <ais523> OIL just used C to represent all the intermediate code
19:52:20 <ais523> and only one optimiser pass needed that information
19:52:24 <ais523> so I just special-cased it
19:52:25 <AnMaster> the constant propagation pass needs to know what instructions clobber and what ones doesn't
19:52:46 <ais523> c = d; /* d not clobbered */
19:52:54 <ais523> c = d; d = 0; /* d clobbered */
19:52:57 <AnMaster> ais523, sure. that would be a polynomial
19:53:15 <AnMaster> but lets say I add "32-bit addition", then that means 4 cells will be clobbered
19:53:15 <ais523> if you use a simple language to represent the transformations, there's no need for hundreds of special cases
19:53:20 <ais523> just a few general ones
19:53:28 <ais523> 32-bit addition wouldn't be a single node
19:53:31 <AnMaster> ais523, I'm not C specific. I can have other backends
19:53:32 <ais523> but a C description of what the operation did
19:53:39 <ais523> and there's no real reason to pick C in particular
19:53:46 <ais523> except it has a decent instruction set for this sort of thing
19:53:58 <ais523> you just need some simple arithmetic language to represent what the idioms are doing
19:53:59 <AnMaster> ais523, I mean, all code tries to be backend agnostic. I plan to add other output languages too
19:54:14 <ais523> OIL's backend agnostic too, doesn't mean it can't use C operators internally
19:54:32 <AnMaster> ais523, sure. But lets consider turning [>] into a special "seek" node. Agree that other passes need to know that it is unbalanced for example?
19:54:47 <AnMaster> and passes need to know IO instructions can't be reordered
19:54:52 <ais523> it sets the IP to a different value to what it has originally
19:55:02 <ais523> therefore, you can deduce it's unbalanced by looking at the resulting code
19:55:13 <AnMaster> ais523, yes. But I reorder > relative other stuff (except seek and unbalanced loops).
19:56:27 <AnMaster> I change to use "offsets from current base" and then the > and < pile up in front of the next place they can't move past
19:56:27 <AnMaster> they are then merged into a single move node there
19:56:27 <AnMaster> anyway, later on some other pass might remove that loop if it found out that it was a dead loop
19:56:33 <AnMaster> the constant propagation pass for example
19:56:44 <AnMaster> they those > are now free to move forwards even more
19:57:14 <ais523> it's a case of ip++; ip--;
19:57:17 <ais523> which can pile up, and combine
19:57:24 <ais523> but that's just still a simple C operator
19:57:26 -!- impomatic has left (?).
19:57:34 <ais523> if you need to know if something's imbalanced, look to see if it assigns to the IP
19:58:08 <ais523> that's a[x]=0; ip++; a[x]+=2; ip--; while(a[x]) ip+=2;
19:58:22 <ais523> after one pass of your optimiser, that will become a[x]=0; a[x+1]+=2;
19:58:27 <ais523> and at that point, there are no assignments to the ip
19:58:32 <AnMaster> the passes, such as "combiner", "shifter", "constant propagator", "loop analysis", "initial memory assumed to be 0" and so on are run after each other until nothing changes
19:58:32 <ais523> so it now knows the loop is balanced
19:58:38 <ais523> and can do more optimisations
19:58:41 <AnMaster> lostkingdom takes something like 10 iterations
19:58:45 <ais523> you just run all the passes repeatedly until you get no change
19:59:27 <ais523> AnMaster: so really, you don't need a balanced/unbalanced loop flag at all
19:59:27 <AnMaster> ais523, the point is, if I add a new type of "node" in my "parse tree", the various passes need to know what to do with it
19:59:27 <ais523> just as long as you use a simple enough representation for your intermediate forms
19:59:27 <AnMaster> or they could produce broken code
19:59:27 <ais523> you /do not add new nodes/
19:59:29 <ais523> you use just a few nodes, and assemble programs out of them
19:59:36 <ais523> if, while, +, -, *, /, = should be enough
20:01:10 <AnMaster> ais523, you forgot "repeat". When you know number of iterations
20:01:10 <AnMaster> but when unrolling would be a bad idea
20:01:10 <AnMaster> like huge ones with lots of stuff that is hard to fold
20:01:10 <ais523> while loop with a separate counter?
20:01:10 <ais523> that'll be optimised by the C compiler better than you could optimise it by hand
20:01:10 <AnMaster> (it turns into something like {int i; for (i=0; i<12; i++) { foo }}
20:01:33 <ais523> that's {int i=0; while(i<2) {foo; i++;}}
20:01:33 <AnMaster> ais523, but how could a normal loop node represent it?
20:01:48 <ais523> they are equivalent, as long as you aren't messing with break/continue, and you aren't
20:01:53 <ais523> so there it is, represented with a while node
20:02:03 <AnMaster> ais523, but various passes exploit the fact that the iteration count is known
20:02:15 <ais523> they can match that specific pattern, then
20:02:17 <AnMaster> like knowing it will always be run if we hit it
20:02:25 <ais523> or do you not have powerful pattern matching?
20:02:38 <ais523> what I mean is, you write your repeat node in terms of low-level instructions
20:02:38 <AnMaster> unlike a while loop in general, which might have 0 for current cell and thus never run
20:02:44 <ais523> so you don't have to special-case it everywhere
20:02:47 <ais523> only in the few places it matters
20:03:43 <AnMaster> well, for loops and loop like I do have a general way. But when you add "complex expression" instead of just "set, add" then things aren't so easy
20:05:40 -!- oerjan has joined.
20:06:33 <AnMaster> ais523, in particular the various passes need to know if the instruction 1) has a body (loops, ifs, ...) 2) performs IO (thus need to be strictly ordered compared to other instructions) 3) is unbalanced with variable movement (thus you can't assume values are at the offsets you expect after) 4) moves pointer fixed amount (yes this is needed, otherwise you couldn't figure out a dead unbalanced loop lik
20:06:33 <AnMaster> e >[-]>++<[>>], the constant propagator need to offsets it's known data at the > before the unbalanced loop)
20:06:45 <oerjan> * ais523 wonders how defend7 can /still/ be third on the BF Joust leaderboard, after all this time...
20:06:55 <AnMaster> 5) What cells are read and what cells are written
20:07:10 <oerjan> if your R/P/S theory is correct, maybe few others have tried to make defenders?
20:07:13 <AnMaster> ais523, I guess you could have some generic "introspection" framework for telling this
20:07:21 <ais523> oerjan: *counterdefenders?
20:07:30 <ais523> but they have been, to knock defend9 down
20:08:07 <ais523> AnMaster: generic's the idea
20:08:07 <AnMaster> ais523, but in general, optimising to high level "intrinsics" allow better output. So just representing things in low level terms isn't such a bright idea either...
20:08:07 <oerjan> ais523: oh so defend.* does not mean a defending program?
20:08:13 <AnMaster> ais523, I considered a generic "reverse inliner"
20:08:20 <ais523> oerjan: defend* are defending programs
20:08:21 <AnMaster> for moving parts often used out in separate functions
20:08:28 <AnMaster> it might be useful for stuff like gcc-bf
20:08:31 <ais523> but in order to make a defence program do badly, you need a counterdefence program
20:08:37 <ais523> rather than a second defence program
20:08:51 <AnMaster> but I don't think it would be impossible
20:09:37 <oerjan> ais523: um i thought the other way around, if you have R/P/S then there will always be a balance between the three types, so the only way to truly remove something is by outcompeting it by things in its own class?
20:09:52 <ais523> oerjan: ah, interesting
20:09:55 <oerjan> of course that would only hold up to a poin
20:10:01 <ais523> I think the problem is that there isn't a balance
20:10:10 <ais523> there's so much attack there that defence does well and counterdefence does badly
20:10:52 <oerjan> so to restore balance, add more defence
20:12:02 <AnMaster> ais523, so how would your simple base thing handle that
20:12:13 <AnMaster> suddenly you have separate trees.
20:12:16 <oerjan> i guess a balance would require all three types to participate equally in the arms race
20:12:34 <ais523> AnMaster: you record a description of what the function does
20:12:53 * oerjan automatically thinks of dinosaur growth...
20:13:44 <oerjan> except predator/prey is not R/P/S afaik
20:13:48 <AnMaster> ais523, and if you wanted to make an SSA form pass or group of passes then you need the SSA -> BF and BF -> SSA to be able to transform all relevant instructions
20:14:07 <ais523> AnMaster: you can express SSA pretty well with just the operators I stated
20:14:45 <AnMaster> sure. Still some stuff ends up better as intrinsics than with those basic things. Because now other passes can see an idiom with much less work
20:15:11 <AnMaster> ais523, anyway you forgot the difference between "output cell" and "output constant list of values".
20:16:11 <ais523> outputting a constant list is just a row of output-constant
20:16:17 <ais523> you can handle that specially in the back end
20:16:23 <ais523> but there's no need to handle it specially before then
20:16:30 <ais523> because special-casing for no good reason = bad
20:16:51 <AnMaster> ais523, as for writing all passes in something like OIL. I can't see that working for more than handling idioms. It wouldn't handle constant/copy/value propagation across long stretches of code very well would it?
20:17:16 <ais523> if you use a proper tree structure, you can just have an "arbitrary code here" node
20:17:30 <ais523> you'd probably need to generalise slightly to "arbitrary code not containing X here"
20:17:32 <AnMaster> ais523, OIL can build some sort of internal state of known state of stuff?
20:17:37 <ais523> but not much more than that
20:17:41 <ais523> and OIL is a tree-rewriter
20:17:45 <ais523> the entire relevant state is on the tree
20:17:53 <ais523> /because/ it's all so simple
20:18:06 <ais523> you want to know if a particular element is assigned to? See if there's an assignment to it!
20:18:12 -!- tombom has joined.
20:18:21 <AnMaster> ais523, so what is the proper tree structure for BF?
20:18:53 <ais523> and my guess is, initially it's just a chain of commands, with [] going to subtrees
20:18:59 <ais523> and it would get more convoluted as you optimised
20:22:09 <AnMaster> <ais523> and my guess is, initially it's just a chain of commands, with [] going to subtrees
20:23:31 <AnMaster> constant folding requires carrying some sort of state describing what you know are you are going along
20:23:50 <ais523> or pattern matching across the tree
20:23:53 <ais523> the tree /is/ the state
20:24:05 <AnMaster> ais523, a bit hard to do across long stretches of code
20:26:40 <ais523> you just have a generic (lots of code that doesn't mention X or move the IP)
20:26:40 <AnMaster> ais523, you suggest I write a DSL then?
20:26:40 <ais523> if it would help to abbreviate lots of repetitive code, yes
20:26:40 <ais523> I wrote OIL because I realised dekludge.c was forming a pattern, and generating it automatically would avoid mistakes
20:26:40 <ais523> and speed and ease editing
20:27:48 <AnMaster> ais523, my passes aren't really forming a pattern though, except what can be described in three lines of code: return new parse tree at end of list (either end of loop/if/whatever, or end of program, no need to make a difference, except in one of the passes), recurse into the body of the blocks.
20:28:04 <ais523> then you're doing it wrong, piling special-case on special-case
20:28:07 <AnMaster> two passes, the shifter and the combiner operate on two instructions at a time.
20:29:20 <AnMaster> otherwise most handle one at a time
20:29:20 <AnMaster> ais523, writing a new pass isn't a lot of work for the basic bit. I do have some generic information about stuff functions
20:29:20 <AnMaster> like "is a loop", "is io" and so on
20:29:39 <AnMaster> so I don't even need to care if it is input or output, just "does this clobber anything?"
20:30:07 <AnMaster> ais523, also I'm dropping some special cases, like "set from", since the polynomial code handles that now.
20:31:04 <AnMaster> ais523, doesn't gcc has quite a few special cases iirc. Or maybe I misremember
20:31:17 <AnMaster> not saying gcc is a good compiler
20:31:33 <ais523> gcc more has absent cases
20:31:56 <ais523> if something doesn't turn up in most of the architectures it targets, the code for it in core generally just doesn't work
20:31:58 <AnMaster> ais523, ah, you mean it doesn't properly handle stuff thus producing bad code?
20:32:06 <ais523> and all the processors that need it have their own workarounds
20:32:26 <AnMaster> why not file patches to fix it
20:33:08 <AnMaster> ais523, you, or others who work on such cpus
20:33:17 <AnMaster> I guess other uncommon ones could hit such code too
20:33:19 <ais523> because I'd then have to take the trouble to work out how it all worked
20:33:30 <AnMaster> ais523, what about filing bugs then?
20:34:13 <ais523> you'd need to invent a fictional architecture
20:34:48 <AnMaster> ais523, anyway if I do find some copy of gcc-bf source, where would I find the idioms. I think I might have your first public version on another computer (which isn't easy to reach atm...)
20:35:05 <AnMaster> it probably was one only generating asm, and no bf
20:35:10 <ais523> AnMaster: the ABI for them would be in the .md file
20:35:18 <ais523> and the translation of ABI to BF is in bf-ld
20:35:30 <AnMaster> ais523, I think that one was from before bf-ld was working
20:35:41 <ais523> it still isn't working
20:35:46 <ais523> as in, some ABI just isn't translated
20:35:53 <AnMaster> ais523, I saw that hello world you gave me
20:36:21 -!- ehird has left (?).
20:36:28 <AnMaster> ais523, anyway back then I think there was no bf-ld at all
20:36:35 <ais523> and even what is written is mostly untested
20:36:51 -!- ehird has joined.
20:36:53 -!- ehird has changed nick to ehird_.
20:36:59 <ehird_> nooga: you want complex control flow
20:37:02 -!- ehird_ has changed nick to ehird.
20:37:15 <AnMaster> ais523, would be useful to know the tested idioms though, stuff you know work and which might be useful to optimise better.
20:38:15 <AnMaster> otherwise I'm going to continue to try to make mandelbrot.b, LostKng.b, life.b as good as possible instead. Because IMO the output from gcc-bf is just too hard to handle
20:38:15 <ais523> I'm not sure I know if any of it works
20:38:16 <ehird> 02:12 pikhq: Hahah. I just discovered a partial evaluator for Tcl.
20:38:29 <AnMaster> ais523, you know that hello world works I assume?
20:38:30 <ais523> addition sort-of works, but I'm not yet sure if it does carries correctly
20:38:35 <AnMaster> not that I'm able to compile it.
20:38:40 <ais523> for all I know that pointer didn't cross a 256-byte boundary
20:39:37 <AnMaster> ais523, gcc OOMs generally. Using a ulimit of 1 GB. Anything more and I end up swap trashing badly
20:40:23 <AnMaster> ais523, I guess I could try clang. But the computer with it on has 512 MB RAM and is a pentium3. So maybe when I have time to build it on here instead.
20:40:23 <pikhq> ehird: http://wiki.tcl.tk/14514
20:40:38 <pikhq> Incredibly unuseful.
20:40:41 <ehird> 13:33 AnMaster: [.>] would be "output nul-terminated string" wouldn't it? Assuming current cell is known to be non-zero. Otherwise same but in a "if".
20:40:42 <ehird> 13:33 AnMaster: that could possibly be optimised somehow...
20:40:46 <ais523> what about splitting the output program into several files?
20:40:51 <pikhq> ... Doesn't even do the first projection usefully.
20:40:51 <ehird> the incredibly difficult print(tape)
20:41:12 <ais523> you'd have to move the pointer to the end of that bit, though
20:41:13 <AnMaster> ehird, one issue. You need to do strlen() to figure out where the pointer ends up after
20:41:19 <ehird> 13:45 ais523: incidentally, Europeans here, have you remembered to vote in the elections?
20:41:24 <ehird> bit of a problem there
20:41:25 <ais523> ehird: you weren't here
20:41:53 <ais523> did you nonetheless go to the ballot station and complain about not being given a ballot paper?
20:41:56 <AnMaster> ais523, however, I suspect optimising gcc-bf output just isn't worth it in general. It generates too bloated output for it to currently be a useful high level language to write BF programs in. Even BFBASIC managed better.
20:42:11 <ais523> AnMaster: it's not designed for writing BF
20:42:13 <ehird> 14:12 AnMaster: is clang better for C code yet?
20:42:15 <ais523> but to compile C programs to BF
20:42:19 <ehird> it can optimize an array into variables for instance
20:43:04 <ehird> 20:39 ais523: not even with -O0?
20:43:04 <ehird> 20:39 ais523: I'm disappointed
20:43:05 <AnMaster> ais523, hm. Not sure who would use it?
20:43:07 <ehird> his computer sucks badly
20:43:21 <ais523> ehird: it's probably better than mine
20:43:29 <ehird> 20:41 AnMaster: ehird, one issue. You need to do strlen() to figure out where the pointer ends up after
20:43:39 <ehird> just put print() or w/es source
20:43:43 <ehird> and use the tape directly
20:43:47 <ehird> 20:41 ais523: did you nonetheless go to the ballot station and complain about not being given a ballot paper?
20:43:50 <AnMaster> ehird, what are you talking about
20:43:53 <ehird> i'm pretty sure I don't want other 13-year-olds voting
20:43:55 <ais523> ehird: you have to move the pointer, because that's what [.>] does
20:44:00 <ais523> in addition to doing output
20:44:06 <ais523> but for style points, just use the return value of printf
20:44:09 <ehird> 20:43 AnMaster: ais523, hm. Not sure who would use it?
20:44:12 <ehird> nobody, it's for fun...
20:44:17 <AnMaster> ais523, thanks for explaining that simple statement to ehird.
20:44:23 <ehird> AnMaster: i know what the fuck it meant
20:44:24 <ais523> admittedly, that's a bad idea for other reasons
20:44:29 <ehird> 20:43 ehird: just put print() or w/es source
20:44:29 <ehird> 20:43 ehird: and use the tape directly
20:44:34 <AnMaster> ehird, then why say something so stupid
20:44:34 <ehird> that's exactly what ais523's would do
20:44:38 <ehird> .... what the fuck did I say?
20:44:54 <ehird> i replied to your comment simply then ais523 restated it and you hail him in a passive-agressive complaint at me?
20:44:57 <ais523> ehird: [.>] is int temp = printf("%s",tape); tape += temp;
20:44:57 <ehird> what the hell did I say that was stupid?
20:45:03 <ehird> ais523: i know that, i'm not an idiot
20:45:09 <ehird> i was talking about avoiding printf overhead
20:45:11 <ais523> AnMaster thinks you missed the tape += temp at the end
20:45:23 <AnMaster> ehird, I can't see where he mentioned it
20:45:25 <ehird> any print function will advance a local variable pointer for that
20:45:30 <ehird> so if you put the print source directly in the program
20:45:33 <ehird> it'll advance the tape pointer
20:45:41 <ehird> maybe you're the stupid one, for not understanding that?
20:45:50 <AnMaster> ehird, So what would "w/es" mean
20:45:59 <ehird> print() or whatevers
20:46:09 <ais523> actually, fputs is probably the right command here
20:46:11 <ehird> as in print() was a hypothetical fputs(stdout,...)
20:46:13 <ais523> not puts, because it adds a newline
20:46:15 <ehird> ais523: right, I just forgot which way fputs was
20:46:35 <AnMaster> puts() and fputs() return a non-negative number on success, or EOF on error.
20:46:56 <ehird> AnMaster: moron (hey, I can insult people who don't understand too). i said UNROLL THE SOURCE OF THAT INTO THE CODE
20:47:01 <ehird> AT ONE POINT IT WILL DO "PTR += BUFSIZE"
20:47:06 <ehird> SO IF YOU S/PTR/TAPEPOINTER/
20:47:11 <ehird> AND UNROLL THE CODE INTO THE GENERATED PRORGAM
20:47:15 <ehird> IT AVOIDS STRLEN()
20:47:16 <ehird> AND STILL ADVANCES
20:48:07 <AnMaster> ehird, except unrolling the source of it would be mostly pointless. Since the point of using such a call in the first place was to avoid system call overhead of repeated putchar.
20:48:16 <ehird> ..................
20:48:26 <ehird> what the fuck do you think fputs does? outputs multiple chunks
20:48:38 <AnMaster> ehird, it outputs it in chunks yes.
20:48:44 <ehird> ........................
20:48:45 <ais523> actually, I think it blits into the stdio buffer
20:48:49 <ais523> and flushes if necessary
20:48:50 <ehird> AnMaster: and then advances the pointer ithas
20:49:06 <ais523> there's no syscall involved at all if the output isn't flushed after it IIRC
20:49:10 <ehird> ais523: can you explain it to him plz? kthx
20:49:19 <AnMaster> ais523, anyway. Then it isn't much different from: while(p[0]) { putchar(p[0]); p++; }
20:49:25 <ais523> well, even without inlining, you can exploit the return value of fputs
20:49:26 <AnMaster> so there is no point in optimising it
20:49:30 <ehird> AnMaster: ... of course it is
20:49:36 <ehird> do you know how stdio works at all
20:49:42 <ehird> go read your fpust source
20:49:47 <AnMaster> ehird, no. because putchar also blits into said buffer iirc
20:49:52 <ais523> ehird: actually, the putchar version and fputs version could be optimised into the same thing by a decent compiler
20:49:58 <ehird> ais523: of which gcc is not one
20:50:02 <ais523> they both translate to a block memcpy, with a bit of bookkeeping
20:50:21 <ais523> I know gcc tries to optimise that, I don't know how good at it it is, though
20:50:40 <AnMaster> ais523, you can't since it is undefined what the return value means for fputs. Except that it is "non negative on success".
20:50:45 <AnMaster> Doesn't say it will be the length
20:50:56 <ais523> it's definitely the length for printf
20:50:57 <AnMaster> <AnMaster> puts() and fputs() return a non-negative number on success, or EOF on error.
20:51:20 <ehird> pikhq: that peval is ridiculously broken
20:51:31 <ehird> http://wiki.tcl.tk/14514
20:51:54 <ais523> nah, I can't be bothered
20:52:02 <ais523> and I haven't been to sleep for 24 hours now, come to think of it
20:52:02 <pikhq> ehird: It's a quick hack. ;)
20:52:08 <ehird> ais523: then I won't bother linking in future
20:52:18 <ehird> as I am not everyone's personal web/backlog searcher.
20:52:45 <nooga> complex flow control?
20:53:29 <ais523> ehird: it's more that the channel-jumping took me by surprise
20:53:32 <ehird> so that the specializer knows more about how the program flows
20:53:40 <ais523> if it's referencing something in another channel, no surprise I didn't get it
20:53:41 <ehird> ais523: i didn't jump channel
20:53:44 <ehird> it was in this channel
20:53:45 <AnMaster> nooga, complex flow control WHERE?
20:53:52 <ehird> AnMaster: read backlog
20:53:54 <ais523> I assumed you were linking to the logs of another channel
20:53:58 * ehird assigns a hotkey to "read backlog"
20:53:58 <AnMaster> ehird, what specific part of it
20:53:59 <ais523> based on saying "read backlog" and giving a link
20:54:10 <ehird> AnMaster: don't you have a search feature?
20:54:41 <AnMaster> ehird, not easily atm. Since I recently reconnected to bouncer. I'm having hardware problems. So I keep having to restart stuff.
20:54:48 <ehird> load tunes.org, Ctrl-F.
20:55:03 <ehird> AnMaster: then don't complain to people
20:55:13 <nooga> ehird: can't imagine how to design something more complex than loops, ifs and functions
20:55:28 <ehird> nooga: write the SADOL interpreter, and look at any control flow patterns or verbosity
20:55:32 <ehird> invent constructs to shorten them
20:59:25 <AnMaster> nooga, I think ehird means like if you see something like "if (a == 1) ... else if (a == 2) ... else if (a == 4) ... else if (a = 7) ..." you might suddenly get a bright idea and invent "switch (a) { case 1: ... case 2: ... case 4: ... case 7 ... }" instead.
20:59:34 <AnMaster> But I'm not sure. Considering how cryptic ehird can be
20:59:40 <ehird> 20:55 ehird: nooga: write the SADOL interpreter, and look at any control flow patterns or verbosity
20:59:41 <ehird> 20:55 ehird: invent constructs to shorten them
20:59:43 <ehird> that's not cryptic at all
20:59:49 <ehird> that's perfectly normal english, what do you want me to do, use Basic English?
20:59:59 <nooga> but switch is harder to specialize?
21:00:08 <oerjan> i was going to say that
21:00:13 <AnMaster> ehird, in general. I consider all you say to potentially mean something else. Even if I don't see anything strange in it.
21:00:20 <ais523> and I guessed you were going to say "I was going to say that"
21:00:21 <AnMaster> it seems to be the best solution for you
21:00:31 <ais523> if I'd been quick enough, I'd have said "I was going to say that" first
21:00:36 <ais523> so as to steal your next response too
21:00:37 <ehird> 20:59 nooga: but switch is harder to specialize?
21:00:48 <ehird> nooga: stop thinking about a specializer; just give it the richest structures you can
21:00:49 <ais523> then your "I was going to say that" would be a correct description of my "I was going to say that"
21:01:07 <oerjan> ais523: you wicked, wicked man
21:03:15 <AnMaster> why is writing specialisers so popular suddenly. I mean the concept isn't exactly new. Yet it seems to have been mentioned a lot more in here recently than before...
21:05:23 <ehird> AnMaster: Yesterday I mentioned it to nooga for SADOL.
21:05:29 <ehird> Then pikhq picked up on it and started working on it.
21:05:41 <AnMaster> ehird, I first saw it in here about a week before that
21:05:47 <AnMaster> think you mentioned it too then
21:06:31 <AnMaster> when I mentioned superoptimisers used to generate better peep hole optimisers.
21:06:49 <AnMaster> ehird, aha! it is all your "fault" ;P
21:14:18 -!- nooga_ has joined.
21:19:20 -!- nooga has quit (Read error: 110 (Connection timed out)).
21:20:30 -!- comex has quit (Remote closed the connection).
21:21:06 <ehird> nooga_: just do what i said
21:21:12 <ehird> write sadol interp, see patterns in control structures
21:21:35 -!- poiuy_qwert has joined.
21:21:55 <nooga_> sadol interpreter, basically is an recursive function iwth switch inside
21:26:06 -!- nooga_ has changed nick to nooga.
21:26:33 -!- ais523_ has joined.
21:27:08 -!- ais523 has quit (Dead socket).
21:27:41 <ais523_> wow, I don't think I've had /that/ quit reason before
21:27:42 -!- ais523_ has changed nick to ais523.
21:28:30 <ais523> that is the right command
21:29:04 <nooga> FFFFFFFFFFFFFUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
21:29:22 <nooga> EgoBot is dead, what now? what sadistic plague comes up with now?!
21:30:35 <EgoBot> help: General commands: !help, !info, !bf_txtgen. See also !help languages, !help userinterps. You can get help on some commands by typing !help <command>.
21:31:21 <EgoBot> Score for ais523_suicide: 0.0
21:32:51 <EgoBot> userinterps: Users can add interpreters written in any of the languages in !help languages. See !help addinterp, delinterp, show | !userinterps. List interpreters added with !addinterp.
21:33:30 <EgoBot> sadol :M$0 :d:i,45000@>i-01(2]M0:i-i1:S$0:C;3:l#C-01:p:m0@<pl(2?=#Cp"1+:#Mm%+#Mm1,3255?=#Cp"1-:#Mm?<-#Mm10,3254-#Mm1?=#Cp"1>:m%+m1d?=#Cp"1<:m?<-m10-s1-m1?=#Cp"1.!'2#Mm?=#Cp"1,:#Mm'1;0?=#Cp"1[]S-p1?=#Cp"1]?=#Mm00:p[S0:p+p1
21:33:33 -!- Slereah has joined.
21:34:10 <EgoBot> That is not a user interpreter!
21:35:09 <nooga> my new lang will be called lax
21:35:57 <ehird> nooga: the sadol-interp one?
21:37:05 <nooga> rather, something like less cryptic sadol
21:37:22 <ehird> nooga: but used for the sadol compilerterp?
21:37:28 -!- inurinternet has quit (No route to host).
21:38:16 <nooga> i plan to enable some tricks that will enable extending core language with ease
21:39:13 <ehird> nooga: that will ruin your specializer hopes
21:39:29 <nooga> so, real custom operators, ability to define constructs that are indistinguishable from i.e. if or while for user
21:39:58 <ehird> yep, bad for a specializer
21:42:00 <nooga> def unless [c t] if not c t nil
21:44:03 <nooga> !sadol ~u2?-0#_0#_10 :a1 !u=a02
21:44:31 <nooga> !sadol ~u2?-1#_0#_10 :a1 !u=a02
21:44:58 <nooga> !sadol ~u2?-1#_0#_10 :a1 !u=a12
21:45:09 <nooga> !sadol ~u2?-1#_0#_10 :a1 !u=a1!2
21:48:04 -!- Slereah_ has quit (Read error: 110 (Connection timed out)).
21:49:11 <nooga> ehird: you seem to know the topic
21:49:26 <nooga> ehird: why don't you write own specializer
21:49:34 <ehird> 'cuz it's not practical :)
22:02:04 <AnMaster> nooga, evil isn't he. Since he didn't tell you this? And now really night.
22:05:07 <ehird> err, I told him there's no really good specializers
22:05:14 <ehird> what you mean is you didn't erad
22:08:36 -!- BeholdMyGlory has quit (Remote closed the connection).
22:09:26 <ehird> ais523: the decss language thing, remember?
22:09:41 <ehird> on the 2nd, but I'm allowed to be forgetful
22:09:42 <ais523> what was the gist of the reply
22:09:45 <ais523> also, what did you ask?
22:10:21 <ehird> ais523: subject: "The DeCSS language - I promise not to sue you :-)"; body is my interpreter, i realised after hitting send that it contained my (facetious but not recognizable as so without #esoteric channel context) "# Fuck you, Dave Touretzky." comment
22:10:29 <ehird> [[Oh no! Now I'm a copyright criminal for sure!!!!
22:10:29 <ehird> <Sob> How could you?
22:10:35 <ehird> either he didn't notice, or I was lucky ;)
22:11:03 <ais523> presumably he was joking in the reply
22:11:18 <ehird> here I was, ruining his life.
22:11:42 <ais523> ehird: I am only marginally better than AnMaster at detecting sarcasm
22:11:48 <ais523> so it helps to be really obvious
22:12:01 <ehird> ais523: four exclamation points
22:12:02 <nooga> ehird: i guess that handwriting optimized optimizing compiler is more practical
22:12:12 <ehird> nooga: but who wants practical
22:12:21 <nooga> but of crs, specializer migh be much more fun and challenging
22:12:21 <ais523> ehird: ah, I never see people use that many exclamation marks even when joking
22:12:27 <ais523> so I'm not entirely wure what it means
22:12:46 <FireFly> I just closed the tab containing your code, just when you spoke about it, ehird
22:12:55 <oerjan> ais523: don't be stupid!!!!!!!!
22:13:18 <ehird> FireFly: It's synchronicity because oerjan spoke next; just ask him about his ... 1994? incident!
22:13:28 <nooga> isnt lax a salmon?
22:13:53 <ehird> nooga: lax is what snowlax does
22:14:11 <ehird> ais523: i've seen people use up to 10 !s seriously
22:14:18 <ehird> oerjan: tell FireFly
22:14:30 <ais523> there must be some esolang with ! as a common character
22:14:40 <ais523> actually, I think I've used nine !s in a row in Underload before
22:14:42 <oerjan> ais523: no way!!!!!!!!!!!!
22:14:49 <ais523> but I didn't intend that to be parsable in English
22:14:57 <ehird> http://upload.wikimedia.org/wikipedia/commons/a/ae/SunOS_4.1.1_P1270750.jpg
22:15:08 <ehird> AnMaster's favourite storage mechanism
22:16:01 <nooga> usa - where universities produce commercial software
22:16:23 <ehird> nooga: i don't think that's just usa
22:16:23 <ais523> over here in the UK, they produce commercial hardware
22:16:25 <pikhq> nooga: Where universities are businesses.
22:16:42 <pikhq> Seriously, we have to pay through the nose.
22:17:36 <ehird> ais523: i want a full oxford dictionary
22:17:44 <ehird> with which to be pedantic in internet grammar/spelling arguments
22:17:59 <ehird> pikhq: i know, that's the fun
22:18:11 <ehird> also I want a full Britannica, and a full Wikipedia
22:18:23 <nooga> the thing is that i don't really know english
22:18:28 <pikhq> Unless you want it on dead tree.
22:19:48 <ehird> pikhq: pic on reddit of a printed WP: just the featured articles
22:19:58 <ehird> <reddit search> no results
22:20:09 <ehird> It truly transcends shittiness, that search.
22:20:45 <ehird> pikhq: http://www.rob-matthews.com/files/gimgs/5_wikipedia-1.jpg
22:20:51 <ehird> WP featured articles, in (iirc) 9pt
22:20:59 <ehird> now, make it all articles, and split into big volumes
22:21:02 <ehird> also, add pictures
22:21:08 <ehird> ais523: (you might like that)
22:21:38 <ehird> ais523: it's a photo of a book
22:21:46 <ehird> a very, very gigantic book
22:21:53 <ais523> I thought it was a very, very gigantic image
22:21:57 <ais523> which would have been even funnier
22:22:03 <ehird> ais523: but it's a real book!
22:22:06 <ehird> that's totally awesome.
22:22:35 <pikhq> http://www.rob-matthews.com/files/gimgs/5_wikipedia-2.jpg :)
22:22:47 <ehird> if it was in volumes, it'd be usable
22:22:51 <FireFly> A bit hard to carry around
22:22:54 <ehird> if it was in volumes and had all articles, it'd be gigantic
22:22:57 <ehird> BUT TOTALLY AWESOME.
22:23:00 <ehird> just like britannica & oed
22:23:07 <ais523> considerably bigger, I imagine
22:23:15 <FireFly> You'd need a dedicated library
22:23:15 <ehird> probably take several large bookshelves
22:23:16 <ais523> britannica took up two shelves of our library
22:23:22 <ehird> ais523: IIRC, it would be 380ft
22:23:25 <ais523> I wouldn't imagine Wikipedia fitting in the entire library
22:23:34 <ais523> (school library, that is)
22:23:39 <ais523> it would fit in the university library without trouble
22:23:43 <ehird> and, I mean, you could do that with several large bookshelves
22:23:47 <ehird> doesn't need a library
22:23:54 <ehird> oh, and the best bit?
22:24:12 <ehird> "George W. Bush is gay[citation needed] a former President of the United States of America."
22:24:27 <ehird> In serifed text, on good proper dead tree, with leather bindings and whatnot.
22:24:39 <ehird> it should come with two copies
22:24:44 <ehird> on the spare one, write your addition
22:24:50 <ehird> and send to the wikipedia offices
22:24:54 <ehird> where they will transcribe and save your change
22:25:03 <ehird> and you can buy update sets
22:25:10 <ehird> where you cut out existing pages and paste the new ones to the spine
22:25:18 <ehird> it'd be like pokemon, but not
22:25:22 <FireFly> Maybe some clipping feature?
22:25:28 <ais523> actually, it was suggested that printed copies of Wikipedia subsets should come with postcards on which you can send editing suggestions
22:25:32 <ehird> there is totally a market for this
22:25:45 <ais523> ehird: collectible trading card encyclopedias?
22:25:55 <ais523> actually, IIRC a newspaper did that a while back
22:26:04 <ehird> "I have the rare one with the big penis on the front page, it was only in print for 15 seconds"
22:26:06 <pikhq> I seem to recall there being efforts to make a printed Wikipedia.
22:26:07 <ais523> each of which contained a random subset of a children's encyclopedia
22:26:18 <ehird> yes, the press would update in real time
22:26:33 <ais523> ehird: how many copies would they sell, though?
22:26:41 <ais523> ah, maybe they can use amazon's new print-on-demand thing
22:26:41 <ehird> ais523: oh, you know, 3.
22:26:49 <ais523> they're setting up a service where they print books as they're ordered
22:26:49 <ehird> also, does that have old yellowy paper?
22:26:52 <ehird> with leather bindings?
22:26:59 <ais523> probably not, unfortunately
22:27:00 <ehird> ais523: aww, but then you'd have to order it at the tiem
22:27:03 <ais523> but you might sell more that way
22:27:03 <pikhq> ais523: Have set up.
22:27:05 <FireFly> "Can I have that one on Befunge? I collect esolangs. You can have this rubbish history article for that befunge."
22:27:07 <ehird> I'm imagining a bunch of pages flying by every second
22:27:27 <ehird> FireFly: when articles get deleted, they'd become super-rare
22:27:32 <ehird> this could totally work.
22:27:45 <ais523> it won't really catch on unless you invent a complex card game to play with them
22:27:46 <FireFly> As soon as you get your card, delete the article
22:27:56 <pikhq> ais523: Turing-complete.
22:28:04 <ehird> ais523: using real-world facts?
22:28:16 <ais523> they're in abundance in Wikipedia
22:28:19 <ehird> "I play [[Rabbit]]. It poops."
22:28:22 <ais523> actually, Wikipedia top trumps might be an interesting game
22:28:28 <ais523> where you make up categories on the fly
22:28:30 <FireFly> ehird, do you have the poop spell card?
22:28:31 <ehird> "I play [[Haskell]]. It gives you a type error"
22:28:44 <ehird> "Poop wins against type errors!"
22:29:08 <FireFly> You'd need [[poop]], and [[Rabbit]] may only use [[poop]] if has a link in its article?
22:29:19 <ehird> FireFly: that's great
22:29:24 <ehird> you could have N-degrees
22:29:34 <ehird> if you can get from [[Rabbit]] to [[nuclear war]] in 3 clicks, you can use it
22:29:39 <ehird> ais523: [[The original authors of the Wikipedia entries will not receive any of this money, but they are acknowledged on the last 30 pages of the book, which lists the handles of all the authors in the most miniscule font possible]]
22:29:44 <ehird> this could be quite an issue
22:29:52 <ehird> you couldn't legally separate them from the volumes, either
22:30:19 <pikhq> ehird: Give it a few months.
22:30:25 <pikhq> Wikipedia's going to be CC soon.
22:30:36 <ehird> pikhq: still have to attribute
22:30:37 <FireFly> N-degrees reminds me of wikirace
22:30:45 <ais523> you could just attribute on the cards
22:30:49 <ais523> to make it more fun, on the back of the cards
22:30:57 <ais523> so you can try to deduce what the article's about by who wrote it
22:31:10 <ehird> "In that time there ruled an opinion that a man shouldn’t lift up more than 3 kg."
22:31:16 <ehird> that's pretty light...
22:31:30 <ehird> ais523: how can you tie in the card game with the ye olde encyclopediae, though?
22:31:40 <FireFly> What does a regular laptop weight?
22:31:41 <pikhq> ehird: I think Americans pick up more soda than that at a time, usually. :p
22:31:56 <ais523> ehird: link structure sounds like a good idea
22:32:27 <ehird> this could be played online, actually
22:32:32 <ehird> ais523: but how do you deal with abilities?
22:32:41 <FireFly> To do N-degree actions, you'd of course need to have all the cards on your hand, so that you can play them all the way there
22:32:43 <ehird> i mean, nuclear war vs photography
22:32:46 <ehird> how do you decide which wins
22:33:03 <ais523> I imagine nuclear war beats most things
22:33:10 <ais523> but if you were going top-trumps style
22:33:19 <ais523> you'd just invent your own category's
22:33:28 <ais523> "how explosive is yours?"
22:33:33 <ais523> "well, mine's more explosive"
22:33:38 <ehird> ais523: that's not really much of a game
22:33:45 <ehird> I'm thinkin' D&D size rulebooks here
22:33:55 <FireFly> I'm actually tempted to convert that to our earthen weight now
22:34:13 <FireFly> ehird, wikipedia sized rulebooks!
22:34:19 <ehird> 22:31 FireFly: What does a regular laptop weight?
22:34:26 <FireFly> And then make a meta-game from that rulebook
22:34:52 <FireFly> I'll stick to my SI units :P
22:34:54 <ais523> obviously, the rulebook also has to be editable in real time, and collectible
22:34:57 <ais523> which I suppose would make it a nomic
22:35:03 <ehird> ais523: massively collaborative nomic
22:35:13 <ehird> FireFly: about 2-3kg
22:35:18 <ehird> netbooks are about 1-1.5kg
22:35:27 <ehird> FireFly: the ideal weight of a laptop is 1kg
22:35:38 <ehird> because really, netbooks are what a laptop should be; otherwise you just want a luggable computer
22:35:39 <ehird> FireFly: of course
22:35:40 <FireFly> In both weight and processor power :P
22:35:43 <ais523> why? how do you know it isn't 890g
22:35:47 <ehird> but 1kg is imperceptible to carry around
22:35:51 <ehird> ais523: give or take
22:36:01 <ehird> also, 10"-12" is about the right size for it
22:36:15 <pikhq> ehird: D&D-sized rulebooks? T3h lame.
22:36:23 <pikhq> I'm thinking encyclopedia volume-sized rulebooks.
22:36:27 <ehird> pikhq: more substantial than "whichever is better"
22:36:36 <ehird> also, we should enlist Agora to help write it
22:36:39 <ehird> they can inflate the language
22:36:40 <FireFly> Rulebooks of what beats what?
22:36:41 <ais523> clearly, this should be the most notable game in the world
22:36:50 <ais523> sufficiently notable, in fact, that it takes up half of Wikipedia
22:36:55 <ais523> then we could have some sort of weird infinite loop
22:37:04 <ehird> ais523: you're thinking of pokemon
22:37:12 <ais523> but those articles were merged
22:37:17 <ais523> on the basis that they were mostly identical
22:37:17 <ehird> ais523: yeah, that made me sad
22:37:24 <ehird> they were only merged 'cuz people thought it was biased
22:37:27 <ehird> but they were good articles!
22:37:36 <ais523> yes, they were mostly identical good articles though
22:37:48 <FireFly> But clearly, [[Tea]] beats [[Coffee]]
22:37:57 <ais523> imagine if every BF equivalent was explained exactly the same way as BF, but with the commands changed
22:38:10 <ais523> you'd have loads of good articles there which were mostly identical
22:38:26 <FireFly> Maybe categories could be used to identify the type of ability?
22:38:27 <pikhq> ais523: Note that there's a number of automatically generated articles on Wikipedia.
22:38:44 <ehird> "It was around this time that J. R. R. Tolkien was employed by the OED, researching etymologies of the Waggle to Warlock range"
22:38:48 <ehird> I love how that's a substantial range
22:38:52 <ais523> but the idea was to add stubs to persuade people to edit them
22:38:56 <FireFly> Is [[Weapon of mass destruction]] in a subcategory of Category:Weapons? Then it's probably pretty strong
22:39:07 <pikhq> ehird: *Germanic* etymologies specifically.
22:39:08 <FireFly> Of course, one would still have to compare the strengh somehow
22:39:22 <ais523> number of references, obviously
22:39:25 <ehird> ais523: I asked in #wikipedia a while back for some work to do. I was told to clean up rambot articles because it made scrappy articles with too many useless digits on numbers, etc. I pointed out that this could be automated and got the IRC equivalent of blank stares.
22:39:26 -!- poiuy_qwert has quit.
22:39:35 <ehird> Bloody mechanical gnomes.
22:39:46 <ais523> it's the sort of thing gnomes enjoy doing
22:39:56 <ais523> there's a wikignome mentality which I don't really understand
22:40:01 <ais523> they must have thought you were one looking for work
22:40:07 -!- tombom has quit ("Peace and Protection 4.22.2").
22:40:18 <ais523> (Bot523 on Wikipedia eventually stopped working because a) humans kept beating it to it, and b) I forgot to run it)
22:40:29 <ais523> also, it only ran in IE
22:40:29 <ehird> i was asking for work that actually helped people :P
22:40:43 <ais523> ehird: you're missing the point
22:40:51 <ais523> why couldn't you apply AWB general fixes to 100000 articles?
22:41:02 <ais523> even when they made no difference to them?
22:41:05 <ehird> incidentally, Wikipedia went downhill around the point they deleted Willy's article
22:41:18 <ehird> ais523: i hate automated wiki browsers with a passion
22:41:20 <ehird> they're so generic and rubbish
22:41:22 <ais523> (nowadays there's consensus that AWB general fixes can only be used if you do something else to the article as well)
22:42:01 <ehird> I'd run my own specialized scripts to do some useful edits on WP, but people would ban me for BOTTING OMG
22:42:27 <ais523> running bots is legal, you just have to get them approved
22:42:33 <FireFly> What happened to the wikigame? :(
22:42:35 <ais523> only that became ridiculously political for no apparent reason
22:42:47 <ehird> which is a painful process; what's the difference, ais523, between doing work tediously and manually
22:42:52 <ais523> oh, probably betacommand was the reason, and it all spiralled from there
22:42:54 <ehird> vs getting it done fixed and errorless with a script?
22:43:01 <ehird> the latter is a lot better, that's what
22:43:16 <ais523> ehird: because of the number of people who think it would be great to own a bot and write rubbish scripts that produce a lot of damage in a short space of time
22:43:18 <FireFly> Or, rather, the discussion about it
22:43:26 <ehird> ais523: why can't that be handled like any bad user?
22:43:34 <ehird> FireFly: we can't think of how to do it
22:43:40 <ais523> ehird: because admins don't like spending the time to clear up after the bots by hand
22:43:50 <ais523> and there's always a row whenever someone tries to clear up automatically
22:44:02 <ehird> ais523: gah, wikipedia is so annoying
22:44:03 <ais523> because they might revert good edits
22:44:17 <FireFly> Categories builds up an hierarchy, could maybe be used?
22:44:29 <ehird> FireFly: yeah, but the basic thing is that we can't go annotating every article ever
22:44:32 <ais523> (a fast bot which is 90% correct is really damaging, for instance, but also you don't want to mass-revert it)
22:44:49 <ais523> also, bot perms can be used to DOS the server
22:44:55 <ais523> well, more effectively than user perms can, anyway
22:44:59 <ais523> because bots are allowed to go faster
22:45:05 <ais523> so you're supposed to use common sense when writing a bot
22:45:11 <ehird> WP's server and software setup seems to suck.
22:45:19 <ais523> ehird: it strikes me as typical PHP
22:45:23 <ais523> which is not really a good thing
22:45:42 <ehird> they should let me administrate their servers
22:45:46 <ehird> i'd only break them 1-2 times a day
22:45:46 <FireFly> One could still make it a computerised TCG, and check wikipedia on demand, but that'd destroy the purpose a bit, I guess
22:46:04 <ais523> time to go home, anyway
22:46:05 -!- ais523 has quit (Remote closed the connection).
22:49:58 <EgoBot> Score for FireFly_draw: 0.0
22:50:36 <FireFly> Hm, current hill is more tolerant to it
22:50:56 <ehird> "In the estimation of some atheists, Craig has won all or nearly all of his debates with atheists and is one of the most impressive debaters currently alive.[1]"
22:50:57 <ehird> http://conservapedia.com/William_Lane_Craig
22:51:43 <ehird> !bfjoust fuck_you_ima_sit_here (-+)*50000
22:51:57 <EgoBot> Score for ehird_fuck_you_ima_sit_here: 4.6
22:52:21 <ehird> 10 | - - - - - - - 0 0 0 - - - - - - - - - + | 4.6 | -11.6 | ehird_fuck_you_ima_sit_here.bfjoust
22:52:25 <lament> !bfjoust mirage (+)*300000
22:52:33 <ehird> !bfjoust fuck_you_ima_sit_here [+-]
22:52:44 <EgoBot> Score for lament_mirage: 7.7
22:52:46 <EgoBot> Score for ehird_fuck_you_ima_sit_here: 6.1
22:53:21 <ehird> lament: pretty good
22:53:24 <ehird> if by good you mean abd
22:54:46 <FireFly> !bfjoust simple (>)*9(>[-])*21
22:54:53 <EgoBot> Score for FireFly_simple: 7.0
22:55:58 <FireFly> !bfjoust simple --->>+++>>>--->>>>(>[-])*21
22:56:04 <EgoBot> Score for FireFly_simple: 7.5
22:57:17 <FireFly> !bfjoust simple (>(+)*127)*9(>[-])*21
22:57:24 <EgoBot> Score for FireFly_simple: 0.0
22:58:12 <FireFly> !bfjoust simple >(>(-)*128)*29
22:58:19 <EgoBot> Score for FireFly_simple: 0.0
22:59:41 <FireFly> !bfjoust simple ++>>-->>++>>-->>>(>[-]<<+>>)*29
22:59:49 <EgoBot> Score for FireFly_simple: 7.5
23:00:54 <ehird> slackware just released a 64 bit version
23:01:00 <ehird> well just = 2009-05-19
23:01:04 <ehird> how ya doin' slowpoke
23:01:27 <FireFly> !bfjoust simple +(>-)*9(>[-].-)*21
23:01:34 <EgoBot> Score for FireFly_simple: 12.1
23:02:37 <FireFly> Oh, yeah, right.. [23:52:16] <FireFly> Time to sleep
23:02:50 -!- FireFly has quit ("Later").
23:15:39 <ehird> oerjan: any success w/ self-recognizer?
23:18:49 <oerjan> and i haven't tried any more than what i already commented
23:18:58 <ehird> oerjan: you talked about it
23:19:20 <oerjan> that Mirror thing. wasn't that yours?
23:19:34 <ehird> oerjan: i never actually got it working
23:19:40 <ehird> shall I ask #haskell?
23:20:08 <oerjan> well what i suggested would be the beginning of an algebra
23:21:12 * ehird challenges #haskell
23:21:12 <oerjan> hm if you parametrize on Bool you have an Applicative instance
23:21:50 <oerjan> newtype Mirror b = M { runM :: Mirror b -> b }
23:22:04 <oerjan> hm wait that doesn't work
23:22:55 <oerjan> you cannot map when changing the type
23:23:58 -!- Corun has joined.
23:24:03 <ehird> "A massive hard disk, a DVD-2 drive, and a 400-MHz Pentium II processor make Dell's XPS R400 a prime example of a power-user's PC."
23:24:04 <ehird> "Storage is the forte of the XPS R400: A speedy IBM Deskstar hard disk holds a whopping 14.4GB of data."
23:27:05 <ehird> pikhq: On our favourite topic, excessive computers, ...
23:27:14 <ehird> pikhq: http://files.myopera.com/wiz/albums/781632/wiz-desktop1.jpg That machine is fanlessly heatpipe-cooled and uses an SSD.
23:27:29 <ehird> Bulky solid state computer + gigantic array of monitors = ????????