←2011-02-11 2011-02-12 2011-02-13→ ↑2011 ↑all
00:01:16 <quintopia> coppro: shutter2 beats it because almost all my decoys are multiples of 3 :P
00:01:36 <Vorpal> night
00:01:38 <quintopia> !bfjoust superfast_jellyfish +>>>>(+)*33<(-)*65<(+)*91<(-)*128>>>>>>>>([-[++[(+)*15[(.-)*3]]]]>)*21
00:01:53 <coppro> quintopia: I just wanted to see what happened when you changed it to a three-cycle wait; a lot of the defenders die to it
00:02:00 <EgoBot> Score for quintopia_superfast_jellyfish: 38.7
00:02:03 <oerjan> <Gergor> It would be nice to be able to say {} in comments :P <-- you could do ((...{}...))%0 . oh wait, what about (({{}}%)%0
00:02:11 <Gergor> oerjan: **
00:02:14 <Gergor> i.e. correction to *
00:02:31 <Gergor> oerjan: (({a{b}c})*0)*0
00:02:32 <Gergor> WHAT NOW, GOD
00:03:19 <oerjan> <coppro> oerjan: except n should be a positive integer <-- hm actually i recall that with _multiple_ {}'s, you must stop at 1 because the {}'s may not contain the same thing
00:04:41 <oerjan> Gergor: oh well i guess there is little harm in making ()%0 a comment always
00:04:58 <quintopia> !bfjoust i_like_turtles (+)*11>>>>(+)*33<(-)*65<(+)*91<(-)*128>>>>>>>>([-[++[(+)*15[.-]]]]>)*21
00:05:07 <nescience> why not just use ""
00:05:15 <nescience> that'd make sense and be simple
00:05:18 <EgoBot> Score for quintopia_i_like_turtles: 59.3
00:05:23 <quintopia> ^^
00:05:39 <Gergor> nescience: no lame
00:05:46 <Gergor> ais has approved of *0 as comments
00:05:55 <Deewiant> Gregor: WHOOPS, not #1 anymore are you
00:06:00 <nescience> lamer than abusing loop syntax for a not loop
00:06:02 <nescience> ?
00:06:05 <Gergor> nescience: () isn't loop
00:06:06 <Gergor> it's repeat
00:06:09 <Gergor> 0 repeat = nothingness
00:06:12 <Gergor> just don't use {} and it's fine :P
00:06:17 <Gregor> WTFWTFWTF
00:06:20 <Gregor> quintopia: DAMN YOUUUUUUUUUUU
00:06:28 <nescience> haha he owned all your programs huh
00:06:32 <Gergor> Gregor: Just write i_like_i_like_turtles
00:06:33 <nescience> nice
00:06:34 <Gergor> to make it go down the hill
00:06:37 <Gergor> and you'll return
00:06:39 <Deewiant> Another top program that maglev beats
00:06:48 <Gregor> elliott: Dude, he's WAY ahead!
00:06:58 <quintopia> Deewiant: maglev is superfast. i can't catch it
00:07:01 <nescience> yeah big scores
00:07:04 <Deewiant> In fact mapping_turtle is the only one above maglev that it doesn't beat
00:07:07 <oerjan> Gergor: turtle_neck_to_neck, is what i want to see
00:07:41 <Gergor> oerjan: well now we know about your secret turtle fetish.
00:07:48 <Deewiant> turtle_necking
00:09:09 <coppro> where are they stored?
00:10:05 <coppro> wait; how does maglev even work if you don't know how big the playing field is?
00:10:14 <Gregor> !bfjoust quapping_turtle -(>(+)*10>(-)*10)*4>([(+)*118(+.)*20.+>]+>[(+)*118(+.)*20.->]->)*11
00:10:28 <EgoBot> Score for Gregor_quapping_turtle: 49.2
00:10:37 <Gregor> Figured :(
00:10:49 <Deewiant> The >(.+)*10000 at the end is just a tiebreaker against shudder if you're wondering about that
00:10:57 <coppro> ah
00:10:57 <Gregor> !bfjoust quapping_turtle <
00:11:07 <EgoBot> Score for Gregor_quapping_turtle: 0.0
00:11:14 <quintopia> aw
00:11:25 <quintopia> i liked having a program named after me by someone else ;P
00:12:20 -!- nescience has quit (Ping timeout: 276 seconds).
00:12:29 <coppro> !bfjoust itsalaser (+)*20>[(-)*10>]([[+][+.]])*100
00:13:01 <EgoBot> Score for coppro_itsalaser: 15.2
00:13:03 <coppro> !bfjoust itsalaser (+)*20>([(-)*10>][[+][+.]])*100
00:13:34 <EgoBot> Score for coppro_itsalaser: 16.3
00:14:44 <Gergor> !bfjoust antidefend13 >+(>(+)*100)*7(>[(-)*128[-.]])*22
00:14:46 <Gergor> !bfjoust
00:14:47 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
00:14:54 <Gergor> Beats it on every polarity and tape length.
00:14:56 <Gergor> Congratulations plz.
00:15:08 <EgoBot> Score for Gergor_antidefend13: 23.5
00:15:09 <Gergor> Argh, I'm as Gergor.
00:15:10 -!- Gergor has changed nick to elliott.
00:15:16 <elliott> Gregor: Can you rename that one? :-P
00:15:20 <Deewiant> You have to re-Gergor to < it
00:15:25 -!- elliott has changed nick to Gergor.
00:15:29 <Gergor> !bfjoust antidefend13 <
00:15:30 -!- Gergor has changed nick to elliott.
00:15:36 <elliott> !bfjoust antidefend13 >+(>(+)*100)*7(>[(-)*128[-.]])*22
00:15:44 <Gregor> elliott: Screw ou
00:15:47 <Gregor> *you
00:15:50 <EgoBot> Score for Gergor_antidefend13: 0.0
00:16:07 <EgoBot> Score for elliott_antidefend13: 22.8
00:16:13 <coppro> !bfjoust itsalaser (+)*20>([(-)*10>][+]--+++++)*100
00:16:23 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
00:16:24 <EgoBot> Score for coppro_itsalaser: 7.6
00:16:34 <elliott> Wow, I beat every ais defend* program on every possible configuration except for defend14 and dfend7, both of which I still beat.
00:16:36 <elliott> *defend7
00:16:58 <coppro> !bfjoust itsalaser (+)*20>([(-)*10>][-]--+++++)*100
00:17:03 <elliott> quintopia: What was that about "NO PROGRAMS ON THE HILL"
00:17:12 <elliott> I developed that one by thinking LOGICALLY and analysing TRACES on EgoJSout!
00:17:14 <EgoBot> Score for coppro_itsalaser: 7.6
00:17:22 <coppro> interesting
00:17:24 <Gregor> I predict lameness:
00:17:28 <Gregor> !bfjoust quapping_turtle -(>(+)*10>(-)*10)*4>([(+)*96(+.)*64.+>]+>[(+)*96(+.)*64.->]->)*11
00:17:35 <quintopia> elliott: that's how i write mine too!
00:17:38 <elliott> Wow, antidefend13's points are -15.
00:17:44 <elliott> But its score is 23 because defend13 is so good :P
00:17:45 <EgoBot> Score for Gregor_quapping_turtle: 45.6
00:17:50 <elliott> That's not lameness.
00:17:53 <elliott> Gregor, you've failed at lameness.
00:17:58 <elliott> I'm disappointed in you.
00:18:03 <coppro> what is the size range of the playing field?
00:18:07 <Deewiant> 10-30
00:18:23 -!- elliott has changed nick to ais523.
00:18:27 <ais523> !bfjoust decoytuner <
00:18:29 <ais523> I hope that doesn't work
00:18:30 <coppro> !bfjoust itsalaser (+)*20>(->+>-->++>)*2([(-)*10>][-]--+++++)*100
00:18:33 * ais523 has it saved :P
00:18:44 <ais523> !bfjoust decoytuner >+>+>->>>>(>[>-[++[+[----[(-)*118(.-)*16(>(-)*120(.-)*16)*18](+>--[++++[(+)*118[+]]])*19](+>++[----[(-)*118[-]]])*19](+>+[--[(-)*119[-]]])*19](+>-[++[(+)*119[+]]])*19])*20>[[-]][-]>[[-]][-]
00:18:45 -!- ais523 has changed nick to elliott.
00:19:12 <elliott> Gregor: Did it... ignore me?
00:19:14 <EgoBot> Score for coppro_itsalaser: 4.5
00:19:15 <EgoBot> Score for ais523_decoytuner: 28.4
00:19:15 <EgoBot> Score for ais523_decoytuner: 28.4
00:19:19 <elliott> ... what.
00:19:22 <coppro> wow that actually suffered?
00:19:24 <elliott> It got 28.4 by being "<"?
00:19:48 <coppro> !bfjoust itsalaser (+)*10>((-)*10>(+)*10>)*2([(-)*10>][-]--+++++)*100
00:20:03 <EgoBot> Score for coppro_itsalaser: 4.5
00:20:09 <coppro> oh wait, I see what I am doing wrong
00:20:11 <coppro> hrmmmmm
00:20:11 <elliott> This laser strategy looks good.
00:20:12 <elliott> :p
00:20:25 <coppro> darn you, brainfuck, for not doing what I want
00:21:33 <elliott> Gregor: Looks like egojsout has a bug.
00:21:38 <elliott> Oh, wait, no.
00:21:53 <elliott> Wait, yup.
00:21:54 <Gregor> egojsout is incapable of bugs.
00:21:55 <elliott> Wait, nope.
00:22:03 <elliott> Gregor: Are you sure that two programs modifying the same cell work?
00:22:09 <Gregor> Yes
00:22:18 <coppro> I want to loop on zero, not on non-zero
00:22:33 <Deewiant> That would be a handy thing to loop on, wouldn't it
00:22:40 <Gregor> TOO BAD
00:22:50 <elliott> Deewiant: Eh?
00:22:59 <Deewiant> What eh?
00:24:18 <elliott> <Deewiant> That would be a handy thing to loop on, wouldn't it
00:24:19 <elliott> <Gregor> TOO BAD
00:24:38 <Deewiant> Why are you eh'ing me
00:24:50 <coppro> I am not eh'ing you
00:25:01 <elliott> Deewiant: What would be a handy thing to loop on
00:25:02 <Deewiant> Gawd dammit
00:25:04 <Deewiant> Who's /ignoring who
00:25:07 <coppro> waitaminute
00:25:10 <coppro> I can totally hack this
00:25:14 <Deewiant> Let me guess: elliott <-> coppro?
00:25:16 <oerjan> Deewiant: he's caught some canadian disease
00:25:21 <coppro> Deewiant: oh
00:25:27 <elliott> I'm /ignoring scrappy because scrappy ignored me and then started restricting his topics of discussion on-channel to how I was ignored
00:25:27 <coppro> I /ignore elliott
00:25:32 <elliott> (Well, 80% of his topics, at least)
00:26:02 <Deewiant> In that case, DON'T EH ME IF YOU ONLY HEAR HALF A CONVERSATION
00:26:26 <elliott> Deewiant: Normally I don't because coppro never speaks.
00:26:28 <elliott> ANd I read it as:
00:26:32 <elliott> <elliott> Gregor: Are you sure that two programs modifying the same cell work?
00:26:32 <elliott> <Gregor> Yes
00:26:32 <elliott> <Deewiant> That would be a handy thing to loop on, wouldn't it
00:26:42 -!- cheater00 has joined.
00:26:42 <elliott> Which just confused me, without realising I was missing a conversation, which is a pretty impossible thing to realise.
00:26:48 <Deewiant> elliott: Assume that when I say something, it makes sense
00:27:00 <Deewiant> Then, when it doesn't make sense, you're obviously missing a conversation
00:27:08 <elliott> Deewiant: But that rule doesn't apply to 90% of people in the channel
00:27:13 <elliott> Who don't make sense on a regular basis
00:27:18 <elliott> You don't get special-cases, sir
00:27:27 <oerjan> the conversation _might_ be something only Deewiant hears, of course
00:27:54 <coppro> !bfjoust itsalaser ((-)*10>(+)*10>)*2>([[-]..--+++++](-)*10>)*100
00:28:30 <coppro> !bfjoust itsalaser ((-)*10>(+)*10>)*2>([[-]..--+++++]++>)*100
00:28:56 <EgoBot> Score for coppro_itsalaser: 15.0
00:28:56 <EgoBot> Score for coppro_itsalaser: 15.0
00:29:22 <coppro> !bfjoust itsalaser ((-)*10>(+)*10>)*2>([[+]..--+++++]>)*100
00:29:35 -!- cheater- has quit (Ping timeout: 240 seconds).
00:29:41 <coppro> !bfjoust itsalaser (>)*9>([[+]..--+++++]>)*100
00:30:01 <coppro> !bfjoust itsalaser (>)*9([[+]..--+++++]>)*100
00:30:13 <EgoBot> Score for coppro_itsalaser: 11.9
00:30:13 <EgoBot> Score for coppro_itsalaser: 11.9
00:30:14 <EgoBot> Score for coppro_itsalaser: 11.9
00:30:18 <coppro> huh
00:30:23 <elliott> !bfjoust
00:30:24 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
00:30:37 <coppro> !bfjoust itsalaser (>)*9([[+]..--+++++]+>[[+]..++-----]->)*20
00:31:01 -!- elliott has set topic: Sorry about that outburst, but it is for your own good, as #esoteric is not a very noob-friendly channel, and you can expect to receive abuse at the drop of a hat. | | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
00:31:26 <EgoBot> Score for coppro_itsalaser: 1.9
00:32:18 <elliott> Gregor: Is it chrome, or is holy shit egojsout laggy
00:33:28 -!- Behold has quit (Remote host closed the connection).
00:35:48 <elliott> (source: http://forums.xkcd.com/viewtopic.php?f=11&t=68422 while googling for "bf joust")
00:35:58 <quintopia> i'm hoping that's the message they get from it
00:36:05 <elliott> remember when we claimed to be the only channel friendlier than #haskell?
00:36:06 <elliott> HA HA HA
00:36:08 <elliott> I fixed that
00:36:27 <elliott> i'm preparing to be nice again in about a month, now that the influx of idiotic newbies has died down >:D
00:36:36 <oerjan> >_>
00:36:43 <elliott> well apart from oerjan.
00:36:46 <elliott> he is the constant idiotic newbie.
00:37:05 <oerjan> @_@
00:37:18 <elliott> @_@
00:37:19 <elliott> ^_^
00:37:20 <elliott> ~_~
00:38:25 <Gregor> elliott: Haven't tried it in Chrome.
00:39:03 <Gregor> elliott: Seems pretty fast to me.
00:39:15 <Gregor> elliott: Do you have full-run ties? They take a long time regardless.
00:39:19 <elliott> Gregor: No.
00:39:23 <elliott> I mean it's actually laggy sometimes after running a program.
00:39:28 <elliott> And I have to restart Chrome or whatever.
00:39:31 <elliott> Laggy as in UI laggy.
00:39:37 <Gregor> Your Chrome is broken :P
00:40:07 <elliott> Probably.
00:40:42 <Gregor> I ran out of CO2, so I just made some sugar-citric_acid-water. It's not bad :P
00:42:14 <elliott> !bfjoust vermillion http://sprunge.us/KUWC
00:42:21 -!- nescience has joined.
00:43:41 <EgoBot> Score for elliott_vermillion: 2.9
00:43:55 <Gregor> Wow
00:44:02 <elliott> Gregor: What
00:44:12 <Gregor> Good score :P
00:44:15 <elliott> Gregor: Totally.
00:47:59 <elliott> Gregor: Are you suuure I have to distinguish {} ()s and regular ()s?
00:48:03 <elliott> I really don't want to >_>
00:48:32 <Gregor> You could choose whether to subtract or add in the ) when you follow back to the } or ( I suppose ...
00:48:41 <Gregor> There's certainly some way around it, but it's probably grotty :P
00:51:24 <elliott> THINGS MY PARSER CURRENTLY ACCEPTS: ([)*1]
00:51:42 <oerjan> elliott: note that non-{} )'s are pretty much like {'s, you could just share that implementation
00:51:50 <elliott> oerjan: hm quite possibly
00:52:11 <elliott> Gregor: Yeaaaaah, lance's parser is rejecting non-strictly-well-formed programs for sanity :P
00:52:24 <Gregor> elliott: That's good :P
00:52:29 -!- poiuy_qwert has joined.
00:54:35 <elliott> Gregor: Apparently ([)*1] increments its flag on the third turn and then does nothing forever. SOMEHOW.
00:54:49 <elliott> Probably the ] is writing the loop position to the wrong place or whatever and it just so happens to be the + instruction :-P
00:54:50 <Gregor> lol
00:55:21 <elliott> Also (+)*128 generates "Unknown instruction 128".
00:55:31 <Gregor> X-D
00:55:34 <elliott> (It doesn't use a struct.)
00:55:36 <elliott> (It's just a list of ints.)
00:55:42 <elliott> (It... seemed like a good idea at the time.)
00:55:46 <Gregor> EgoJSout is OBJECT ORIENTED
00:55:47 <oerjan> <elliott> THINGS MY PARSER CURRENTLY ACCEPTS: ([)*1] <-- that does not seem like something you want to do :D
00:56:08 <elliott> Why am I using a list of ints X-D
00:56:08 <Gregor> oerjan: <Gregor> THINGS MY PARSER CURRENTLY ACCEPTS: [()$q
00:56:11 <elliott> OH WELL, IT STAYS
00:56:21 <oerjan> Gregor: O KAY
01:00:50 <elliott> >FE 00 00 00 00 00 00 00 00 <80 -- >0, <9
01:00:50 <elliott> >FF 00 00 00 00 00 00 00 00 <80 -- >0, <9
01:00:50 <elliott> >00 00 00 00 00 00 00 00 00 <80 -- >0, <9
01:00:50 <elliott> >01 00 00 00 00 00 00 00 00 <80 -- >0, <9
01:00:50 <elliott> >01 00 00 00 00 00 00 00 00 <80 -- >0, <9
01:00:51 <elliott> >01 00 00 00 00 00 00 00 00 <80 -- >0, <9
01:00:52 <elliott> =====================
01:00:56 <elliott> How on earth does that end the match...
01:01:32 -!- oerjan has quit (Quit: Good night).
01:04:47 <quintopia> you probably didn't clear your loss flag right
01:08:09 <elliott> i so did
01:08:29 <elliott> quintopia: more importantly, the program is (+)*128 :P
01:08:35 <elliott> oh, off-by-one.
01:08:40 <elliott> i.e. one of the hard things in CS.
01:09:26 <elliott> aha.
01:09:33 <elliott> quintopia: it's actually an optimisation trick.
01:09:55 <quintopia> oh
01:09:56 <elliott> quintopia: if both programs reach the end, i end in a tie. but actually i should only do that if the death counter expires, hmm
01:10:15 <elliott> if (hasended[0] && hasended[1] && !deathcount[0] && !deathcount[1]) return 0;
01:10:15 <elliott> there
01:17:29 <elliott> OK, () work. Now for {}.
01:17:41 <elliott> Gregor: hmm, oerjan's trick only works when you keep an explicit loop stack at execution time, right?
01:18:58 <Gregor> Yes
01:19:42 <elliott> Gregor: Which I don't, yay :P
01:20:38 <elliott> Gregor: Hmm, does that mean that I can't even figure out the matching ] at parse-time?
01:26:40 <elliott> Gregor: Wait, no. Don't I just have to kee ptrack of the _number_ of nested loops?
01:27:02 <Gregor> You need a counter per loop.
01:29:50 <elliott> Gregor: Hmm, yeah. That's weird... uh, you realise that by loop stack I mean [] loop stack?
01:29:52 <elliott> Not () loop stack
01:29:57 <Gregor> OH
01:30:02 <Gregor> I don't have a [] loop stack
01:30:05 <elliott> Oh.
01:30:07 <elliott> I don't need it then. Yay.
01:30:21 <elliott> Gregor: But then how do you handle ([{a}])*3?
01:30:33 <elliott> AFAICT without a loop stack, that won't nest thrice.
01:31:39 <Gregor> This is why you have to do the count-up count-down thing.
01:31:57 <Gregor> If you're counting down during the second part, then you can jump back naively and still be on the correct [
01:32:07 <elliott> Hmmmmm, right.
01:32:14 <elliott> So basically, (...{ and }...) are the two nesters :P
01:33:58 -!- zzo38 has joined.
01:34:40 <quintopia> Gregor: i like the interface changes on bfjsout. making it obvious the arrows are links is a nice touch.
01:34:56 <zzo38> Why do some program make a error only when it is not running in the debugger?
01:35:06 <elliott> zzo38: Because of witches.
01:35:20 <Gregor> quintopia: Glad I could help you beat me :P
01:36:17 <quintopia> Gregor:
01:36:21 <zzo38> Witches?
01:36:30 <Gregor> quintopia: Fascinating.
01:36:42 <quintopia> i'm trying to paste something and it won't
01:36:46 <quintopia> it's a bug i think
01:37:04 <elliott> $ time ./lance '(+)*10000000000000000000' '(+)*10000000000000000000' >/dev/null
01:37:04 <elliott> real0m0.548s
01:37:09 <elliott> Gregor: SO HOW SLOW IS EGOJOUST ON THAT PROGRAM
01:37:12 <elliott> </troll>
01:37:24 <quintopia> erm...i think bfjsout is now in an infinite loop >_>
01:37:25 <elliott> Gregor: P.S. lance: so advanced it supports repeats up to maximum cycle count, not just 12 or whatever it is egojoust's limit is
01:37:29 <elliott> P.P.S. trollin
01:37:32 <elliott> *trollin'
01:37:37 <quintopia> GAH
01:37:41 * quintopia kills the browser
01:37:51 <zzo38> Whiches?
01:38:23 <quintopia> 1358: 0 <90 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF 8A 88 9B 76 08 0A 0A >FD 0
01:38:27 <quintopia> 1359: 0 <90 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF 8A 88 9B 76 08 0A 0A >FD 0
01:38:30 <quintopia> 1361: 2 <91 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF 8A 88 9B 76 08 0A 0A FE 0
01:38:34 <quintopia> 1360: 0 <91 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 FF 8A 88 9B 76 08 0A 0A >FE 0
01:38:37 <quintopia> there
01:38:48 <quintopia> i had to kill your page with had frozen to get the text copied from it
01:39:12 <quintopia> a program shouldn't jump from 0 to 2 losses with its flag at 91 should it?
01:39:27 <elliott> lance doesn't crash your browser because it doesn't touch your browser. discuss.
01:39:41 <quintopia> finish it and give it to me
01:39:45 <elliott> Doing so :P
01:39:59 <elliott> Except just the runner, I want to get a full EgoBot-ready solution before writing the helper.
01:41:31 <quintopia> bfjsout wouldn't kill my browser either if it didn't have a major lock-up-causing bug in it
01:41:38 <quintopia> but hey, that's what js is for, isn't it?
01:41:42 <elliott> precisely!
01:42:33 <elliott> Gregor: Would you hold it against me if I used an actual parser generator for lance rather than hacking up this awful thing? X-D
01:43:13 <Gregor> Yes
01:43:16 <quintopia> elliott: have you already written up the grammar?
01:43:18 <elliott> Gregor: Why
01:43:21 <elliott> quintopia: The grammar is beyond trivial.
01:43:31 <quintopia> HAVE YOU WRITTEN IT DOWN
01:43:31 <elliott> It's just that my current parser accepts ([)*n], which is just perverse.
01:43:33 <Gregor> elliott: Because it's loser.
01:43:41 <Gregor> elliott: I would still accept Lance into EgoBot of course.
01:43:46 <Gregor> elliott: But I would eternally shame you.
01:43:49 <elliott> *lance
01:43:50 <elliott> It's totes lowercase.
01:44:09 <elliott> Because it's EUNUCHS philosophy, in contradiction of Gregor's SUCK philosophy.
01:44:14 * elliott unbias
01:44:23 <elliott> Sucklosophy.
01:44:28 <Gregor> LANCE
01:44:33 <elliott> L.A.N.C.E.
01:44:55 <elliott> Luxurious, yet Anal, Noodly Cervix Enabler
01:44:56 <elliott> Wait, what
01:45:06 <elliott> That acronym was GOING to be about BF Joust
01:49:34 <quintopia> Looks like Acronyms are Not Coherent from Elliot
01:49:35 <quintopia> t
01:50:29 <elliott> :DDD
01:50:34 <elliott> i'm a fuckin geni
01:50:37 <elliott> plural of: geniuses
01:51:10 <R0b0t1> I did not realize how hardcore brainfuck programming could get.
01:51:31 <elliott> BF Joust is the only legitimate use of brainfuck :P
01:51:40 <elliott> (Every other use became tired years ago)
01:53:09 <quintopia> elliott: no, it's still useful for proving other (stateful) languages TC
01:53:18 <elliott> True.
01:53:23 <elliott> (Proving -- depends on your definition of TC.)
01:53:41 <elliott> (Only proves TCness if the language {P} where P is a UTM simulator is TC; this is a matter of debate.)
01:54:10 <quintopia> it's pretty well accepted that BF on an infinite tape can simulate arbitrary TMs
01:55:17 <elliott> quintopia: that isn't the point
01:55:25 <quintopia> what is?
01:55:28 <elliott> quintopia: s/P is a UTM simulator/P is a brainfuck interpreter/
01:55:44 <elliott> quintopia: the debate is: does a language have to have a simulator for /all/ Turing machines to be TC, or is a simulator for just one enough?
01:55:51 <elliott> cpressey, at least, takes the former position
01:56:37 <quintopia> i don't see the difference between "can simulate a UTM" and "can simulate all TMs"?
01:57:05 <elliott> quintopia: can simulate a UTM /with a specified initial input/
01:57:17 <elliott> the point being that, you can have a program that takes a TM specification on stdin and simulates it
01:57:20 <elliott> but you can't pre-rig a program to do that
01:57:28 <elliott> i'm glossing over the issues, it's actually a rather fundamental disagreement IMO
01:57:34 <elliott> but rarely an important one
01:57:50 <elliott> as you're unlikely to find a non-contrived example of a language with a BF interpreter that doesn't have a program for every TM
01:57:52 <quintopia> i've not seen it discussed before.
01:58:05 <elliott> quintopia: we fleshed it out in here some weeks / month ago :P
01:58:17 <elliott> when trying to articulate just what the disagreements about the definition of turing-completeness are
01:59:10 <quintopia> right, because if you can simulate any BF program, then you can simulate the BF TM simulator, which you can use to simulate any UTM, which you can use to simulate all TMs...
01:59:17 <elliott> wrong
01:59:26 <elliott> well, right
01:59:29 <elliott> if you have a program template
01:59:34 <elliott> { foo ",[.,]" }
01:59:36 <elliott> where you can plug in any BF program
01:59:39 <elliott> and get a program that runs that
01:59:41 <elliott> then that's sufficient
01:59:42 <elliott> but if you just have
01:59:43 <elliott> { foo }
01:59:49 <elliott> where that program takes a BF program as /input/ and runs it
01:59:57 <elliott> then that's insufficient, by the must-have-program-for-all definition
02:00:10 <elliott> because you can't construct a program that does the same as the BF program +[>+]
02:00:18 <elliott> (or, you might be able to, but the mere existence of { foo } does not demonstrate it)
02:00:22 <elliott> see?
02:00:29 <quintopia> almost
02:00:38 <elliott> admittedly, 99% of BF interpreters will allow you to transform the latter type into the former
02:00:49 <quintopia> ohhhh
02:00:50 <elliott> but again, consider the language with one operation, where all programs consist of one instruction
02:00:51 <elliott> the operation is:
02:00:54 <elliott> run_bf_program_on_input
02:01:05 <elliott> it's arguable whether this language counts as TC, as there is not a program for every TM
02:01:18 <elliott> just a program for one specific universal language (brainfuck)
02:02:16 <quintopia> it's slipping away...
02:02:28 <elliott> it's ok, the disagreement is very academic :P
02:03:17 <quintopia> it seems like there should be a program for every TM. namely, the BF UTM with that TM pre-written to the tape to be simulated by the BF UTM
02:03:43 <quintopia> (by pre-written, i mean, the sequence of BF instructions that write it)
02:03:51 <elliott> <elliott> but again, consider the language with one operation, where all programs consist of one instruction
02:03:52 <elliott> <elliott> the operation is:
02:03:52 <elliott> <elliott> run_bf_program_on_input
02:03:55 <elliott> there is exactly one valid program
02:03:58 <elliott> run_bf_program_from_input
02:03:59 <elliott> *from, not on
02:04:05 <elliott> there is exactly one program.
02:04:08 <quintopia> ohhhhhhhh
02:04:10 <elliott> therefore there is not a program for every TM.
02:04:30 <elliott> this program simulates a UTM (well, no, but equivalent). but you cannot write a program to simulate an arbitrary TM.
02:05:01 <quintopia> this is almost like the battle over whether the 5,3 TM is universal...because its TCness depends critically upon its input
02:05:38 <quintopia> so it's the question of what it means to encode a TM...whether or not the encoding itself handles all the TCness of it
02:06:10 <elliott> 5,3?
02:06:12 <elliott> *2,3
02:06:21 <quintopia> yeah that. well, anyway, we've established that there are 2 good uses for BF
02:06:24 <elliott> quintopia: but, err, it's almost exactly like it, because ais523 is the one who proved the 2,3 TM turing complete
02:06:28 <elliott> and he's the one who helped flesh it out
02:06:31 <elliott> wait, do you actually know that?
02:06:34 <elliott> i guess you don't necessarily
02:07:09 <quintopia> no, no i didn't know that. i'm not exactly surprised. if i'd ever heard his name mentioned, i'd probably have recognized it.
02:07:18 <elliott> alex smith
02:07:32 <elliott> lol, apparently there's a wired article about it
02:12:01 <quintopia> "He also enjoys composing electronic music" where is this music? :P
02:12:10 <elliott> quintopia: when questioned he has been
02:12:12 <elliott> EXCEEDINGLY
02:12:13 <elliott> ELUSIVE
02:12:15 <elliott> about the matter.
02:12:45 <quintopia> erm ahhh ehhh right the music umm
02:13:06 <elliott> AT THIS POINT IN TIME
02:14:23 <quintopia> oh
02:14:25 <quintopia> my ears
02:14:30 <quintopia> they are defective
02:14:36 <quintopia> that is why i am unable to hear the music
02:15:15 <elliott> quintopia: drinking game for you
02:15:16 <elliott> http://cs.nyu.edu/pipermail/fom/2007-October/012149.html
02:15:19 <elliott> drink whenever wolfram links to his own book
02:15:25 <elliott> prepare to become very, very drunk
02:15:35 <quintopia> i've read through this thread before
02:18:27 <elliott> [[That could be because cellular automata date back to the 1950s, Aaronson says. "The impact of NKS on all the areas of computer science and physics I'm familiar with has been basically zero," he says. "As far as I can tell, the main impact is that people now sometimes use the adjective 'Wolframian' to describe breathtaking claims for the trivial or well-known." Davis offers a sunnier take: "The book has a lot of beautiful pictures."]]
02:18:30 <elliott> that last sentence
02:18:31 <elliott> priceless
02:20:37 <quintopia> lul
02:23:50 <Sgeo_> NKS?
02:24:22 <elliott> Sgeo_: new kind of sexytime. sorry science.
02:24:54 <Gregor> Well it does have pretty pictures.
02:25:12 <quintopia> i haven't read it
02:25:17 <quintopia> by which i mean
02:25:24 <quintopia> i haven't admired the pretty pictures
02:27:26 <elliott> Yay, my parser is approaching something more stable.
02:27:31 <elliott> A New Kind of Stability.
02:28:22 -!- R0b0t1 has quit (Quit: R0b0t1).
02:34:56 <elliott> $ time (for i in $(seq 100); do ./lance '(+)*10000000000' '(+)*10000000000' >/dev/null; done)
02:34:57 <elliott> real0m10.167s
02:35:03 <elliott> Gregor: Does EGOJOUST offer that kind of RAW SPEED PERFORMANCE?
02:36:27 <quintopia> IS IT DONE YET
02:36:35 <elliott> quintopia: ALMOST
02:36:51 <elliott> I just need to add {} loop support, port report.c to it, and port the !bfjoust command to it.
02:37:24 <quintopia> you get the bfjoust command automatically, really
02:37:41 <quintopia> if you change the name of report, you might have to change one line in the shell script for the command
02:37:48 <elliott> !info
02:37:49 <EgoBot> EgoBot is a bot for running programs in esoteric programming languages. If you'd like to add support for your language to EgoBot, check out the source via mercurial at https://codu.org/projects/egobot/hg/ . Cheers and patches (preferably hg bundles) can be sent to Richards@codu.org , PayPal donations can be sent to AKAQuinn@hotmail.com , complaints can be sent to /dev/null
02:38:24 * elliott tries to find the command
02:38:35 <quintopia> the relevant line is ../report ../cache ../egojoust *.bfjoust
02:38:38 <quintopia> that's all you need to change
02:38:50 * elliott reads.
02:38:52 <quintopia> it's in scmds/bfjoust or something like that
02:39:17 <elliott> Gregor: Do you run the report with... a post-commit hook?
02:39:28 <Gregor> wtf, no
02:39:34 <elliott> 38 # Wait for the score to exist
02:39:34 <elliott> 39 (
02:39:34 <elliott> 40 while [ ! -e ../cache/"$I_FILE".bfjoust.score ]
02:39:36 <Gregor> Report does the committing, it's run by egobot
02:39:42 <elliott> What's that about then
02:39:51 <Gregor> Good job understanding bash.
02:40:02 <elliott> Gregor: I just mean, what creates it.
02:40:07 <Gregor> report
02:40:13 <elliott> Oh, it's run in the background :P
02:40:28 <elliott> But yeah, admittedly the bfjoust command itself just needs s/egojoust/lance/ or whatever :P
02:44:19 <elliott> fprintf(stderr, "%d : Oi -- you have a {, but you're not in a ( block. If I were you, I'd make sure my family doesn't hear about this.\n", n);
02:44:20 <elliott> MY ERROR MESSAGES
02:44:23 <elliott> THEY JUST KEEP
02:44:23 <elliott> GETTING
02:44:25 <elliott> BETTER
02:45:04 <elliott> Gregor: { and } don't have to store any counts or anything with them, right?
02:45:05 <Deewiant> s/ -- /—/
02:45:13 <Gregor> elliott: Right
02:45:24 <elliott> Gregor: Not even the location of the other }, yah?
02:45:35 <Gregor> Certainly not that.
02:45:38 <elliott> Deewiant: nou
02:45:41 <Gregor> {} never jump to each other.
02:45:53 <elliott> Deewiant: " -- " looks nicer, especially in a monospaced medium where -s are wide.
02:46:03 <elliott> Deewiant: Besides, as a Brit, I put thin spaces around em dashes.
02:46:24 <elliott> Deewiant: AND THAT'S HOW I LIKE IT.
02:46:41 <elliott> TBH, I usually prefer the en dash simply because the em dash is pretty damn wide.
02:47:00 <Deewiant> "According to [...] some British sources (e.g., The Oxford Guide to Style), an em dash should always be set closed (not surrounded by spaces)."
02:47:24 <elliott> "some"
02:47:31 <Deewiant> "Oxford"
02:47:44 <Deewiant> en-GB-oed spelling goes with Oxford style
02:47:47 <elliott> Deewiant: The Brit thing was a joke.
02:47:51 <elliott> Also, I never specified -oed.
02:48:00 <Deewiant> I do.
02:48:05 <elliott> [[The Canadian The Elements of Typographic Style recommends the more concise spaced en dash – like so – and argues that the length and visual magnitude of an em dash "belongs to the padded and corseted aesthetic of Victorian typography."]]
02:48:11 <elliott> Deewiant: Canada.
02:48:13 <elliott> Canada hates you.
02:48:19 <Deewiant> Screw Canada.
02:48:21 <elliott> [[The spaced en dash is also the house style for certain major publishers (Penguin, Cambridge University Press, and Routledge among them, all British).]]
02:48:22 <elliott> [[The spaced en dash is also the house style for certain major publishers (Penguin, Cambridge University Press, and Routledge among them, all British).]]
02:48:23 <elliott> [[The spaced en dash is also the house style for certain major publishers (Penguin, Cambridge University Press, and Routledge among them, all British).]]
02:48:26 <Deewiant> They don't even have Internet these days.
02:48:27 <elliott> Deewiant: CAMBRIDGE.
02:48:31 <Deewiant> OXFORD.
02:48:35 <elliott> Deewiant: PENGUIN
02:48:36 <Deewiant> en-GB-cam? What's that?
02:48:59 <elliott> <Gregor> Fucking FONTophiles.
02:50:26 <Gregor> !bfjoust sugar_philip http://pastebin.com/raw.php?i=0ppQDKzt
02:50:47 <EgoBot> Score for Gregor_sugar_philip: 1.9
02:50:53 <Gregor> wtf, really?
02:51:10 <quintopia> gregor
02:51:17 <quintopia> were you even paying attention at all
02:51:25 <Gregor> quintopia: Yes, that's why I wrote this.
02:51:34 <Gregor> It is a substantial improvement, at least by egojsout
02:51:36 <quintopia> did you fix the bug first?
02:51:45 <Gregor> Then I guess I wasn't paying attention :P
02:52:06 <quintopia> egojoust does not support ({})% correctly
02:52:14 <Gregor> Ahhh
02:52:16 <Gregor> Sweet :P
02:52:17 <quintopia> expand all that stuff manually and try again
02:52:40 <elliott> Gregor: No
02:52:41 <elliott> Gregor: More importantly
02:52:43 <elliott> Gregor: That page is HTML
02:52:45 <elliott> And starts with a <
02:52:54 <Gregor> ARGH
02:52:56 <Gregor> Pastebin made of fail.
02:52:57 <elliott> How it gets more than 0 points, I have no clue.
02:52:58 <elliott> Gregor: sprunge.us
02:52:58 <quintopia> next time try a sprunge
02:53:00 <elliott> Srsly.
02:53:13 <elliott> It's the only way to stay sane :P
02:53:15 <Gregor> I edited it in egojsout, I don't have it so conveniently in a file.
02:53:30 <elliott> Gregor: Write some PHP as a post form to sprunge :P
02:53:30 <elliott> It's just
02:53:32 <elliott> not even php
02:53:48 <elliott> <form action="http://sprunge.us" method=post><textarea name=sprunge></textarea><input type=submit></form>
02:53:54 <quintopia> Gregor: make it so you can submit programs FROM bfjsout!
02:53:55 <elliott> Save as ~/sprunge.html :P
02:54:08 <elliott> Gregor: But usually I just do
02:54:09 <Gregor> quintopia: Stop saying "bfjsout"
02:54:14 <elliott> $ curl -F 'sprunge=<-' sprunge.us
02:54:15 <quintopia> elliott: how do you get back the link title?
02:54:16 <elliott> [middle click]
02:54:17 <elliott> ^D
02:54:27 <elliott> quintopia: It'll be in the response you get
02:54:28 <elliott> So just submit
02:54:42 <Gregor> !bfjoust sugar_philip http://sprunge.us/jjJS
02:54:46 <quintopia> oh. neatsauce
02:55:03 <EgoBot> Score for Gregor_sugar_philip: 38.9
02:55:08 <quintopia> not bad
02:55:10 <Gregor> Hm
02:55:34 <quintopia> what is a sugar philip
02:55:40 <elliott> A penis.
02:55:47 <elliott> Made out of ... sugar.
02:55:50 <quintopia> should have known
02:56:02 <elliott> Gregor is all about the sugar penises.
02:56:17 <Gregor> Now what's this bug about expanding ({}) that isn't a crashbug?
02:57:37 <elliott> Gregor: See: the messages oerjan sent you via lambdabot that you ignored :P
02:58:14 <Gregor> I thought that was a crashbug, not a correctness issue.
02:58:25 <elliott> Gregor: Nope :P
02:58:39 <Gregor> Well then screw you guys for not making that clear X-P
02:59:00 <elliott> We did, you were all "OH BUT, LANCE WILL SAVE THE DAY" ... which it will.
02:59:17 <quintopia> basically, it results in failure to parse on certain matches where the brackets get expanded too much
02:59:37 <quintopia> and failure to parse is the PROGRAM'S FAULT SO THE PROGRAM LOSES
03:02:46 <Gregor> !bfjoust sugar_philip http://sprunge.us/CjZH
03:03:03 <elliott> In lance, failing to parse aborts the battle immediately :P
03:03:25 <elliott> You know, because it comes from the SANE principle of software design, rather than the WTF principle of software design that Gregor employs in everything and that's why his life is meaningless and empty, devoid of all emotion.
03:03:27 <EgoBot> Score for Gregor_sugar_philip: 4.2
03:03:33 <elliott> Gregor: WHAT AN IMPROVEMENT
03:03:34 <Gregor> ...
03:03:38 <elliott> XD
03:03:41 <Gregor> That was supposed to be testing the fix.
03:04:26 <Gregor> Which didn't work, as I win against different things here than in EgoJSout
03:04:28 -!- zzo38 has quit (Remote host closed the connection).
03:04:35 <elliott> BECAUSE OF LOGIC
03:05:13 <quintopia> why can't i say egojsout? there is no reason here for me to exert the tremendous effort required to reach for the shift key
03:05:17 <Gregor> Just get lance done already :P
03:05:21 <Gregor> quintopia: You were saying bfjsout
03:05:21 <elliott> Gregor: I am :P
03:05:24 <Gregor> quintopia: bfjsout is wrong.
03:05:29 <quintopia> oh
03:05:33 <quintopia> i'm a bit drunk
03:05:37 <quintopia> nevermindme
03:05:38 <elliott> Just debugging a RATHER CURIOUS parser bug, because fucking hell, everything is a fucking parser.
03:05:44 <elliott> All programs have been reduced to parsing.
03:05:50 <elliott> This is the sorry state of the fucking field we're in.
03:05:51 <elliott> Sorry, what?
03:06:17 <Gregor> !bfjoust sugar_philip http://sprunge.us/LHaP
03:06:42 <elliott> !bfjoust
03:06:42 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
03:06:44 <Gregor> Really large decoys will eff up sugar_philip a lot.
03:06:50 <EgoBot> Score for Gregor_sugar_philip: 24.4
03:06:52 <elliott> BTW, egojsout is really quite awesome :P
03:07:04 <elliott> It makes the strategy of programs so clear.
03:08:13 <elliott> Gregor: I like how (+)*-1 still works in EgoJSout... is that on purpose? :-P
03:08:18 <Gregor> Yup :P
03:08:22 <Gregor> Sort of an easter egg :P
03:08:45 <elliott> Gregor: Arguably -1 should be code for "forever" ... admittedly, that's totally faggy, since it reduces the purpose of a large class of loops, but it's already possible because of the cycle limit.
03:08:47 <quintopia> it's equivalent to -?
03:08:53 <elliott> quintopia: no, *100000000000000
03:08:55 <elliott> or whatever
03:09:09 <quintopia> that's dumb
03:09:21 <Gregor> So's your face, but you don't see us complaining about that.
03:09:24 <elliott> quintopia: it's like that in egojoust. why's it dumb.
03:09:24 <quintopia> (+)*-n should be (-)*n :P
03:09:35 <Gregor> ...lol
03:09:40 <elliott> approve
03:09:44 <quintopia> it would make the metagame easier to write for
03:09:47 <elliott> Gregor: Figgrrred out what causes the LAGS in Chrome.
03:09:54 <Gregor> Oh?
03:10:00 <elliott> IT WILL DESTROY YOUR SOUL
03:10:13 <Gregor> Oh really? I thought I'd fixed that >_>
03:10:27 <elliott> Gregor: BTW, could you redirect codu.org/bfjoust to the right place? I keep having to !bfjoust :P
03:10:30 <elliott> I suppose I could bookmark it.
03:10:37 <elliott> Gregor: Oh, do I have to shift-refresh or w/e
03:10:50 <Gregor> Depends on how long it's been since you updated it I suppose :P
03:10:55 <Gregor> That fix was actually a fair bit ago.
03:11:00 <elliott> Since the first time I loaded it, which was when it came out :P
03:11:11 <elliott> (JS URL THAT IS)
03:11:12 <elliott> BOY
03:11:30 <elliott> Just tried it again after refreshing in numerous ways, same problem, runs still stop trickling in.
03:12:02 <elliott> Gregor: Or maybe it's like GC or something ... after a tie, my browser goes all fuxilaggy.
03:12:06 <elliott> Scrolling is painful.
03:12:20 <Gregor> The runs are supposed to stop trickling in if you click one, it's forced to stop.
03:12:29 <Gregor> But it shouldn't become laggy, just switch gears.
03:13:22 <Gregor> ... unless ...
03:14:04 <elliott> 880: 0 75 81 81 7F ED 12 FF 01 00 X80 0
03:14:04 <elliott> 999: 0 75 81 81 7F ED 12 FF 01 00 XD4 0
03:14:25 <Gregor> ...???
03:17:13 <quintopia> it is bug, gregor
03:17:17 <quintopia> the whole thing
03:17:19 <quintopia> bug
03:21:26 <elliott> Gregor: that was just my quote for my prog :P
03:27:49 <Gregor> Heh, I actually did fix the bug, I just forgot that egojoust IS sensitive to *-vs-% :P
03:27:58 <Gregor> !bfjoust sugar_philip http://sprunge.us/YgVQ
03:29:43 <EgoBot> Score for Gregor_sugar_philip: 27.3
03:30:05 <quintopia> gregor: sugar philip pushed vorpal_shudder off the hill :D
03:30:14 <Gregor> !bfjoust sugar_philip http://sprunge.us/iPFe
03:30:22 <Gregor> Funny, I just want to push quintopia_* off ;)
03:30:29 <Gregor> Since you knocked me WAY down from 1st.
03:30:44 <quintopia> Gregor: you're about to push quintopia_when_will_it_explode off
03:30:46 <quintopia> have fun
03:32:38 <elliott> quintopia: wat
03:34:03 <elliott> Gahh, this is hard.
03:37:23 <elliott> wow, this might actually work
03:40:28 <Gregor> !bfjoust sugar_philip http://sprunge.us/FeRb
03:40:36 <Gregor> (Got tired of waiting :P )
03:40:45 <elliott> !bfjoust mexican_wave >>>+<<(>>[[-]+>[-]+>]+[<<])*-1
03:41:05 <elliott> This program does something I haven't seen any other program do.
03:41:16 <elliott> Basically, it visits two cells more every iteration of the "loop".
03:41:21 <elliott> By doing a BF-tape style thing.
03:41:33 <elliott> As in "encoding tapes into BF".
03:41:34 <Gregor> So it'll fail in at least half of the tape lengths? :P
03:41:44 <elliott> Gregor: Nope.
03:41:48 <elliott> Gregor: Because it clears both cells.
03:42:00 <Gregor> If the first cell is the flag, doesn't it wander off?
03:42:06 <elliott> Gregor: Run it and another program in egojsout, you'll see what I mean by "wave".
03:42:08 <elliott> And no.
03:42:13 <Gregor> Okidoke.
03:42:23 <elliott> (It used to be a bit less of a lopsided wave before I added more stuff.)
03:42:42 <EgoBot> Score for Gregor_sugar_philip: 31.2
03:42:43 <EgoBot> Score for Gregor_sugar_philip: 31.2
03:42:48 <EgoBot> Score for elliott_mexican_wave: 1.1
03:42:53 <elliott> Yaaaaay
03:43:00 <Gregor> Wow, mexican_wave causes EPIC FAILURE in sugar_philip sometimes.
03:43:03 <elliott> Howso
03:43:39 <Gregor> I try to avoid getting into a tight [+] loop by backing off, but you make me back off into my own decoys.
03:43:48 <elliott> X-D
03:44:27 <elliott> Gregor: I love how leisurely the normal polarity, 30-length sugar philip vs mexican wave run is.
03:44:43 <elliott> mexican_wave just starts clearing all these cells slooooooooooooooooooowly while you sit around wasting time.
03:45:29 <Gregor> Wow, I pretty epically fail there don't I :P
03:47:03 <elliott> Gregor: I just made a modified mexican_wave that kills sugar_philip ... ... after 8804 turns.
03:47:09 <elliott> It is ... pretty epic.
03:47:30 <elliott> mexican_wave fills the whole tape with crap as slowly as possible while sugar_philip sort of... tags along?
03:47:40 <elliott> Ooh, 11045 turns maximum.
03:47:52 <elliott> Holy shit, more.
03:47:59 <elliott> Gregor: 18911 turns.
03:48:14 <elliott> Gregor: Run sugar philip against this:
03:48:14 <elliott> >>>+<<(>>[(-)*128[+](+)*128>(-)*128[+](+)*128>]+[<<])*-1
03:48:18 <elliott> Polarity inverted, tape length 30.
03:48:20 <elliott> Observe the madness.
03:48:28 <elliott> !bfjoust in_mexico_trains_are_slow >>>+<<(>>[(-)*128[+](+)*128>(-)*128[+](+)*128>]+[<<])*-1
03:49:18 <EgoBot> Score for elliott_in_mexico_trains_are_slow: 4.8
03:49:24 <elliott> X-D
03:49:37 <elliott> From beating sugar_philip, basically.
03:49:41 <elliott> In fact, entirely.
03:49:45 <Gregor> lol
03:49:54 <Gregor> You should set higher goals :P
03:49:55 <elliott> sugar_philip is now #25 X-D
03:53:36 <Gregor> sugar_philip is very experimental X-P
03:54:06 <elliott> *crap
03:57:15 <elliott> Hey Gregor, have you been breaking my parser again
04:06:57 <elliott> Gregor: LANCE: TOTES ALMOST READY
04:08:13 <elliott> Gregor: Should I just support -1 as a synonym for maximum, or -anything? IMPORTANT DECISIONS
04:08:32 <Gregor> A BAJILLION AND A HALF
04:08:40 <elliott> Gregor: THAT'S NOT AN ANSWER
04:19:10 <Ilari> Wow, saw molecular diagrams of vitamin D3 and cholesterol (there's only one kind) side by side. Took a while to spot the differences.
04:19:39 <elliott> Gregor: Woo, just have to implement the actual bodies of ({}) and it's done. (Plain () works.)
04:20:25 <elliott> Gregor: So let me get this straight. ( pushes 0 on one stack, and its iteration count on another stack. } checks the first stack; if it's reached the iteration count, it's a nop (no popping), otherwise, it increments the value on top of the first stack, and goes back after the matching (.
04:20:26 <elliott> Right?
04:20:41 <elliott> And then }) does the same, except checking for 0, and decrementing.
04:21:28 <elliott> Gregor: Or do I only need one stack?
04:22:01 <Ilari> Basically, Cholesterol has C(CH3)C group, Vitamin D3 has C(CH2) .. CH - One hydrogen in different place and one bond in different position.
04:22:09 <Gregor> !bfjoust high_fructose_corn_philip http://sprunge.us/FNgE
04:22:14 <Gregor> elliott: I am now too tired to judge that :P
04:22:21 <elliott> Gregor: Just gueeeesss
04:22:25 <EgoBot> Score for Gregor_high_fructose_corn_philip: 53.7
04:22:25 <elliott> Gregor: Do you need one stack or two
04:22:27 <elliott> For ({})
04:22:39 <elliott> I think you need two, because ( has to push its maximum iteration, so that { can check it.
04:22:40 <Gregor> Just one.
04:22:49 <elliott> Gregor: How does { know when it's iterated enough?
04:22:49 <Gregor> #3 :)
04:23:11 <Gregor> You need to store the count somewhere it can get to.
04:23:25 <elliott> Gregor: i.e. on a stack (for nested ({})s)
04:23:28 <elliott> No?
04:24:03 <Gregor> Ohohoh
04:24:08 <Gregor> Yeah, then you need two stacks :P
04:24:16 <Gregor> I just happen to be storing those inline in my object format :P
04:24:54 <elliott> Gregor: I could store them inline, but then { would have to scan backwards, would it not?
04:25:09 <Gregor> I store that inline too :P
04:25:14 <elliott> Gregor: Of course what I COULD do is put a pointer to the ( in { instructions, and put a pointer to the ) in } instructions.
04:25:19 <elliott> Is that what you do?
04:25:24 <Gregor> Yes
04:25:29 <elliott> Kay.
04:25:42 <elliott> My parser is... quite thoroughly ugly.
04:26:57 <elliott> Gregor: Man, how do you get the pointer to the ) into }s.
04:27:03 -!- Mathnerd314 has quit (Ping timeout: 240 seconds).
04:27:05 <elliott> That seems like it'll be totally fugly for my parser.
04:27:26 <Gregor> I actually stored everything I needed in (, including the location of ), and just go via there.
04:27:46 <elliott> Gregor: Oh, good idea :P
04:27:53 <elliott> Gregor: (That's... so cheating.)
04:28:06 -!- TLUL has joined.
04:28:26 <elliott> *into++ = whole_into[whole_into[j-1]];
04:28:30 <elliott> Indirection, it's what's for dinner.
04:29:14 -!- TLUL has quit (Client Quit).
04:31:41 <elliott> Gregor: Wait, why does ( need to know where ) is?
04:31:47 <elliott> I store the repeat count in (... for some reason...
04:31:54 <elliott> I'm really fucking confused.
04:32:05 <Gregor> ( needs to know where ) is for *0
04:32:28 <elliott> Gregor: Ha, currently I don't even handle *0, it's... an infinite loop X-D
04:32:36 <Gregor> !bfjoust high_fructose_corn_philip http://sprunge.us/dNYZ
04:32:38 <elliott> Gregor: So (x)*0 = xxxxxxxxxxx...
04:32:45 <Gregor> Nice
04:32:48 <EgoBot> Score for Gregor_high_fructose_corn_philip: 0.0
04:32:51 <Gregor> wtfbbq
04:33:21 <Gregor> Oh, egojoust doesn't support ({})-nesting right hyuk X-P
04:34:46 <Gregor> !bfjoust high_fructose_corn_philip http://sprunge.us/TFbD
04:35:01 <EgoBot> Score for Gregor_high_fructose_corn_philip: 52.9
04:35:08 <quintopia> the first one was better
04:35:29 <elliott> quintopia: rewrite my parser
04:35:39 <quintopia> 'kay
04:36:13 <Gregor> !bfjoust rapping_turtle <
04:36:23 <EgoBot> Score for Gregor_rapping_turtle: 0.0
04:36:51 <quintopia> why you killin' the turtle wrapper?
04:37:50 <elliott> $ ./lance '' '({})*3'
04:37:50 <elliott> 2 : Oi -- your program has an unmatched . You can't just bash random keys and expect it to work!
04:37:54 <elliott> An unmatched... what, exactly?
04:38:20 <elliott> Gregor: BTW, I fully intend to make sure !bfjoust reports these amazing complaints to the submitter. You have been warned.
04:38:29 <elliott> This is may payment for writing such an amazing piece of software.
04:38:31 <elliott> *my
04:38:40 <Gregor> quintopia: Got too many on the board.
04:38:59 <quintopia> are they all too similar?
04:42:52 <Gregor> Had three in the turtle family, two in the philip family.
04:42:54 <Gregor> Now have two in each.
04:47:45 <elliott> Hey Gregor guess what I BROKE
04:47:52 <elliott> Ohh
04:47:52 <Gregor> OOOH WHAT
04:47:54 <elliott> Duh!
04:47:55 <elliott> Gregor: IT.
04:49:30 <elliott> Gregor: Basically lance's parser is fucking everything up and it's 5 am.
04:49:31 <Sgeo_> Something happened to me.
04:49:39 <Gregor> elliott: Sweet.
04:49:40 <elliott> Sgeo_: What, exactly?
04:49:52 <Sgeo_> I ate an entire box of pasta. I'm still hungry.
04:50:00 <elliott> An ENTIRE BOX?!?!?!?!
04:50:04 <elliott> Are we talking:
04:50:12 <elliott> - Box you'd store a speck of dust in
04:50:21 <elliott> - Cardboard box you'd store something from Ikea in
04:50:25 <elliott> - Box size of house
04:50:29 <Sgeo_> 8 servings of 2 oz of pasta
04:50:33 <elliott> - The cardboard box surrounding the universe
04:51:04 <elliott> I... need supporters for my religion which says that the universe is surrounded by a cardboard box.
04:52:00 <Gregor> !bfjoust high_fructose_corn_philip http://sprunge.us/URVI
04:52:18 <EgoBot> Score for Gregor_high_fructose_corn_philip: 58.3
04:52:30 <elliott> Gregor: I have done what no man thought possible
04:52:39 * Gregor stretches.
04:52:41 <Gregor> It's good to be king.
04:52:47 <elliott> NO MAN THOUGHT POSSIBLE
04:53:16 <elliott> Gregor: I have turned (foo)*N into (foo)*0.
04:53:17 <elliott> For everything.
04:53:20 <Sgeo_> If no man thought of it at all, then no man thought it possible
04:53:25 <Gregor> elliott: lawl
04:54:27 <quintopia> nice one
04:54:36 <quintopia> i think the philip idea is quite clever
04:54:49 <elliott> I think it's retarded, because I made it do stupid things ;)
04:55:12 <Gregor> quintopia: It still depends fundamentally on this rather durptarded inner loop that's broken if you change your flag too much :P
04:55:22 <elliott> "durptarded"
04:55:24 <Gregor> But yeah, avoids decoys much better than the turtles.
04:55:26 <elliott> A new addition to my lexicon.
04:55:37 <elliott> Hopefully, one that will soon be purged. From the collective memory. Of everyone. Forever.
04:56:33 <elliott> Man... what is wrong with this.
04:56:35 <quintopia> gregor: yeah, it's a nice way of speeding up the careless idea
04:56:59 * elliott looks at trace _what_
04:59:39 <Gregor> Yeah, it'd be tough to beat both quintopia's stuff and the decoyboosters with the careless Philip the turtle strategy.
05:00:01 <quintopia> lol
05:00:25 <elliott> Gregor: Draw Philip the turtle please
05:00:32 <Gregor> Cannot draw :P
05:00:50 <elliott> Gregor: Get that person who drew that existentialism one
05:00:52 <elliott> Make him do it
05:00:54 <elliott> FORCE him
05:00:58 <elliott> I must see Philip the turtle
05:01:06 <Gregor> But he's SO careless durpadurp
05:02:27 <Gregor> Incidentally, in spite of it turning out that it is careless' strategy, I didn't take it from there, I thought of it independently.
05:02:30 <quintopia> you do at least manage to beat ALL of my serious entries with fructose
05:02:35 <Gregor> :)
05:02:40 <Gregor> That's the only reason I'm #1 :P
05:02:53 <Gregor> My points are substantially lower than #2, but I beat #2, #3, #4 :P
05:03:13 <elliott> Gregor: I imagine him smiling, with his eyes slightly further apart than a person of normal intelligence would have, walking in a way that could only be achieved with a complete misunderstanding of the way feet work.
05:03:14 * quintopia shrugs, folds his hands
05:03:18 <elliott> But still. Smiling.
05:03:29 <quintopia> haha
05:03:41 <elliott> SO CUTE.
05:04:51 * quintopia draws
05:05:59 <elliott> quintopia: MAKE SURE HE'S CUTE.
05:06:19 <quintopia> how does a turtle smile
05:06:24 <elliott> quintopia: HAPPILY.
05:07:37 <elliott> Gregor: lance will be all done for EgoBot integration tomorrow probably.
05:22:50 <pikhq> ...
05:23:08 <pikhq> In some US states allowing for common-law marriage, there is no requirement that the parties be male and female.
05:23:23 -!- elliott has quit (Ping timeout: 240 seconds).
05:28:47 <quintopia> here in GA, we don't let little loopholes like that slip through. we past CONSTITUTIONAL AMENDMENTS declaring gay marriage to be EXPRESSLY FORBIDDEN
05:30:47 <quintopia> elliott: http://imgur.com/yQN9j
05:35:56 <Gregor> Wow, this is the first time I've ever felt like oggenc at default settings REALLY let me down.
05:37:09 <Gregor> http://codu.org/tmp/death-2011-02-12.ogg Anyway, what does somebody who isn't an audiophile think of this as a "death ditty"
05:37:12 <Gregor> For a video game
05:38:26 <quintopia> unless people die by waking up from a dream, it sucks
05:38:31 <quintopia> there's nothing deathy about it
05:38:38 <Gregor> It's a very mellow game.
05:38:53 <quintopia> tell the person making this game to include careless Philip the turtle
05:39:00 <Gregor> X_X
05:39:53 <quintopia> i think i know why it doesn't sound deathy
05:39:56 <quintopia> it's too regular
05:40:14 <Gregor> I haven't tweaked the tempo yet at all, it definitely needs to be tweaked.
05:40:50 <quintopia> just sitting here i've hummed a few things with a similar harmonic structure that sound far more deathy
05:46:52 <pikhq> quintopia: I wonder what full faith and credit has to say about that.
05:47:54 <quintopia> not sure what you mean there
05:53:56 <Gregor> http://codu.org/tmp/death-2011-02-12-2.ogg Bleh, I shouldn't try to finesse rhythm at 1AM after being awake from 8AM X_X
05:53:58 <Gregor> *sleep*
05:54:10 <quintopia> nainai
06:13:55 <pikhq> WHY GOD WHY
06:14:19 <pikhq> A sequel to Manos: The Hands of Fate.
06:14:37 <pikhq> It is considered by many to be the worst film.
06:15:45 <quintopia> :D
06:15:53 <quintopia> where can i get the MST3K of it?
06:16:31 <pikhq> I was only able to find it on Google Videos.
06:17:06 <pikhq> Said Google Video upload is actually official.
06:17:17 <pikhq> Low-quality, but nevertheless.
06:17:29 <pikhq> Oh, well, there's also the "complete MST3K" torrents.
06:30:39 -!- copumpkin has joined.
06:35:39 -!- nescience has quit (Quit: AndroidIrc Disconnecting).
07:09:12 <myndzi> wow gregor
07:09:17 <myndzi> i couldn't geet code like that to work
07:09:19 <myndzi> congrats ;p
07:09:55 <myndzi> that's kinda what i wanted to do with careful but i wasn't having much luck writing it properly... or at least i didn't think that such ridiculous exponential expansion would fly
07:18:40 -!- asiekierka has joined.
07:48:30 <myndzi> oooh i have what could be a pretty good idea
07:48:36 <myndzi> why do i have such ideas when i'm trying to sleep though?!
07:48:49 <myndzi> it's actually more of an extension of an idea but whatever
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:18:37 -!- copumpkin has quit (Ping timeout: 255 seconds).
09:19:04 -!- copumpkin has joined.
10:05:50 -!- oerjan has joined.
10:09:56 -!- MigoMipo has joined.
10:11:17 <oerjan> <elliott> Gregor: Hmm, yeah. That's weird... uh, you realise that by loop stack I mean [] loop stack?
10:12:32 <oerjan> technically you don't need a loop stack either, you could save the current count somewhere associated with the loop, since it cannot be entered twice simultaneously. not that that is any simpler.
10:13:02 <oerjan> *a () loop stack
10:13:22 <oerjan> well, for running. for parsing is a different matter.
10:13:51 <oerjan> (you need two stacks for parsing, although one could be replaced with recursion.)
10:18:51 <oerjan> <elliott> Gregor: Would you hold it against me if I used an actual parser generator for lance rather than hacking up this awful thing? X-D <-- ah. that may be a problem since the language isn't CF. (see previous comment)
10:20:16 <oerjan> well, i guess you could use a parser generator for one half, and track the ({}) matching separately.
10:26:55 <oerjan> <elliott> quintopia: the debate is: does a language have to have a simulator for /all/ Turing machines to be TC, or is a simulator for just one enough? <-- note that commonly accepted TC models where the input must be encoded into the program, such as the lambda calculus, cannot possibly make a meaningful distinction between these
10:28:33 <oerjan> i.e. in my view this distinction is wholly based on fixing a particular notion of I/O for the model, something which may be an absurd restriction for purely mathematical models.
10:29:04 <oerjan> although turing machines themselves do have a distinction between program and tape
10:29:48 <oerjan> *between machine and tape
10:31:53 -!- copumpkin has quit (Ping timeout: 245 seconds).
10:32:18 -!- copumpkin has joined.
10:32:42 <oerjan> 02:34:20 <elliott> quintopia: when questioned he has been
10:32:42 <oerjan> 02:34:21 <elliott> EXCEEDINGLY
10:32:42 <oerjan> 02:34:23 <elliott> ELUSIVE
10:32:59 <oerjan> conclusion: he composes electronic music for porn films
10:39:50 -!- FireFly has joined.
10:52:25 -!- BeholdMyGlory has joined.
10:59:12 <oerjan> <elliott> Gregor: So let me get this straight. ( pushes 0 on one stack, and its iteration count on another stack. } checks the first stack; if it's reached the iteration count, it's a nop (no popping), otherwise, it increments the value on top of the first stack, and goes back after the matching (.
10:59:37 <oerjan> argh you must pop if you want to support my beautiful (({{}})*)* notation :(
10:59:59 <oerjan> (in {)
11:01:43 <oerjan> also, only one stack
11:22:16 -!- FireFly has quit (Quit: swatted to death).
11:26:51 -!- cheater00 has quit (Ping timeout: 240 seconds).
11:27:13 -!- cheater- has joined.
11:33:37 <oerjan> ok i'm trying to find an example that (({{}})%)% is actually useful
11:34:02 <oerjan> so the first program i downloaded the other day, ais523_attack7.bfjoust
11:34:02 <oerjan> (>)*5(+)*40<(-)*40(>)*4(>[+[+[+[+[-----[-[-[-[-](-)*122[-.]]]]]]]]])*21
11:34:57 <oerjan> (first alphabetically, that is)
11:35:41 <Ilari> Huston estimate for APNIC depletion is August 15th. Has been coming nearer in last few days.
11:36:47 -!- cheater- has quit (Ping timeout: 240 seconds).
11:37:24 <oerjan> nah fuck that doesn't need more than ordinary ({}) :(
11:37:57 -!- cheater- has joined.
11:38:51 -!- Tritonio has joined.
11:41:14 -!- asiekierka has quit (Ping timeout: 255 seconds).
11:45:14 -!- Tritonio has quit (Quit: Leaving).
12:23:10 -!- cheater- has quit (Ping timeout: 240 seconds).
12:24:14 -!- cheater- has joined.
12:35:19 <oerjan> jix_wiggle2 would have been a good candidate for (({{}})) if it was slightly more ordered instead of trying that hard to be unpredictable
12:41:37 <oerjan> well at least i am assuming it is unpredictable, i didn't look at _that_ much of it
12:44:34 * oerjan tries simplifying with s///
12:52:31 -!- asiekierka has joined.
12:53:36 -!- cheater- has quit (Ping timeout: 240 seconds).
12:53:44 -!- cheater00 has joined.
12:58:29 <oerjan> basically, if there is a pattern to how jix alternates the +, - and other things in there, then it probably can use (({{}})%)% for simplification, but if it's not repetitive then it cannot.
12:58:59 <oerjan> (there are obvious patterns, but they seem to have a random element at first glance)
13:33:32 -!- oerjan has quit (Quit: Lost terminal).
14:25:34 -!- iconmaster has joined.
15:04:46 <Gregor> oerjan: Why are you not here now :P
15:05:02 <Gregor> high_fructose_corn_philip's canonical implementation uses (({{}}))
15:05:33 <Gregor> Works on egojsout, but not egojoust
15:11:01 -!- ais523_ has joined.
15:14:34 <Gregor> ais523_: Y'know you're all the way down to fifth now, right?
15:14:38 <Gregor> ais523_: You gonna take that? :P
15:14:50 <ais523_> maybe I'll have to, I'm kind-of busy at work
15:14:56 <ais523_> besides, I care more about playing than winning
15:17:04 -!- copumpkin has quit (Ping timeout: 240 seconds).
15:17:09 -!- Behold has joined.
15:17:30 -!- copumpkin has joined.
15:21:04 -!- BeholdMyGlory has quit (Ping timeout: 272 seconds).
15:22:58 -!- olsner has quit (Ping timeout: 272 seconds).
15:23:35 <Vorpal> Gregor, "egojsout"?
15:23:52 <Gregor> Vorpal: http://codu.org/eso/bfjoust/egojsout/
15:24:01 -!- Sgeo_ has quit (Read error: Connection reset by peer).
15:24:15 <Vorpal> <ais523_> besides, I care more about playing than winning <--- what, someone actually believes that playing is more important than winning
15:24:34 <Vorpal> ais523_, you know what. Sometimes you remind me of Carrot from the Discworld books.
15:24:52 <ais523_> Vorpal: but I don't know the name of everyone in the universe
15:25:36 <Vorpal> ais523_, indeed. But in many other aspects...
15:26:45 <Vorpal> ais523_, you seem to act the way everyone think is a good idea but no one does. Like believing that playing is more important than winning. Everyone says that. But very few actually act like they really think that.
15:27:05 <ais523_> well, it depends on where the interest of the game is
15:27:24 <ais523_> I play nomic to win, not because I like winning for the sake of it, but because the win conditions are normally designed to be things that are interesting to aim for
15:27:44 <ais523_> but I tend to value manipulating a win for someone else as highly as manipulating a win for myself
15:27:48 <ais523_> as it takes the same sort of skill
15:28:01 <Vorpal> hah
15:29:44 -!- Zuu has quit (Ping timeout: 260 seconds).
15:33:45 <Gregor> !bfjoust sucralose_philip http://sprunge.us/dVNA
15:34:50 * Gregor has high hopes for sucralose_philip :)
15:35:14 -!- olsner has joined.
15:35:57 <fizzie> Incidentally, I did a silly little egojoust-implementation experiment too: http://p.zem.fi/5zkw + http://p.zem.fi/bd54 [the name is a bit stolen from elliott and far too pompous, but try to disregard that]
15:35:58 -!- p_q has joined.
15:36:25 <EgoBot> Score for Gregor_sucralose_philip: 56.0
15:36:32 <Gregor> fizzie: egojoust IS an implementation, surely you either mean "bfjoust-implementation" or "egojoust-reimplementation"
15:36:39 <fizzie> Yes, the latter.
15:36:54 <Gregor> Bahahaha, even less points than HFCP, even higher score (though not by much)
15:37:05 <fizzie> Since it does egojoust-specificly the all-tape-lengths-and-polarity-flippery thing.
15:37:36 <Gregor> Pff, that should be considered canonical BF Joust now :P
15:37:55 -!- poiuy_qwert has quit (Ping timeout: 240 seconds).
15:38:23 <Gregor> !bfjoust sugar_philip <
15:38:39 <EgoBot> Score for Gregor_sugar_philip: 0.0
15:38:45 <ais523_> it's nice to see an esolang evolve
15:40:20 <Gregor> It's also nice to see my competitors dominate the hill >: )
15:41:15 <ais523_> I want to do another defend9-based program sometime, I think it could do quite well
15:41:32 <ais523_> adjusted to work versus current strategies rather than really old strategies
15:41:38 <fizzie> Uh, how do you read ">: )"? Noseless with horns, or uncanonical-orientation sharp-frowny highbrow?
15:41:39 <ais523_> but not now, as you can tell from my nick I'm not on my own computer
15:42:27 <Gregor> fizzie: Smiley with evil eyebrows
15:42:50 <fizzie> But the... the empty space where your nose should be. Surely that's not a normal face.
15:42:52 <Gregor> I make it noseless so that clients that turn :-) into a graphical smiley don't turn >:-) into a horrible abomination.
15:43:23 <fizzie> I guess that makes 'sense'.
15:49:19 <Gregor> !bfjoust julius_freezer (+(-)*2(+)*3(-)*5(+)*7(-)*11(+)*13(-)*17)*100000
15:50:11 -!- Sgeo has joined.
15:50:19 <EgoBot> Score for Gregor_julius_freezer: 20.6
15:51:19 <Gregor> Better than I expected.
15:51:34 <Gregor> It also inverted HFCP and sucralose_philip :P
15:51:54 <Gregor> Oh, that's in third-to-last place X-P
15:51:58 <Gregor> I guess I'll just let it die :P
15:52:18 <ais523_> is that yet another shudderer?
15:53:44 <Gregor> Yeah, just wanted to see if things had changed w.r.t. other strategies :P
15:54:01 <Gregor> Since I know that both the turtles and the philips don't do well against shuddering.
15:55:54 <ais523_> how do the phillips work?
15:57:08 -!- BeholdMyGlory has joined.
15:57:29 <Gregor> They try to adjust the cell within a small range (+-8ish?) using []-loops, and if that fails they try a turtle-style thoughtless addition. sucralose_philip additionally switches to steamroller if it finds four big decoys.
15:58:47 <ais523_> ah, that's more or less how decoytuner works
15:59:09 <ais523_> it's hard coming up with genuinely innovative ideas nowadays; rule_of_nine was one, but it's rubbish
15:59:24 -!- Behold has quit (Ping timeout: 255 seconds).
15:59:48 <ais523_> (the idea was to look at where an opponent attacked to deduce the location of its flag, because nearly all programs start attacking nine squares from their flag, where the first possible location for the enemy flag is)
16:00:08 <Gregor> Hm
16:00:15 <Gregor> If their attack is []'d though, that's borklebork :P
16:00:33 <ais523_> !bfjoust oneway_shudder (+++++++++++++++)*1000
16:00:51 <Gregor> Curious way to write that :P
16:00:53 <ais523_> Gregor: well, it had to try to set a decoy on every cell of the tape in order to get round the problem
16:00:58 <ais523_> and I think that's where the issue is
16:00:59 <Gregor> I think I made that as spin_me_right_round at one point.
16:01:11 <ais523_> Gregor: someone told me that egojoust cut off repeats after a while
16:01:24 <EgoBot> Score for ais523__oneway_shudder: 13.0
16:01:35 <ais523_> !bfjoust oneway_shudder ((((((+)*10)*10)*10)*10)*10)*10
16:01:40 <Gregor> ais523_: 100K
16:01:40 <ais523_> let's make sure
16:02:18 <ais523_> I want to see the amazing drawing ability of that program
16:02:27 <ais523_> in particular, what it draws to on one polarity, and what it loses against
16:02:27 <Gregor> lol
16:03:12 <EgoBot> Score for ais523__oneway_shudder: 13.1
16:03:47 <Gregor> !bfjoust lead_acetate_philip http://sprunge.us/RBIF
16:04:01 <ais523_> Gregor: note the difference in score between the two versions
16:04:01 <EgoBot> Score for Gregor_lead_acetate_philip: 54.2
16:04:09 <Gregor> ais523_: It was running on a different hill.
16:04:22 <ais523_> well, OK
16:04:29 <Gregor> !bfjoust sucralose_philip <
16:04:42 <EgoBot> Score for Gregor_sucralose_philip: 0.0
16:05:01 <Gregor> Somehow that let wireless_frownie back into spot #2 :P
16:05:04 <ais523_> btw, some turtle names that IIRC you haven't used yet: strapping; scrapping; slapping
16:05:05 <Gregor> Maybe I want to undo that X-D
16:05:15 <Gregor> I'm done with turtles though :P
16:05:19 <fizzie> !bfjoust lostkng http://p.zem.fi/lostkng
16:05:24 <fizzie> (The most sensible thing.)
16:05:25 <Gregor> fizzie: lawl
16:05:33 <ais523_> that actually made me laugh out loud
16:05:49 <ais523_> good thing I'm the only person in the office right now (= good thing it's Saturday)
16:06:17 <quintopia> what is lostkng?
16:06:23 <EgoBot> Score for fizzie_lostkng: 0.4
16:06:27 <Gregor> quintopia: Run it in a standard BF interpreter.
16:06:27 <quintopia> a game?
16:06:29 <ais523_> wow, lostkng's beating more or less everything on tape lengths 11 and 14
16:06:31 <fizzie> Ooh, a non-zero score.
16:06:41 <ais523_> and losing to most things on most other tape lengths
16:06:42 <quintopia> Gregor: i don't wanna. just tell me what it was?
16:07:06 <ais523_> it's a text adventure
16:07:13 <quintopia> that was my guess
16:07:16 <ais523_> a rather difficult one, too; I never got very far in it
16:07:24 <Gregor> !bfjoust sucralose_philip http://sprunge.us/dVNA
16:07:30 <quintopia> wasn't it the longest BF program ever written?
16:07:36 <Gregor> But it wasn't written..
16:07:40 <EgoBot> Score for Gregor_sucralose_philip: 51.8
16:07:42 <fizzie> I did remove the [-][.] part that it had in the start.
16:07:43 <Gregor> !bfjoust lead_acetate_philip <
16:07:46 <ais523_> it was generated
16:07:55 <EgoBot> Score for Gregor_lead_acetate_philip: 0.0
16:08:07 <Gregor> Heywhatthe D-8
16:08:21 <Gregor> !bfjoust lead_acetate_philip http://sprunge.us/RBIF
16:08:21 <quintopia> Gregor: auto-generated?
16:08:29 <Gregor> quintopia: Compiled.
16:08:31 <EgoBot> Score for Gregor_lead_acetate_philip: 53.6
16:08:34 <Gregor> !bfjoust sucralose_philip <
16:08:49 <EgoBot> Score for Gregor_sucralose_philip: 0.0
16:09:54 <ais523_> !bfjoust anti_decoybooster (>)*8(>[[>]>((-)*120(.-)*16)*20])*21
16:10:08 <EgoBot> Score for ais523__anti_decoybooster: 0.0
16:10:13 <Gregor> ...???
16:10:15 <ais523_> ouch, that bad?
16:10:16 <quintopia> huh
16:10:42 <ais523_> apparently it loses to decoybooster
16:10:49 * ais523_ debugs
16:10:53 <quintopia> you were trying to beat the ones that put decoys in reverse order?
16:11:32 <ais523_> oh, I see
16:11:33 <ais523_> quintopia: yep
16:12:11 <ais523_> !bfjoust anti_decoybooster (>)*8(>[[>](>[(-)*120[-]])*20])*21
16:12:25 <EgoBot> Score for ais523__anti_decoybooster: 10.0
16:12:31 <ais523_> hmm, should probably have a double tripwire there
16:12:40 <ais523_> ah no, it isn't necessary
16:12:45 <Gregor> !bfjoust tape_length_15_ahoy >>>>>>>>>>>>>(-)*128.([-]>)*16
16:12:48 <Gregor> Best - idea - ever
16:13:07 <quintopia> bindun
16:13:12 <EgoBot> Score for Gregor_tape_length_15_ahoy: 1.4
16:13:17 <Gregor> YAY
16:13:25 <Gregor> quintopia: INB4STFU
16:13:29 <ais523_> !bfjoust anti_decoybooster (>)*5(>[[>](>[(-)*120[-]])*10])*24
16:13:44 <EgoBot> Score for ais523__anti_decoybooster: 15.0
16:13:49 <ais523_> just realised that if I'm detecting decoys, I probably shouldn't be skipping them...
16:14:36 <quintopia> goodpoint :P
16:15:03 <quintopia> experiment time!
16:15:14 <quintopia> !bfjoust wireless (>)*8+<-<(+)*18<(-)*19(<(-)*127<(+)*127)*2<(-)*17(>)*9([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>)*21
16:15:27 <quintopia> this one does beat hfcp but i dunno if it does well
16:15:42 <EgoBot> Score for quintopia_wireless: 49.6
16:15:51 * Gregor shakes his fist.
16:15:53 <quintopia> ah not so well :P
16:16:06 <Gregor> quintopia: No, but its defeating HFCP twiddled the leaderboard.
16:16:24 <Gregor> (I needed those points :P )
16:16:26 <ais523_> !bfjoust triple_tripwire_avoider (>[>>(>(-)*120[-])*21])*29
16:16:37 <ais523_> let's see how well large tripwire avoiders do on the current hill
16:16:37 <quintopia> lap is till winning!
16:16:39 <EgoBot> Score for ais523__triple_tripwire_avoider: 10.8
16:16:52 <ais523_> !bfjoust double_tripwire_avoider (>[>(>(-)*120[-])*21])*29
16:17:06 <EgoBot> Score for ais523__double_tripwire_avoider: 23.8
16:18:15 <Gregor> Not bad
16:18:15 <ais523_> !bfjoust double_tripwire_avoider (>)*4(>[>(>(-)*120[-])*21])*22(>++[-])*3
16:18:30 <EgoBot> Score for ais523__double_tripwire_avoider: 20.0
16:18:36 <ais523_> hmm, I wonder why that did worse?
16:18:50 <quintopia> Gregor: 17 is actually the smallest thing i can decrement my flag by and still beat hfcp. it's not vulnerable to small changes in timing at all
16:19:03 <ais523_> !bfjoust double_tripwire_avoider (>)*4(>[>(>(-)*120[-])*21])*23(>++[-])*2
16:19:18 <EgoBot> Score for ais523__double_tripwire_avoider: 20.9
16:19:27 <ais523_> !bfjoust double_tripwire_avoider (>)*3(>[>(>(-)*120[-])*21])*24(>++[-])*2
16:19:45 <EgoBot> Score for ais523__double_tripwire_avoider: 21.0
16:19:57 <ais523_> !bfjoust double_tripwire_avoider (.)*32(>)*4(>[>(>(-)*120[-])*21])*23(>++[-])*2
16:20:02 <ais523_> just trying an idea here...
16:20:09 <EgoBot> Score for ais523__double_tripwire_avoider: 20.1
16:20:12 <quintopia> !bfjoust wireless (>)*8+<-<(+)*18<(-)*19(<(-)*127<(+)*127)*2<(-)*11(>)*9([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>)*21
16:20:17 <quintopia> there you go. back how it was.
16:20:18 <ais523_> !bfjoust double_tripwire_avoider (+)*32(>)*4(>[>(>(-)*120[-])*21])*23(>++[-])*2
16:20:34 <EgoBot> Score for quintopia_wireless: 48.7
16:20:35 <EgoBot> Score for ais523__double_tripwire_avoider: 20.1
16:20:47 <quintopia> huh. that does worse. :P
16:20:56 <Gregor> quintopia: You've gotta stop wandering DOWN the hill :P
16:21:00 <quintopia> !bfjoust wireless (>)*8+<-<(+)*18<(-)*19(<(-)*127<(+)*127)*2<(-)*17(>)*9([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>)*21
16:21:04 <quintopia> FINE
16:21:16 <ais523_> Gregor_high_fructose_corn_philip.bfjoust vs ais523__double_tripwire_avoider.bfjoust: >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> ais523__double_tripwire_avoider.bfjoust wins
16:21:25 <EgoBot> Score for quintopia_wireless: 50.6
16:21:31 <Gregor> ais523_: You make me sad :P
16:21:46 <Gregor> quintopia: Uhh ... proceed wandering down the hill ...
16:21:51 <ais523_> it also beats one of the turtles and ties with the other one
16:22:12 <Gregor> ais523_: And lead_acetate_philip?
16:22:23 <quintopia> !bfjoust i_like_turtles (+)*17>>>>(+)*33<(-)*65<(+)*91<(-)*128>>>>>>>>([-[++[(+)*15[.-]]]]>)*21
16:22:26 <ais523_> beats it on all 42 configs too
16:22:43 <EgoBot> Score for quintopia_i_like_turtles: 53.1
16:22:57 <Gregor> Oh I see, we're playing the arms-race game :P
16:23:00 <quintopia> Gregor: just for you, i'm not going to tweak wireless_frownie
16:23:15 <ais523_> quintopia: I still think 85 is the optimal height for a large decoy
16:23:26 <ais523_> if you make it any taller, on average you help the opponent if they guess the wrong polarity
16:23:43 <quintopia> yes that's true
16:23:43 <ais523_> but perhaps I'm wrong in that
16:23:50 <quintopia> no i think that's right
16:24:16 <ais523_> my defend9 variant will probably use a height-85 decoy too, as it produces the most clear-cut timing differences
16:24:33 <ais523_> although it'd be confused by an offset clear of height 28 or more
16:24:56 <ais523_> perhaps I can design defence mechanisms that work best against the detected height, but well against the next-nearest
16:24:58 <quintopia> ais523_: couldn't you put a small decoy in front of your large decoy to check the offset size?
16:25:03 * Gregor is unsure where to go with lead_acetate_philip :P
16:25:19 <ais523_> that makes you vulnerable to turtle-style programs, as they look like a really large offset clear and then go destroy your flag
16:25:24 <Gregor> 986: 2 <00 8F 6F 83 7B 83 7B 04 FC 01 01 01 01 01 01 01 01 01 01 01 01 01 01 6B 6B 01 80 >05 0 LAAAAAAAAAAAAAAAAME
16:25:56 <quintopia> Gregor: egojsout should do that
16:26:14 <Gregor> It ... does?
16:26:21 <quintopia> Gregor: print "LAAAAAAAAAAAAAAME" on the last line
16:26:23 <quintopia> every time
16:26:25 <Gregor> Ahhhh :P
16:27:06 <ais523_> !bfjoust double_tripwire_avoider (+)*32(>)*4(>[>(>[(-)*120[-]])*21])*23(>++[-])*2
16:27:22 <EgoBot> Score for ais523__double_tripwire_avoider: 39.5
16:27:33 <ais523_> I added a defence detector and reverse-decoy detector
16:28:05 <quintopia> ais523_: why is 85 better than 128 for regular offset clears? is it only better when turtle-style programs are taken into account?
16:28:46 <ais523_> it's because you don't know what polarity the opponent's aiming at; 128 means you don't punish them for being on the wrong polarity
16:29:09 <ais523_> so the extra time you spent setting up the flag is useless, as it takes them an average of 256 to clear from both 85 and 128
16:29:20 <ais523_> (85 means it takes twice as long to clear "backwards" as "forwards")
16:29:22 <ais523_> *setting up the decoy
16:29:34 <quintopia> hmm
16:30:33 <quintopia> Gregor: write a philip program that quick decrements by 85 before doing the slow clear. it's gonna be the next big thing.
16:30:44 <Gregor> :P
16:31:38 <ais523_> !bfjoust double_tripwire_avoider (+)*32(>)*4(>[>(>[(-)*120[-.]])*21])*23(>++[-])*2
16:31:41 <quintopia> !bfjoust wireless (>)*8+<-<(+)*18<(-)*19(<(-)*85<(+)*85)*2<(-)*17(>)*9([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>)*21
16:31:58 <ais523_> just seeing if a three-cycle clear makes any difference, although I doubt it will as dodging tripwires generally beats defence anyway
16:32:23 <EgoBot> Score for quintopia_wireless: 55.9
16:32:24 <EgoBot> Score for ais523__double_tripwire_avoider: 37.8
16:32:34 * quintopia shakes ais523_'s hand
16:32:40 -!- Zuu has joined.
16:32:44 <quintopia> as usual, sir, you are spot on
16:33:04 <ais523_> yep, it's better faster
16:33:20 <ais523_> !bfjoust double_tripwire_avoider (+)*32(>)*4(>[>(>[+[--[(-)*120[-]]]])*21])*23(>++[-])*2
16:33:25 <ais523_> let's dodge trails too
16:33:36 <EgoBot> Score for ais523__double_tripwire_avoider: 45.3
16:33:42 <ais523_> as they're the most likely reason for an enemy to have set up lots of decoys
16:33:43 <quintopia> nice
16:34:14 <ais523_> up there with defend13, now
16:34:23 <quintopia> careless jumped up i think
16:34:28 <ais523_> is that the highest a tripwire-avoider's ever got?
16:34:55 <quintopia> it's not really a relevant question :P
16:35:08 <ais523_> well, they always used to do badly
16:35:11 <quintopia> it's the only tripwire avoider on the hill
16:35:18 <Gregor> ais523_: "(>)*9([(-)*128>])*21" vs ".", who SHOULD win?
16:35:36 <quintopia> and it's unlike any other tripwire avoider in many way
16:35:58 <ais523_> so left program, marginally
16:35:58 <ais523_> Gregor: draw on all tape lengths but 10, left program wins on length 10 regardless of polarity
16:36:01 <quintopia> Gregor: the nop
16:36:11 <Gregor> ais523_: wtf, why does left program win on 10?
16:36:11 <quintopia> (it doesn't suicide)
16:36:27 <quintopia> oh
16:36:28 <ais523_> oh right, left program loses
16:36:28 <quintopia> wait
16:36:29 <ais523_> as the > is suicide
16:36:34 <ais523_> and draw on other tape lengths
16:36:40 <quintopia> the > is inside the brackets
16:36:45 <Gregor> It suicides on ANY tape length.
16:36:46 <ais523_> yep
16:36:53 <Gregor> However, it does that on the second flag-down turn.
16:36:57 <ais523_> no it doesn't, on other tape lengths it just does repeated [] loops
16:37:01 <ais523_> and doesn't move
16:37:07 <quintopia> it only suicides on tape 10
16:37:15 <ais523_> as there's no < or > except inside the square brackets, apart from the first 9
16:37:20 <Gregor> Ohyeah :P
16:37:27 <Gregor> "(>)*9([(-)*128>]>)*21" then :P
16:37:38 <quintopia> now it always suicides
16:38:01 <Gregor> So a suicide, even as the flag is down for the second turn, is a loss?
16:38:18 <ais523_> yep, at least as egojoust implements it
16:38:20 <quintopia> you left the > inside the bracket
16:38:31 <quintopia> take that out and it won't
16:38:45 <ais523_> because the > happens during the turn, whereas flag loss is measured at the end of the turn
16:38:58 <ais523_> I can see an argument for making it considered a draw, though
16:39:06 <Gregor> It's a draw in egojsout X-P
16:39:21 <ais523_> ah, hmm, the documentation on the wiki implies it should be a draw
16:39:31 <quintopia> i disagree. i think dying at someone else's hands is marginally smarter than suiciding
16:39:34 <ais523_> I doubt it comes up very often
16:41:00 <quintopia> we almost had the shudders pushed off the board at some point (vorpal's copy is actually gone), and now they've started climbing again
16:41:08 <quintopia> i blame gregor
16:41:33 <quintopia> he could modify philip so it beats shudder but NOOOOOO
16:41:44 <ais523_> well, it's a valid strategy
16:41:55 -!- FireFly has joined.
16:42:01 <ais523_> also, what's with the topic?
16:42:07 <Gregor> I have no idea :P
16:43:04 -!- Gregor has set topic: Topic revoked under DMCA by the Department of Homeland Security | | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
16:43:37 -!- quintopia has set topic: tripwires and turtles and tuners, oh my! | | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
16:43:40 <quintopia> A TOPIC
16:43:43 <quintopia> THAT IS ACTUALLY TOPICAL
16:43:49 <ais523_> oh, I like that topic
16:43:54 <quintopia> for the first time in #esoteric history, i'm sure
16:44:24 <ais523_> Gregor_quapping_turtle.bfjoust vs ais523__double_tripwire_avoider.bfjoust: >>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< >>>>>>>>>>>>>>>>>>>>> Tie
16:44:28 <ais523_> that one's interesting...
16:44:34 <quintopia> huh
16:45:16 <Gregor> quintopia: My canonical topic that was here for a fair while was Welcome to #esoteric, the international hub for esoteric programming language design and deployment - #esoteric is not associated with the joke language Perl, for that language please visit www.perl.org or #perl - logs: http://tunes.org/~nef/logs/esoteric/?C=M;O=D
16:45:18 <fizzie> Incidentally, I think the report table looks marginally more interesting like http://p.zem.fi/erep this, since you can sort-of see how the +'s and -'s cluster in their own separate halves.
16:45:52 <Gregor> fizzie: I had actually thought about that.
16:46:00 <quintopia> Gregor: i think that was the topic when i first came here
16:46:03 <ais523_> oh, it seems quapping turtle reaches the flag first by miles, but the flag adjustment I did to waste time causes it to die on one polarity
16:47:02 <ais523_> I'd like to see an organisation of "similar" programs, determined via programs that beat similar sets of programs
16:47:07 <quintopia> Gregor: moving the program numbers to the right side of the table would improve readability immensely. it's very difficult to trace the line from a - up to a number, find the number on the left, and then trace back to the right again.
16:47:09 <ais523_> but I'm not sure how you'd do that
16:47:15 <ais523_> it probably involves eigenvectors or something
16:47:22 <quintopia> ais523_: edit distances on win/loss records
16:47:38 <quintopia> erm
16:47:42 <quintopia> not even edit distances
16:47:49 <ais523_> quintopia: I mean, saying "this program is 50% group A, 25% group B, 25% group C"
16:47:51 <quintopia> L1 distance would work just as well
16:47:54 <ais523_> and we then identify what the groups are
16:48:04 <ais523_> I think that's what eigenvectors do
16:48:04 <quintopia> oh
16:48:06 <Vorpal> <quintopia> he could modify philip so it beats shudder but NOOOOOO <-- why do you hate shudders!?
16:48:10 <quintopia> yeah, that seems hard
16:48:16 <Vorpal> quintopia, what have they done to you?
16:48:36 <quintopia> Vorpal: i don't. i just want every program on the hill to do well against such a simple and mindless strategy.
16:48:49 <quintopia> that's the whole reason they exist, isn't it?
16:48:56 <Vorpal> quintopia, "mindless". Harsh words.
16:49:33 <fizzie> ais523_: There's a bazillion ways to do clustering (also soft clustering where you get partial membership values), and, well, not all of them involve eigenvectors/values. Spectral clustering does, though.
16:49:36 <quintopia> it doesn't contain a single [ anywhere. therefore, it doesn't really "think"
16:50:05 <Gregor> !bfjoust i_regret_everything (-)*127>(+>)*8([-]>)*21
16:50:21 <Vorpal> quintopia, none of them think!
16:50:28 <quintopia> FINE
16:50:38 <Vorpal> quintopia, and it contains no [ for speed reasons
16:50:39 <fizzie> (-)*127 sounds like quite a start.
16:50:46 <quintopia> Gregor: what would the rules be for the metabfjoust tournament?
16:51:04 <EgoBot> Score for Gregor_i_regret_everything: 15.1
16:51:09 <Vorpal> quintopia, making the best bfjoust tournament?
16:51:13 <Vorpal> (that's quite meta)
16:51:15 <Gregor> quintopia: I haven't fully decided, that's why I haven't made them. The BFJoust runs themselves would be identical.
16:51:23 <quintopia> obv
16:51:40 <Gregor> quintopia: I want to make it fair in terms of runtime, which makes me consider requiring submission of something that can have a canonical cycle count.
16:51:57 <ais523_> careless and Nyarlathotep also contain no [, IIRC
16:52:02 <Gregor> Like MIPS binaries or something. I could make it "easier" by allowing you to submit C if you aren't as concerned about cycle counts. I just want it to be 100% consistent.
16:52:02 <quintopia> but deciding how many programs each program gets to try against each competitor so as to give it time to "learn" the other program's "strategy" seems the main thing here
16:52:30 <Gregor> Well I'd give you plenty of cycles, I just can't solve the halting problem is all :P
16:52:36 <quintopia> Gregor: fuck that. measure time in ms like everyone else :P
16:53:04 <Vorpal> Gregor, cycle count is better IMO
16:53:36 <fizzie> Z80 binaries, since that seems to be the thing people spend large amount of time golfing, too.
16:53:57 <Gregor> quintopia: That creates nondeterminism. Nondeterminism is bad.
16:54:08 <Gregor> fizzie: I'd like something that's easy to compile C to :P
16:54:21 <quintopia> Gregor: as long as all the programs are in a reasonably fast language and running on the same computer and don't run simultaneously (or if they do, run on different cores), the cycle count differences will be insignificant
16:54:48 <Gregor> quintopia: Nice theory.
16:54:53 <Gregor> quintopia: It's completely wrong, but it's a nice theory.
16:54:57 <Vorpal> quintopia, incorrect
16:55:02 <quintopia> Gregor: esp. if you dedicate a CPU entirely to them and don't let anything else run on them.
16:55:14 <Vorpal> quintopia, do you know about L3 cache?
16:55:23 <fizzie> Gregor: Well, 6502 asm and cc65, that's "C".
16:55:26 <Vorpal> I have to presume you don't
16:55:37 <Gregor> That might be borderline-correct if you were on a realtime system, but aside from everything else, Codu is a friggin' VM running Linux. Just no.
16:55:57 <Vorpal> quintopia, L3 cache is shared between cores.
16:56:03 <quintopia> Vorpal: why is cache going to play a factor here. we don't expect to be accessing a lot of memory for this game.
16:56:05 <Vorpal> or even CPUs in some design
16:56:21 <Vorpal> quintopia, it will possibly stall cache still
16:56:24 <Vorpal> it might happen
16:56:34 <Vorpal> thus non-determinism
16:57:10 <quintopia> alright
16:57:16 <Vorpal> quintopia, beside depending on heat the actual clock frequency will vary a bit
16:57:34 <quintopia> let's run the tournament on an arduino :P
16:57:40 <Vorpal> quintopia, why that one
16:58:01 <quintopia> i just picked a popular chip that's reasonably priced and can be compiled to from C
16:58:17 <Gregor> The idea is to simulate.
16:58:21 <Vorpal> quintopia, arduino is not a chip. It is a development board.
16:58:22 <Gregor> That way I can count cycles.
16:58:29 <Vorpal> quintopia, arduino uses the AVR chip
16:58:53 <quintopia> Vorpal: atsmega chips are also used in arduino clones. i refer to the entire family of products by the shorthand "arduino"
16:59:08 <Vorpal> quintopia, atmega*
16:59:16 <quintopia> wutev
16:59:25 <fizzie> quintopia: That's like calling all kinds of searching "googling". How dares you.
16:59:43 <quintopia> ...people use search engines other than google?
16:59:47 <Vorpal> quintopia, dude, I use ATmega chips in a course at university currently :P I know them well atm :P
17:00:02 <fizzie> There's that bingbong thing, some people I think do use it.
17:00:21 <Vorpal> quintopia, yes... I use grep, find and locate as local search engines
17:00:22 <quintopia> but even it uses google, so technically speaking, they're still googling
17:00:44 <quintopia> Vorpal: i thought that's what google desktop search was for? >_>
17:00:48 <Vorpal> quintopia, "windows live search". As much as I hate it, people use them.
17:00:51 <Vorpal> quintopia, "google desktop"?
17:00:58 <Vorpal> s/them/it/
17:01:54 <Sgeo> Someone was surprised when I used Bing. I only used Bing because I was too lazy to switch the search bar to Google
17:01:55 -!- asiekierka has quit (Ping timeout: 276 seconds).
17:01:58 <quintopia> i've never heard of windows live search. lemme google it real quick.
17:02:02 <fizzie> Vorpal: That would be better completely flipped; "as much as I hate them, people use it."
17:02:13 <Vorpal> fizzie, XFD
17:02:15 <Vorpal> XD*
17:02:35 <quintopia> Gregor: have you made "death" not suck yet?
17:03:05 <Vorpal> quintopia, "death"? Is that one of his projects?
17:03:35 <fizzie> I thought that was, in a sense of speaking, everyone's project...
17:03:43 <quintopia> it's a song snippet from the game he's composing for
17:03:52 <quintopia> but it doesn't sound very deathy last i heard
17:03:57 <Vorpal> quintopia, got a link?
17:04:01 <quintopia> it sounds more like a dream sequence
17:04:04 -!- Tritonio has joined.
17:04:09 <Vorpal> quintopia, I love his music
17:04:14 <quintopia> http://codu.org/tmp/death-2011-02-12-2.ogg
17:04:29 -!- elliott has joined.
17:04:37 <quintopia> elliott! did you finish lance?
17:04:49 <elliott> fuck you i just got up
17:04:51 * Sgeo lances quintopia
17:04:53 <quintopia> how dare you show your face in here before having finished lance?
17:05:07 <quintopia> :P
17:05:13 <Vorpal> quintopia, perfect bad dream yeah!
17:05:36 <ais523_> <Sgeo> Someone was surprised when I used Bing. I only used Bing because I was too lazy to switch the search bar to Google <--- pretty much the explanation for all use of Bing
17:05:40 <Vorpal> elliott, your sleep schedule. It's fucked
17:05:53 <elliott> no shit
17:06:00 <Vorpal> elliott, yes shit!
17:06:04 <elliott> ais523_: haha, i've done that too
17:06:07 <ais523_> that, and the Windows malware that sets your default search engine to Bing and adds affilate identifiers, so they get referral revenue from it
17:06:59 <elliott> someone make a site that's a reskin of bing and google, and then /etc/hosts a relative's google.com there
17:07:01 <Vorpal> ais523_, ... that exists?
17:07:04 <elliott> *reskin of bing to look like google
17:07:06 <elliott> see if they notice
17:07:26 <ais523_> Vorpal: yep
17:07:26 <elliott> 10:41:16 <oerjan> <elliott> Gregor: Would you hold it against me if I used an actual parser generator for lance rather than hacking up this awful thing? X-D <-- ah. that may be a problem since the language isn't CF. (see previous comment)
17:07:28 <elliott> :D
17:07:35 <elliott> i love how new bf joust isn't context free
17:07:35 <ais523_> elliott: they don't notice anyway, most likely
17:07:47 <elliott> ais523_: a slightly more savvy relative then
17:07:52 <ais523_> there was that case where a news story about Facebook managed to beat Facebook in a Google search
17:08:01 <ais523_> and lots of people tried to log into Facebook via its comments form
17:08:08 <elliott> 10:55:24 <oerjan> conclusion: he composes electronic music for porn films
17:08:09 <elliott> ais523, you have not confirmed nor denied this.
17:08:14 <ais523_> no, I haven't
17:08:19 <elliott> that's _suspicious_.
17:08:21 <ais523_> but it seems pretty believable
17:08:28 <ais523_> oh, wrong conversation
17:08:28 <elliott> aha! admission!
17:08:33 <elliott> ...haha
17:08:36 <Vorpal> haha
17:08:37 <fizzie> elliott: I stole your name for a small alternative egojoust-reimplementation... I don't know what the right word is, "trick" or "experiment" or something.
17:08:46 <elliott> fizzie: What, "lance"?
17:08:50 <ais523_> I need to know more context before I can sensibly confirm or deny it, anyway
17:08:51 <Vorpal> <elliott> 10:55:24 <oerjan> conclusion: he composes electronic music for porn films <-- how did he reach that conclusion?
17:08:52 <elliott> fizzie: You do realise lance is 3/4ths done already?
17:08:52 <fizzie> elliott: I called it "chainlance".
17:09:00 <fizzie> But it's still name-stealing.
17:09:01 <elliott> fizzie: Heh, what does it do.
17:09:10 <elliott> I'll just absorb its features into lance and then sue you.
17:09:14 <elliott> You horrible person.
17:09:23 <fizzie> Translates to x86-64 asm, basically. But it's not much of a win because of the strict cycle-alternation stuff.
17:09:26 <elliott> 12:57:47 <oerjan> jix_wiggle2 would have been a good candidate for (({{}})) if it was slightly more ordered instead of trying that hard to be unpredictable
17:09:27 <elliott> :D
17:09:45 <Vorpal> fizzie, with the right register allocation it could help
17:09:48 <elliott> fizzie: I can already simulate the longest possible battle in 1/10th of a second :P
17:10:02 <ais523_> elliott: even with insane programs?
17:10:09 <elliott> So on a 100-big hill filled of programs that do + forever, it would take 10 seconds to try a new warrior.
17:10:14 <Vorpal> elliott, given fully expanded source code?
17:10:21 <elliott> Vorpal: Probably.
17:10:36 <fizzie> 100-big hill involves 100*99 = 9900 duels.
17:10:39 <elliott> Note that it also detects when both programs stop executing and ties immediately.
17:10:51 <ais523_> fizzie: but only 100 duels to test a new warrior
17:10:55 <elliott> What ais523_ said.
17:10:57 <quintopia> cuz of cache
17:10:58 <elliott> You don't redo the hill every time.
17:11:19 <elliott> (Most normal matches end in less than 0.06 seconds so far :P)
17:11:27 <elliott> But I haven't finished implementing {} yet.
17:11:31 <elliott> So I haven't extensively tested yet.
17:11:36 <fizzie> elliott: Well, I get a 100000-cycle match done in 3/100ths of a second. :p
17:11:55 <elliott> fizzie: Well lance is better because I said so. :|
17:11:56 <ais523_> 100000, or 384000?
17:12:08 <fizzie> ais523_: 100k, it's trying to be egojoust-compatible.
17:12:12 <ais523_> ah, OK
17:12:15 <elliott> Is it compatible in its broken %?
17:12:22 <quintopia> ais523_: what is the "booster" in decoybooster meant to refer to?
17:12:32 <elliott> 15:27:19 <Gregor> oerjan: Why are you not here now :P
17:12:32 <elliott> 15:27:35 <Gregor> high_fructose_corn_philip's canonical implementation uses (({{}}))
17:12:32 <elliott> 15:28:06 <Gregor> Works on egojsout, but not egojoust
17:12:32 <elliott> Gregor: Was it actually... useful?
17:12:34 <ais523_> quintopia: using decoys in order to allow bigger decoys
17:12:50 <quintopia> ah
17:12:53 <elliott> 15:46:49 <Vorpal> <ais523_> besides, I care more about playing than winning <--- what, someone actually believes that playing is more important than winning
17:12:54 <elliott> hey, I play egojoust and never win
17:12:58 <elliott> *bfjoust
17:13:04 <quintopia> i would have said "staller" :P
17:13:06 <Vorpal> elliott, yes but you aim to win still
17:13:10 <Vorpal> that is your goal
17:13:13 <fizzie> elliott: Well... It doesn't do the non-matching-[s-in-() at all and replaces (foo{bar}baz)%n with a (foo)*n bar (baz)*n as a preprocessing step. I'm not seriously advocating it as a replacement, after all.
17:13:16 <elliott> Aim, but don't care about.
17:13:24 <Vorpal> elliott, indeed. Which is different
17:13:26 <elliott> fizzie: Oh, so it has totally broken % :P
17:13:52 -!- Tritonio has quit (Quit: Leaving).
17:13:55 <elliott> And seemingly runs redundant polarities. PFFFFFFFFFFFFFFFFFFFFFFFT
17:13:58 <Sgeo> I play too crappily to ever think I have a chance of winning
17:14:02 <ais523_> Gregor: there's an obviousish fix to HFCP; you check 0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8 before assuming a large decoy and doing the adjustment by 128
17:14:09 <ais523_> why do you check 0..7 twice?
17:14:11 <fizzie> elliott: It doesn't run redundant polarities, it just does the *2 thing. :p
17:14:38 <elliott> So does ([{x}])%n not even work, fizzie "I THINK I CAN COMPETE WITH LANCE, THE BEST PROGRAM EVER, HAHA" fizzie?!?!?!!
17:14:43 <Sgeo> !bfjoust loop_suicide [-]
17:14:57 <ais523_> !bfjoust slow_shudder (+.-.)*100000
17:15:17 <elliott> why does everyone keep submitting the same idiotic programs :P
17:15:17 <quintopia> that's not a shudder. that's a vibrator.
17:15:19 <fizzie> elliott: Well, no, obviously not, since it turns into ([)*n x (])*n -- I just wanted to, you know, try the theory out in practice.
17:15:24 <fizzie> Vorpal: There's a generated-code example at http://p.zem.fi/bd54
17:15:25 <quintopia> (vibrator? hardly know 'er!)
17:15:33 <ais523_> quintopia: what's the difference? I thought vibrators went to 0 every second turn
17:15:53 <elliott> fizzie: I'm sorry, I *believe* that you have *lost* *forever* and are *bad*. Carry on.
17:16:04 * elliott goes back to lance, cries about performance
17:16:11 <quintopia> ais523_: well, call it an alternator then. the point is, it doesn't change its average value on its own)
17:16:26 <ais523_> ah, I see
17:16:32 <ais523_> making that change the average value would just suicide, though
17:16:51 <quintopia> yes
17:16:53 <ais523_> also, why is breakdown not updating? egojoust doesn't seem to have even started running
17:17:06 <elliott> because egojoust sucks
17:17:07 <elliott> any questions
17:17:09 <ais523_> !c printf("test\n");
17:17:18 <quintopia> it does that every now and then
17:17:27 <Vorpal> lagged to hell I bet
17:17:39 <elliott> lance debugger: TOTES GONNA BE CALLED "GUINEVERE"
17:17:41 <EgoBot> test
17:17:57 <fizzie> I wanted to consider llvm asm, but the "alternate between programs" would have meant some pretty awkward-looking code. (At least based on what little I remember of llvm ops.)
17:18:01 <elliott> ;; run through all tape sizes with progA vs progB
17:18:01 <elliott> xor rTapeSized, rTapeSized
17:18:07 <elliott> fizzie: Don't you know that mov 0 is _faster_ these days?
17:18:10 <elliott> Clearly this man knows nothing of performance
17:18:40 <ais523_> `run ps aux | grep ego | grep -v grep
17:18:59 <fizzie> Can you provide references for that? I can believe xor a, a is no longer a win, but it sounds a bit strange that it'd actually be slower.
17:19:16 <ais523_> elliott: I thought mov was faster into memory, and xor-with-self was faster in registers (due to taking the same number of cycles and being a shorter opcode)
17:19:29 <ais523_> (and thus fitting into cache more easily)
17:19:30 <elliott> fizzie: It was Wikipedia commenting on Abrash or something, saying that "mov 0" had been OPTOMIZED(tm) because, you know, it's common.
17:19:36 <elliott> The xor version is of course shorter.
17:19:39 <HackEgo> 5000 1458 0.2 0.0 3640 388 ? SN 17:39 0:00 ../../../slox/slox 25 ../report ../egojoust ../cache Deewiant_maglev.bfjoust Deewiant_monorail.bfjoust Deewiant_sloth.bfjoust Deewiant_steamroller.bfjoust Gregor_high_fructose_corn_philip.bfjoust Gregor_julius_freezer.bfjoust Gregor_lead_acetate_philip.bfjoust
17:19:56 <elliott> fizzie: "For example, the bit-oriented "XOR EAX, EAX" (example in Intel assembler syntax) instruction was the fastest way to set a register to zero in the early generations of the x86, but most code is generated by compilers and compilers rarely generated XOR instructions, so the IA designers decided to move the frequently occurring compiler generated instructions up to the front of the combinational decode logic, making the literal "MOV EAX, 0"
17:19:56 <elliott> instruction execute faster than the XOR instruction."
17:19:58 <ais523_> that's a strange thing for it to be held up on
17:20:03 <quintopia> no
17:20:11 <quintopia> that's egojoust it's held up on
17:20:13 <elliott> ais523_: report runs all the matches
17:20:32 <ais523_> yep, but it's the list of programs there that's weird
17:20:33 <EgoBot> Score for ais523__slow_shudder: 16.1
17:20:33 <EgoBot> Score for Sgeo_loop_suicide: 20.0
17:20:35 <ais523_> ah, it's running now
17:20:54 <quintopia> ais523_: report takes a list of programs as arguments
17:20:59 <Sgeo> Well, that's interesting
17:21:03 <quintopia> all the programs in the programs folder
17:21:23 <elliott> 16:24:14 <Gregor> ais523_: 100K
17:21:26 <elliott> Gregor: nope, 10K
17:21:32 <elliott> (cut off repeats)
17:21:33 <Sgeo> Who did I win against?
17:21:38 <quintopia> Sgeo: if you kill yourself slow enough, some programs kill themselves first :P
17:21:56 <elliott> 16:27:54 <fizzie> !bfjoust lostkng http://p.zem.fi/lostkng
17:21:56 <elliott> 16:27:59 <fizzie> (The most sensible thing.)
17:22:01 <elliott> fizzie: is this what you wrote chainlance for? :D
17:22:12 <elliott> 16:29:04 <ais523_> wow, lostkng's beating more or less everything on tape lengths 11 and 14
17:22:14 <elliott> hahaha, wow
17:22:14 <fizzie> No, it runs reasonably fast with stock egojoust too. :p
17:22:32 <elliott> The only thing that needs speeding up are * and {} really.
17:22:35 <ais523_> slow_shudder actually does pretty well
17:22:38 <elliott> Lostkng runs fast because it has none.
17:22:43 <elliott> Gregor: ping
17:22:45 <Sgeo> quintopia, ais523's program should have been like a noop, why'd it score worse?
17:23:01 <ais523_> Sgeo: mine's not like a no-op at all
17:23:02 <quintopia> check the report!
17:23:17 <ais523_> it draws with two-cycle clears, but only on every other tape length
17:23:22 <elliott> how on earth would ais523_'s be a nop?
17:23:22 <ais523_> no-ops don't do that
17:25:48 <elliott> Maybe I'll replace my strange program format with structs.
17:25:59 <elliott> Rather than storing instruction parameters as the instruction after the instruction.
17:26:23 <elliott> 17:01:21 <ais523_> because the > happens during the turn, whereas flag loss is measured at the end of the turn
17:26:23 <elliott> ooh
17:26:29 <elliott> ais523_: I check for flag loss at the start of a turn
17:26:33 <elliott> although i suppose that's equivalent
17:26:37 <ais523_> yep
17:26:50 <ais523_> "between turns", you could say
17:26:56 <elliott> I also handle draws when both of your flags go to 0 at the same time, when both your programs end and neither of your flags are 0, and when both pointers run off the tape.
17:27:02 <elliott> I'm just THAT FAIR.
17:27:37 <elliott> 17:04:36 <ais523_> also, what's with the topic?
17:27:38 <elliott> you mean
17:27:40 <elliott> 00:53:08 • elliott changed the topic to: Sorry about that outburst, but it is for your own good, as #esoteric is not a very noob-friendly channel, and you can expect to receive abuse at the drop of a hat. | | http://tunes.org/~nef/logs/esoteric/?C=M;O=D
17:27:41 <elliott> ?
17:28:16 <elliott> ais523_: it's a quote from this post about bf joust by quintopia telling people to /msg egobot rather than come into #esoteric because we're evil and kick puppies :D
17:28:17 <elliott> http://forums.xkcd.com/viewtopic.php?f=11&t=68422
17:28:56 <elliott> fizzie: how is http://p.zem.fi/erep different to the standard report?
17:29:02 <ais523_> oh, quintopia trying to advertise BF Joust on xkcd?
17:29:13 <elliott> ais523_: ages ago
17:29:28 <elliott> oh
17:29:29 <elliott> feb 9
17:29:31 <elliott> not ages then
17:29:38 <quintopia> no, recently.
17:29:51 <quintopia> my goal is actually to have a separate competition not involving the current hill
17:29:54 <elliott> thankfully nobody replied, it'd get really annoying checking the report every few hours and noting that ten new programs you don't know about appeared and are beating all of yours :D
17:29:57 <quintopia> but i don't think anyone will reply
17:30:03 <ais523_> I suspect it works better on Reddit, and if you just say "hey, there's this ongoing game, join in if you want" rather than "let's have a separate competition"
17:30:13 <ais523_> more or less like "join Agora/Blognomic" tends to work better than "let's start a nomic"
17:30:18 <elliott> quintopia: I think when you told people to download hg and compile shit they sort of stopped reading.
17:30:28 <elliott> quintopia: Or, you know, suggested programming in brainfuck.
17:31:10 <quintopia> elliott: nah, it's just that the coding forum is no longer as fun as it used to be. two years ago I ran a similar competition for people to write their own versions of bf_txtgen
17:31:17 <quintopia> and tons of people entered
17:31:25 <elliott> as xkcd gets stupider, the people who read xkcd get stupider.
17:31:27 <quintopia> even though they had to download and install the checker
17:31:48 <quintopia> possibly
17:35:35 <elliott> ais523_: you'll be pleased to know that i've managed to break lance's ()* checking while implementing {} parsing
17:35:48 <ais523_> why would I be pleased to know that?
17:35:53 <Sgeo> I'll be pleased to see your commit messages
17:35:56 <elliott> ais523_: it's innovation!
17:36:01 <elliott> Sgeo: it's not in VC.
17:36:07 <ais523_> hmm, technically speaking, I don't have to be pleased at that now, just later, to make your statement true
17:36:29 <quintopia> take your time
17:36:35 <Sgeo> to trust in me
17:37:33 <Vorpal> ais523_, hah
17:37:54 <ais523_> Vorpal: it isn't that funny...
17:40:41 -!- impomatic has joined.
17:40:46 <impomatic> Hi :-)
17:41:10 <quintopia> sup
17:42:27 -!- nescience has joined.
17:43:10 <elliott> 32 megabytes in global variables!
17:44:02 <quintopia> elliott: i found a picture of you and your dad! http://www.bestworstadvice.com/photo-advice/feel-like-youre-losing-touch-with-your-son/
17:44:15 <elliott> I SEE
17:44:24 <ais523_> I take it this is trolling?
17:44:25 <ais523_> hi impomatic
17:45:59 <elliott> switch ((progs[prog]++)->ins) {
17:46:04 <elliott> wow that switch statement is perverse
17:47:00 <nescience> man I need a computer but I won't be able to try anythin until tonight :(
17:47:42 <nescience> how's lance coming, elliott?
17:48:22 <fizzie> elliott: The table of +s, -s and 0s is sorted according to score too.
17:48:40 <ais523_> hmm, what happened to Lymia?
17:50:17 <quintopia> that personage, after completely unravelling and breaking the game of fyb, disappeared.
17:51:15 <elliott> nescience: good
17:51:28 <nescience> excellent ;)
17:51:50 <nescience> I thought of a legitimate use for ([)*n type code though
17:52:04 <nescience> can't figure an analogue with ({})
17:52:07 <Sgeo> breaking?
17:52:22 <nescience> actually it's a thing I tried earlier but didn't flesh out
17:52:58 <quintopia> is something like [[[[[[[a]b]a]b]a]b]a]
17:53:04 <nescience> but you didn't say it'd be illegal, just undesirable so I am ok with that :P
17:53:06 <nescience> nah
17:53:10 <nescience> it's more like
17:53:31 <nescience> >[-++<
17:53:46 <nescience> >[-++<<
17:53:47 <nescience> etc.
17:54:38 <nescience> can't do (>[-++{}<]) because it adds extra tests that might make it suicide
17:55:20 <ais523_> quintopia: ([[{a}]b]a)%3
17:55:34 <elliott> nescience: i think you could do that with {}. maybe.
17:55:51 <nescience> see above
17:55:58 <elliott> ais523_: btw Gregor's "preferred" version of a current contestant involves nested %, so I'm going to see how he does it and then decide to maybe reinstate %
17:56:01 <nescience> try and write it :P
17:56:09 <elliott> nescience: welp, manually expand it
17:56:22 <elliott> nescience: it's not like you're going to have 5000 of them :)
17:56:59 <ais523_> elliott: you should definitely treat % and * with their specced meaning, whether you treat them as equivalent to acccomplish that or not
17:57:05 <ais523_> *accomplish
17:57:06 <nescience> ugly and hard to count ]
17:57:08 <nescience> anyway
17:57:14 <elliott> nescience: use a proper editor that matches ]s...
17:57:18 <elliott> ais523_: we agreed to eliminate %, actually.
17:57:23 <quintopia> ais523_: [a[b[c[a[b[c[a[b[c]b]a]b]a]b]a]b]a] this can be done with % but would be a whole lot compacter with ([)*
17:57:28 <nescience> rolleyes
17:57:32 <ais523_> elliott: well, you're using ({}), aren't you?
17:57:38 <elliott> nescience: not rolleyes, _any_ editor can match ]
17:57:40 <elliott> apart from notepad
17:57:45 <elliott> ais523_: but if Gregor's use turns out to be... useful, % will be reinstated
17:58:07 <nescience> point is just that it's not really necessary to disallow the syntax
17:58:14 <ais523_> what I mean is, I want to be able to write something like (a[{b}]c)%1000 efficiently
17:58:21 <elliott> nescience: yes, it is
17:58:26 <nescience> and it would be useful in some cases to allow it
17:58:27 <elliott> expanding it is costly
17:58:32 <ais523_> and ideally that syntax should work, even if you treat it as (a[{b}]c)*1000 internally
17:58:37 <ais523_> in neither case would you need an expansion
17:58:38 <nescience> don't expand it
17:58:43 <elliott> you can't avoid expanding it
17:58:48 <elliott> that's why % was invented
17:58:48 <nescience> sure you can
17:58:52 <elliott> no
17:59:05 <nescience> if you have 8 [s in a row and it can be parsed
17:59:06 <elliott> ais523_: no, we agreed to remove the % syntax as redundant
17:59:10 <ais523_> in order to do the abcabc....baba thing above, you have to expand it at least to ([a[b[c[a[b[c{a}b]a]b]a]b]a])%2, or whatever
17:59:18 <nescience> so too with 8 [s on one cell
17:59:20 <ais523_> elliott: redundant's no reason it shouldn't be allowed to preserve backwards compat
17:59:30 <elliott> ais523_: I'm not arguing over it, we already agreed :P
17:59:31 <nescience> you always have to know which one you are on anyway
17:59:34 <ais523_> if nothing else, % serves as a visual clue to look at the {}
17:59:35 <ais523_> and no we didn't
17:59:36 <elliott> But it depends if Gregor's found a good usecase.
17:59:42 <ais523_> I agreed it was OK for you to keep the two internally
17:59:45 <elliott> ais523_: All the rest of us did and I /did/ ask you and you said yes.
17:59:50 <elliott> anyway, you don't own the BF Joust spec...
18:00:09 <ais523_> and I don't see how gregor's usecase makes any difference as to whether it should be notated with % or with *
18:00:13 <nescience> apparently you do though? :P
18:00:27 <ais523_> I'm fine with you allowing ({})* as an alternative syntax to ({})%, too, even though it's confusing
18:00:35 <elliott> ais523_: because it's ambiguous with just *... except that the case that requires explicitly marking %s seemed totally useless
18:00:47 <ais523_> in what way is it ambiguous with just */
18:00:53 <ais523_> s/\/$/?/
18:00:53 <elliott> nescience: but no, ([)*n is definitely not efficiently doable
18:00:59 <elliott> ais523_: ((a{b}c)*m)%n
18:01:12 <nescience> by efficient you mean without expansion?
18:01:15 <elliott> ais523_: other kinds of nesting
18:01:17 <elliott> nescience: yes
18:01:21 <elliott> ais523_: if you s/%/*/, then this will be parsed as the old ((a{b}c)%m)*n
18:01:23 <ais523_> elliott: oerjan and I agreed that was meaningless, I think
18:01:28 <nescience> that's untrue
18:01:31 <elliott> ais523_: not meaningless, just useless
18:01:42 <elliott> ais523_: but Gregor's using it in an actual program on the hill (but not in that version, since egojoust doesn't support it)
18:01:45 <elliott> (but he's using it in egojsout)
18:01:46 <ais523_> what does (a{b}c{d}e)%2 expand to?
18:01:56 <elliott> aabccdee
18:01:57 <elliott> obviously
18:01:58 <nescience> when you encounter "stacked" [] you already have to keep track of your depth, yes?
18:02:04 <elliott> nescience: no
18:02:15 <nescience> are you seeking matches or pre-processing and storing pointers?
18:02:20 <elliott> latter obviously
18:02:34 <nescience> hey I'm just being clear
18:02:36 <elliott> :P
18:02:51 <nescience> why don't you need to track depth? you don't loop forever
18:03:01 <elliott> i have no idea what you mean
18:03:15 <elliott> case LOOP:
18:03:15 <elliott> if (!saves[prog]) {
18:03:15 <elliott> progs[prog] = progs[prog].jmp;
18:03:15 <elliott> goto nonext;
18:03:15 <elliott> }
18:03:16 <elliott> break;
18:03:18 <elliott> case POOL:
18:03:20 <nescience> if I'm missing something please set me straight before I proceed :P
18:03:20 <elliott> if (saves[prog]) {
18:03:20 <ais523_> I don't consider that obvious at all, as it unmatches brackets: ([{x}][{y}])%2 would become [[x][][y]] which matches the wrong [ with the wrong ]
18:03:24 <elliott> progs[prog] = progs[prog].jmp;
18:03:26 <elliott> goto nonext;
18:03:28 <elliott> }
18:03:30 <elliott> break;
18:03:32 <elliott> does that answer your question?
18:03:34 <elliott> LOOP is [, POOL is ]
18:03:39 <elliott> ais523_: well, (a{b}c{d}e)%2 wasn't allowed
18:03:42 <nescience> real hard to read on phone
18:03:42 <elliott> just the form i showed
18:03:52 <elliott> (arguably, that's perverse)
18:03:53 <elliott> anyway
18:04:03 <elliott> I'm going to have to see how Gregor uses it before I can make any kind of opinion
18:04:22 <nescience> just verifying that you have to store some information about how many ] deep you are
18:04:25 <ais523_> elliott: well, (([{x}])*2)%2 would come to the same thing
18:04:27 <nescience> er [
18:04:28 <elliott> nescience: I don't
18:04:38 <nescience> so you know how many ] to test
18:04:44 <elliott> what?
18:04:52 <nescience> ok example code time
18:05:52 <nescience> I see, you only store counters on the (), yes?
18:06:03 <nescience> well that doesn't conflict with what I am getting to
18:06:21 <elliott> you realise that (a{b}c)%n was _invented_ because ([)*n is a huge pain to do without expansion?
18:07:02 <elliott> lance.c:138: error: label at end of compound statement
18:07:03 <elliott> stupid C
18:07:46 <quintopia> so, does anyone here like long-distance remote control robots?
18:07:47 <nescience> each [ pairs with a specific ]; all you need is to tie them together. so you track depth when pre parsing and have a list of pointers or something like that. you can store the depth in the same way you store loop counts, and it will indicate which item in the list to go to
18:07:55 <Gregor> <elliott> ais523_: btw Gregor's "preferred" version of a current contestant involves nested %, so I'm going to see how he does it and then decide to maybe reinstate % // no. The case for nesting back and forth hasn't been made.
18:08:03 <quintopia> http://www.youtube.com/watch?v=mz4FshiMu3U <-- robot ordering scones in a coffee shop, also awesome
18:08:12 <elliott> Gregor: So yours is just ((a{b}c)*n{d}e)*n?
18:08:13 <elliott> Or?
18:08:23 <Gregor> Lemme just pastebin :P
18:08:26 <ais523_> elliott: http://codu.org/eso/bfjoust/in_egobot/Gregor_high_fructose_corn_philip.bfjoust
18:08:38 <ais523_> it would make sense if you could somehow RLE the repeated rows of that
18:08:42 -!- copumpkin has quit (Ping timeout: 276 seconds).
18:08:45 <elliott> ais523_: umm, that's not the version he prefers
18:08:46 <Gregor> http://pastebin.com/vTLvx2mM
18:08:50 <elliott> because the version he prefers doesn't work with egojoust
18:08:59 <ais523_> elliott: indeed, I'm mentioning that that is clearly contractable
18:09:01 <elliott> Gregor: BTW, please tell nescience that I'm really not going to devote effort to making (A[B)*nC(D]E)*n work beyond a simple preprocessor until programs that do that get replaced :-P
18:09:09 <elliott> I still doubt it can be done efficiently
18:09:18 <Gregor> nescience: Yeah, that's bad.
18:09:29 <Gregor> And can always be replaced by (...{...}...)
18:09:31 -!- copumpkin has joined.
18:09:41 <nescience> see above example?
18:09:47 <Gregor> #4 DAMN IT
18:10:01 <elliott> Gregor: Oh yeah, nescience wants to do it with *n *m
18:10:02 <nescience> unless you can nest those constructs which is confusing as hell
18:10:06 <elliott> where n=/=m
18:10:08 <elliott> making it like 10x as evil
18:10:16 <elliott> My preprocessor won't even do that X-D
18:10:27 <ais523_> Gregor: umm, the outside % is meant to match the inside {} there?
18:10:43 <Gregor> ais523_: Yes
18:10:43 <nescience> I'm just saying it won't take more memory to process it with () than it would fully expanded
18:10:52 <Gregor> When you find a {, you match it against the nearest not-yet-matched (
18:10:58 <ais523_> ah, OK
18:10:59 <nescience> AND that it's not difficult to interpret without expansion
18:11:31 <elliott> Gregor: So those {}s all match the closest (), right?
18:11:32 <Gregor> I can't find the example and am not willing to look, having unmatched [] in () = pain, Idonwanna.
18:11:35 <nescience> particularly when you make a pass before execution to store pointers
18:11:38 <elliott> Or does the nested one actually match the _previous_ one?
18:11:41 <Gregor> elliott: The closest not-yet-matched (
18:11:53 <Gregor> elliott: The innermost { matches the second-outermost (
18:12:02 <elliott> Gregor: The way I interpret it, (a{b{c}d}e) would all belong to the same.
18:12:07 <elliott> Gregor: Your interpretation is a bit ... perverse.
18:12:10 <elliott> But I can do that.
18:12:12 <elliott> Probably.
18:12:29 <nescience> your love of the word perverse is perverse ;)
18:12:33 <Gregor> elliott: You could have multiple nested {}s in one ()? That makes no sense.
18:12:47 <Gregor> And mine makes philip possible :P
18:12:50 <elliott> Gregor: That's true :P
18:13:22 <elliott> Gregor: (a[{b[({[(a[b]c)%2]})*3]c}d]e)%42
18:13:23 <elliott> Gregor: FEAR
18:13:33 <elliott> Note: Makes no sense :P
18:13:43 <nescience> my eyes
18:14:49 <elliott> Gregor: So, basically, we still don't need % any more.
18:14:58 <Gregor> elliott: Right.
18:15:29 <Gregor> You only need them if you allow multiple {} within one (), and specifically allow that to be introduced by ()*
18:15:35 <Gregor> *within one ()%
18:16:30 <elliott> Gregor: Which sounds quite perverse. :p
18:16:36 <elliott> perverse perverse perverse perverse perverse perverse perverse perverse perverse perverse perverse perverse perverse
18:16:40 <nescience> lols.
18:17:42 <nescience> I might have to try and hack on egojoust (or lance) to try and make the idea I want to try easier to implement
18:18:18 <elliott> nescience: Just write a generator program :P
18:18:22 <elliott> We don't need a huge macro language.
18:18:35 <nescience> that's not what I meant
18:18:43 <Gregor> Wait for lance.
18:18:45 <Gregor> Don't hack egojoust.
18:18:49 <Gregor> Or hack egojsout
18:18:54 <nescience> and the argument before is for keeping existing behavior, not making anything huge
18:18:57 <nescience> lol
18:19:11 <nescience> I just want to get some information more easily ;)
18:19:22 <nescience> I'll probably end up just doing it by hand though
18:19:26 <Gregor> Y'know, egojsout is a legit, by-the-book non-expanding interpreter. Its code is really pretty nice.
18:19:29 <ais523_> !bfjoust dta2 (+)*32(>)*4(>[+[--[>(>[+[--[(-)*120[-]]]])*21]]])*23(>++[-])*2
18:19:49 <elliott> Gregor: You are not integrating egojsout :P
18:19:53 <elliott> Gregor: Lance is, like, almost done.
18:19:54 <nescience> I'm not handy enough with c that it would be definitely less work
18:19:57 <Gregor> elliott: Good lord no.
18:20:09 <Gregor> elliott: I'm just saying it's not a bad platform to hack at just for experimental purposes.
18:20:12 <elliott> But yeah, egojsout is really helpful.
18:20:14 <elliott> Gregor: Agreed.
18:20:19 <elliott> Gregor: Except for JS and all that, but.
18:20:30 <nescience> I might be able to get what I want from egojsout
18:20:41 <ais523_> I suspect that'll do worse because it loses to most defence programs
18:20:56 <nescience> dunno yet, still haven't played with it from a screen bigger than like 3"
18:21:40 <ais523_> aha, what if I make double_tripwire_avoider trail?
18:22:08 <ais523_> !bfjoust double_tripwire_avoider (+)*20(++>)*4(-->[>(>[+[--[(-)*120[-]]]])*21])*23(>++[-])*2
18:22:18 <nescience> eventually you'll be jumping so many cells :P
18:22:22 <Gregor> Man, once defend13 has you in a jam, you're just friggin' dead.
18:22:29 <elliott> Gregor: Not if you're antidefend13.
18:22:33 <elliott> Is antidefend13 still on the hill?
18:22:34 <Gregor> elliott: :P
18:22:36 <elliott> Because it's genius.
18:22:38 <ais523_> it didn't last very long
18:22:40 <nescience> tripwires will just add more decoys
18:22:47 <elliott> ais523_: But it was awesome!
18:22:53 <elliott> It made defend13 go into stupid mode :P
18:23:05 <ais523_> ah no, it's still there
18:23:10 <elliott> Ha
18:23:21 <elliott> ais523_: It beats all of your defend programs IIRC
18:23:24 <ais523_> `run ps aux | grep ego | grep -v grep
18:23:24 <Gregor> I'm trying to decide if there's any way that something akin to lead_acetate_philip could beat defend13.
18:23:25 <elliott> And just about nothing else
18:23:26 <Gregor> I don't think there is.
18:23:41 <elliott> Gregor: Do what defend13 does, detect defend13 and choose a different strategy :P
18:23:50 <quintopia> Gregor: watch defend9 vs. wireless. it's a *thing of beauty*
18:23:50 -!- cheater00 has quit (Ping timeout: 240 seconds).
18:23:52 <nescience> doesn't beat impomatic's defenders?
18:24:00 <elliott> I like how Gregor went from absolutely terrible player to one of the top after implementing egojsout :P
18:24:06 <Gregor> elliott: The whole reason the philips work is speed, they can't take time to detect.
18:24:08 <elliott> nescience: Oh, it might. But IIRC a few won.
18:24:30 <elliott> Gregor: Detect it really stupidly. Like with one single [ on only one cell at one point in decrementing.
18:24:39 <elliott> I dunno.
18:24:45 -!- cheater00 has joined.
18:24:59 -!- p_q has quit (Quit: Leaving).
18:25:16 <HackEgo> 5000 4035 0.1 0.0 3640 392 ? SN 18:45 0:00 ../../../slox/slox 25 ../report ../egojoust ../cache Deewiant_maglev.bfjoust Deewiant_monorail.bfjoust Deewiant_sloth.bfjoust Deewiant_steamroller.bfjoust Gregor_high_fructose_corn_philip.bfjoust Gregor_julius_freezer.bfjoust Gregor_lead_acetate_philip.bfjoust
18:25:23 <ais523_> quintopia: wow, defend9 gets quite a way through there
18:25:29 <ais523_> despite the misdetection
18:26:04 <quintopia> it's not a misdetection
18:26:06 <quintopia> is it?
18:26:19 <quintopia> it looks like it figured out my cycle length perfectly
18:26:23 <ais523_> no, it's a correct detection
18:26:25 <ais523_> and it wins
18:26:29 <ais523_> I misread the results to start with
18:26:36 <ais523_> is that a three-cycle clear?
18:27:20 <ais523_> yep, indeed
18:28:18 <elliott> BF Joust is a pretty surprising success
18:28:28 <ais523_> why is it surprising?
18:28:34 <elliott> I remember when I was telling ais523_ that I didn't think defend programs were possible :P
18:28:35 <nescience> ah, after examining jsout more
18:28:38 <quintopia> s/surprising/SMASHING/
18:28:46 <nescience> it is one line per cycle after all yes?
18:28:48 <elliott> ais523_: because it seems like it should be quite easy to write a near perfect program on first glance
18:28:53 <elliott> because "oh, you can't ..."
18:28:59 <elliott> but then all sorts of strategies have arisen
18:29:05 <elliott> like: detecting cycle count
18:29:11 <elliott> that doesn't seem possible at first glance at all
18:29:17 <ais523_> defend9's the only program that really does that
18:29:18 <quintopia> it isn't very reliable though
18:29:19 <ais523_> and in quite a naive way
18:29:31 <ais523_> I think I can make a more reliable version, but not easily on this computer because it runs Windows
18:29:46 <quintopia> i think there may be a more reliable way that involves measuring on multiple decoys...
18:29:46 <EgoBot> Score for ais523__double_tripwire_avoider: 47.4
18:29:47 <EgoBot> Score for ais523__dta2: 33.5
18:30:06 <quintopia> what's the difference
18:30:08 * quintopia can't read up
18:30:38 <nescience> I have a strategy in mind that I don't think has showed up yet ;) but it will be a great deal of effort to pull off and possibly not very maintainable
18:30:52 <ais523_> are you going to tell people what it is, or keep it secret?
18:31:06 <nescience> I want to write it first ;)
18:31:15 <nescience> unless you want to write it for me lol
18:31:26 <nescience> it wouldn't be fun to give it away :P
18:32:07 <nescience> anyway it's kind of a different twist on a defender which is what made me want to mention it :P
18:32:26 <nescience> there is a surprising amount of variety in that strategy after all
18:32:28 <ais523_> ooh
18:32:45 <ais523_> the problem with defenders is that counterdefence is so easy to write
18:33:04 <quintopia> nescience: does it involve exploiting the ()* expansion system?
18:33:06 <ais523_> so they'll never dominate the hill, just maybe end up filling a third of it or so
18:33:29 <elliott> ais523_: but what about a defender that detected counterdefenders, and turned into an attacker?
18:33:45 <elliott> that's why defend13 should be called hybrid1, because of possibilities like that :P
18:33:58 <ais523_> it's still defence by my definitions
18:34:02 <quintopia> then someone would write a countercounterdefenderattackerdefender and keep winning
18:34:04 <ais523_> as it waits for the opponent before it does anything
18:34:09 <elliott> ais523_: yes, but it's sort of like a transition
18:34:14 <elliott> from pure defence
18:34:19 <elliott> quintopia: that's not a real argument
18:34:25 <elliott> you could reply to any strategy like that
18:34:25 <nescience> yeah, but if you can make counterdefence untenable against other programs.. then you benefit
18:34:32 <elliott> of /course/ any program gets counter-programs
18:34:35 <elliott> that's the game
18:34:41 <ais523_> elliott: I'm not certain, even, say, defend7 attacks
18:34:49 <ais523_> just it keeps the opponent locked at the same time
18:34:51 <ais523_> it has to win somehow, after all
18:34:52 <quintopia> elliott: the point was that counterdefense is easy to write, and i was extending that argument
18:34:54 <nescience> ah well I suppose I don't care if you write it, though I won't feel any ownership if it succeeds :P
18:35:00 <ais523_> "pure defender" only really applies to shudder-style programs, IMO
18:35:10 <ais523_> nescience: I'm unlikely to be able to write it now
18:35:11 <ais523_> you go for it yourself
18:35:15 <nescience> quintopia, no.. that was just to make a tripwire tripper easie
18:35:22 <elliott> quintopia: counterdefence is easy to write, counterhybrid isn't
18:35:42 <nescience> r
18:35:42 <nescience> anyway this builds on the idea about multiple cell timing I described to you before ais
18:35:43 <elliott> because if you try and counterdefence, it'll turn into an attacker
18:35:52 <nescience> and also trapwire which didn't succeed
18:35:54 <quintopia> elliott: defense13 is a hybrid. it gets pretty solidly trounced by a rusher that waits forever.
18:36:00 <nescience> because I forgot how loops work
18:36:07 <elliott> quintopia: it's not a true hybrid
18:36:11 <elliott> as ais523_ said, it waits for the opponent
18:36:22 <nescience> ya, I will probably try but I feel like a dick talking about it like a secret :P
18:36:23 <elliott> it's like a... protohybrid
18:36:30 <quintopia> you know a way of syncing with an opponent that doesn't involve waiting?
18:36:45 <elliott> nescience: talk about what like a secret?
18:36:50 <nescience> the idea is to zero my flag for one cell when an attacker would encounter it with a loop
18:37:00 <elliott> quintopia: the point is that a hybrid program would start off by setting up defences /and working out what the opponent is doing/
18:37:03 <nescience> causing the attacker to fall through
18:37:09 <elliott> rather than only trying to work that out once the opponent starts coming
18:37:26 <nescience> by varying the decoys I should be able to spread out the timings of programs on the hill
18:37:39 <nescience> so that I can tackle each one separately
18:37:59 <quintopia> i suggested that actually, elliott. building a big decoy while waiting on your reverse tripwires to get hit. i forget what ais523_ said about that...
18:38:05 <nescience> and of course there are only so many looping combinations you can really use
18:38:28 <nescience> then, fixed cycle attackers can be tackled in a similar way
18:38:50 <ais523_> nescience: oh, it needs to be tuned to each individual opponent and tape length
18:38:50 <ais523_> I hate programs like that
18:38:51 <nescience> once you see a zero you can predict specific attack timings
18:38:51 <ais523_> also, it's defeated outright by check-twice programs
18:38:53 <ais523_> that won't leave a cell without verifying that it's 0 for two cycles in a row
18:38:57 <quintopia> elliott: but figuring out what an opponent is going to do while it is still building its own decoys is impossible, so i'm really not sure what you're trying to say
18:39:08 <nescience> the idea is not to prevent leaving
18:39:15 <nescience> it's to prevent entering
18:39:33 <ais523_> elliott: your idea up there is going to be partially used by defend9b or defend15 or whatever I call it
18:39:53 <elliott> quintopia: I didn't say I knew how to do it effectively
18:39:56 <nescience> and you don't really have to tune it to the hill, you will wind up tuning it to "loop once, loop twice, 2 cycle, 3 cycle" all in the same program
18:39:59 <elliott> who says you can't detect that an opponent's building decoys
18:39:59 <ais523_> in that I can detect certain types of enemy by checking to see if my decoys are still intact just before going into wait mode
18:40:01 <elliott> and wait for it to finish?
18:40:04 <elliott> while building your own defences
18:40:12 <nescience> fixed cycle attack programs are less certain of course
18:40:19 <ais523_> elliott: it's very hard to detect decoys reliably without running off the flag
18:40:27 <ais523_> *running off the tape
18:40:36 <nescience> but will have to fall in a certain range of timings as well
18:40:38 <ais523_> if you could detect decoys reliably, why not just skip them and sink the flag?
18:40:56 <nescience> things like wiggle would probably beat it
18:41:08 <nescience> where the attack varies per cell
18:41:39 <elliott> ais523_: very true, but I'm just thinking heuristics
18:41:50 <elliott> ais523_: I'm not going to say something is impossible after saying defence programs were way back :)
18:41:59 <nescience> but generally, you can expect a fixed overhead and then a loop from looping attackers, and varying the decoys precisely can allow you the spread to tweak the flag at the right moment
18:42:11 -!- asiekierka has joined.
18:42:39 <ais523_> nescience: the issue is: if you use a large cell value you can't distinguish the fixed overhead from the loop; if you use a small value, the overhead normally ends up no longer fixed
18:42:55 <ais523_> although, hmm, what if you used two different large decoys?
18:42:58 <nescience> you don't have to know what it is
18:43:01 <ais523_> and measured the number of cycles between them?
18:43:20 <nescience> you just have to cause the fall through for every possibility
18:43:24 <ais523_> that might be more reliable for a defend9-style program than what it currently does
18:43:46 <quintopia> nescience: so you want the opponent to arrive at your flag just as it goes to zero, thereby not ever trying to decrement it?
18:43:50 <nescience> and you use decoy size to force different attackers to take a longer spread of time so you can control the cell timing
18:44:02 <nescience> basically yes
18:44:21 <ais523_> that's trivially defeatable via a second [] after your zero-detection
18:44:24 <nescience> and for fixed attackers you can use a +- to save yourself
18:44:31 <ais523_> not to mention, some programs use an unguarded offset clear
18:45:04 <ais523_> it's relatively easy to write an attack program that's theoretically incapable of running off the end of the tape without an arbitrarily complex shudder of your choice
18:45:06 <nescience> you're right, not much I can do about [[
18:45:23 <quintopia> nescience: and wireless_frownie actually uses [[
18:45:30 <nescience> but then it'd be slower and be defeated by other programs ;)
18:45:45 <quintopia> (actually, it does [[[[ :P)
18:46:03 <quintopia> but yes, it gets defeated by very fast rushers, like maglev
18:46:41 <elliott> hmm, my end of program thing takes up a cycle so it doesn't work at the cycle limit, but i think all such cases would end in draws anyway
18:47:15 <nescience> [[[[ but it has instructions inbetween
18:47:22 <nescience> which can be timed against
18:47:36 <nescience> besides if the first one fails
18:47:40 <nescience> it skips it all
18:47:53 <elliott> [[[[[[[[[[[[[[[[[[[[[[
18:47:54 <nescience> what am I talking about I already considered [
18:47:57 <nescience> lettin you guys confuse me
18:48:15 <nescience> again none of them run if it NEVER ENTERS THE FIRST
18:48:43 <nescience> and that's the whole point of the idea
18:49:06 <elliott> $ ./lance '[+]' '.'
18:49:06 <elliott> 1 : Oi -- your program has an unmatched X; you should feel bad.
18:49:09 <elliott> Oh man, an unmatched X!
18:50:39 <ais523_> defend9 vs. Nyarlathotep is one of the most hilarious matchups ever to watch in a debugger
18:50:59 <ais523_> and incredibly close, because it depends mostly on effectively random factors
18:51:16 <ais523_> nescience: [][]
18:51:17 <nescience> wanna see ;)
18:51:25 <nescience> gotta get off til later though
18:52:42 <nescience> ais: there you go, that's what I was thinking about
18:52:42 <nescience> anyway it still forces opponents into a possibly less effective strategy
18:52:42 <nescience> I gotta save batteries
18:52:42 <nescience> forgot my laptop! :(
18:52:42 -!- nescience has quit (Remote host closed the connection).
18:54:08 <quintopia> ais523_: i don't think he could effectively time against a -[
18:54:19 <quintopia> but yeah, [][] is the smarter route
18:54:55 <elliott> Gregor: lance is ALMOST ENTIRELY LANCED-UP.
18:59:27 <quintopia> we're still waiting
19:02:23 <elliott> quintopia: shaddap
19:04:04 <Gregor> Hey everybody: Just added a cheato statement to egojsout :P
19:04:18 <Gregor> ``(put JavaScript here!)*0
19:04:19 <HackEgo> No output.
19:04:22 <Gregor> lawl
19:04:42 <elliott> Gregor: That might actually be useful as a macro type language...but not JS.
19:05:00 <Gregor> elliott: It's mainly useful as ``(print("I just hit a point I'm interested in"))*0
19:05:31 <elliott> Gregor: `test(n)*((++---)*n) ... `test(3)%
19:05:51 <Gregor> It's not really intended for cheating, it's intended for debugging :P
19:06:23 * quintopia starts putting in statements that break the interpreter
19:06:37 <elliott> Gregor: That wouldn't be cheating.
19:06:45 <elliott> It'd just expand to (++---)*3 :P
19:06:59 <elliott> Admittedly this stuff belongs in a proper program, not the implementation.
19:07:09 <Gregor> quintopia: It doesn't matter if it breaks the interpreter, that hurts only yourself.
19:07:20 <Gregor> quintopia: Doing well in egojsout is irrelevant, doing well on the hill is important.
19:07:29 <quintopia> Gregor: duh
19:07:40 <quintopia> it's like he thinks i'm an idiot or something
19:08:56 <quintopia> i think i'm going to put in some code that submits a file to be processed by webmidi in the inner loop
19:09:07 <Gregor> lawl
19:09:54 <quintopia> your queue will be a year long
19:10:09 -!- asiekierka has quit (Ping timeout: 240 seconds).
19:10:11 <Gregor> I also made it show every PC that's hit by an instruction instead of just the first one.
19:10:38 <quintopia> PC?
19:10:47 <elliott> program castration
19:11:02 <quintopia> i'm not sure what it means to hit a PC by an instruction
19:11:50 <pikhq> MPEG LA is actually trying to set up a VP8 patent pool now.
19:11:58 <Gregor> I made that unclear I guess :P
19:12:07 <Gregor> Every PC that's hit within a cycle.
19:12:11 * pikhq strongly hopes Google goes in and demands a royalty-free licensing scheme.
19:12:19 <elliott> Gregor: Isn't it always just one? Or are we talking abotu repeats.
19:12:20 <elliott> *about
19:12:49 <Gregor> elliott: (){} are all different instructions and so different PCs for me *shrugs*
19:12:50 <pikhq> (note: Google actually has patents on VP8.)
19:12:57 <Gregor> So it'll be a number of (){}s, then a "real" instruction.
19:13:03 <quintopia> Gregor: so if both players decrement the same cell, it shows it on two different lines?
19:13:06 <Gregor> Before it was just the first of any of those that you hit.
19:13:20 <Gregor> quintopia: Just go look at it X_X
19:13:24 <quintopia> kk
19:14:09 <quintopia> Deewiant: maglev is p cool
19:14:11 <Gregor> quintopia: Or have you never clicked on a line in the debugging output and seen that it gives you the programs at that point?
19:14:51 <pikhq> And if this damned patent pool actually gets set up, well, I strongly hope the x264 guys give Vorbis some help.
19:15:16 <quintopia> Gregor: no i hadn't, and i suppose you're referring to the highlight of the )?
19:15:28 <Gregor> quintopia: Yes
19:16:08 <quintopia> Gregor: you should make it decrement the numbers associated with the () so you can easily see which iteration its in
19:16:25 <Gregor> quintopia: That was my original plan, but that data is lost and not easily recoverable by the time I'm generating those.
19:16:37 <pikhq> Oh, *hah*.
19:16:40 <quintopia> oh
19:16:47 <Gregor> pikhq: ?
19:17:02 <elliott> pikhq: give *Vorbis*?
19:17:05 <pikhq> Google's licensing scheme on the VP8 patents forbids you from enforcing your own patents on VP8.
19:17:07 <elliott> Surely you mean Xiph.org.
19:17:16 <elliott> Vorbis is an audio codec.
19:17:21 <pikhq> elliott: Theora, not Vorbis!
19:17:28 <pikhq> elliott: Theora needs the help!
19:17:30 <elliott> Right.
19:17:38 <elliott> I have a feeling Xiph.Org is quite thoroughly dormant.
19:17:42 <Gregor> Damn it SodaStream, where's my CO2!
19:17:48 <pikhq> Actually, no, xiph.org is quite active.
19:17:57 <elliott> pikhq: Well it was dormant for quite a few years.
19:18:09 <pikhq> They're currently working on a Vorbis/Speex replacement.
19:18:10 <elliott> Gregor: Just extract it from the air to undo global warming with soda
19:18:16 <elliott> BEST IDEA?
19:18:20 <elliott> pikhq: More a Speex replacement no?
19:18:28 <pikhq> (it was originally just a Speex replacement, but it also outperforms Vorbis.)
19:18:33 <quintopia> elliott: too bad he'll probably end up burping it back out again :/
19:18:35 <elliott> What on earth is sodastream
19:18:35 <Gregor> elliott: I'll just make a diesel-powered machine to do that!
19:18:39 <elliott> Some soda maker thing?
19:18:45 <elliott> Gregor: POWER IT WITH CO2
19:18:56 <Gregor> elliott: They make at-home soda machines.
19:19:02 <pikhq> Also, Theora has been improving.
19:19:13 <elliott> <Gregor> I decided doing it manually was too cool so now I'm using a MACHINE.
19:19:17 <elliott> You: sux
19:19:24 -!- hagb4rd has quit (Ping timeout: 240 seconds).
19:19:28 <Gregor> Doing it manually was too expensive and ineffectual.
19:19:36 <pikhq> Last I checked they were working on adding psy-opts. Which is what makes x264 so fucking good.
19:19:54 <Gregor> pikhq: Then they'll be working on getting sued 8-D
19:20:00 <elliott> psychic optimisations: THE BEST
19:20:06 <elliott> <Gregor> Doing it manually was too expensive and ineffectual.
19:20:12 <elliott> Your face is too expensive and ineffectual.
19:20:12 <elliott> God.
19:20:15 <elliott> Next it'll be all
19:20:16 <pikhq> Gregor: Actually, psychological optimisations aren't patented, as far as we know.
19:20:18 <elliott> <Gregor> Hey guys
19:20:21 <elliott> <Gregor> I bought a PVC instrument maker
19:20:27 <Gregor> X-D
19:20:27 <elliott> <Gregor> You press a button and out comes a PVC instrument
19:20:30 <elliott> <Gregor> Hey guys
19:20:34 <pikhq> Gregor: I think x264's currently one of *two* encoders currently doing it. At all.
19:20:36 <Gregor> All this machine makes is carbonated water :P
19:20:37 <elliott> <Gregor> I bought a programming language maker
19:20:43 <elliott> <Gregor> Doing it manually was too expensive and ineffectual
19:20:51 <elliott> <Gregor> Hey guys, I bought a music box
19:21:01 <elliott> <Gregor> Here's Opus 14: http://codu.org/musicbox.ogg
19:21:23 <Gregor> elliott: Nah, I'll just adapt the programming language maker to work with AlgoRhythms.
19:21:35 <pikhq> But, it seems that it will be impossible for any entity in a VP8 patent pool to *use* VP8.
19:21:58 <elliott> Gregor's next paper will be automatically generated by a program that thinks of interesting things to say about JavaScript.
19:21:59 <ais523_> pikhq: they're probably just trying to scare other people into not using it
19:22:05 <pikhq> ais523_: Almost certainly.
19:22:15 <elliott> That he wrote by pressing a button on a machine that creates programs that think of interesting things to say about JavaScript and make papers about them.
19:22:19 <pikhq> ais523_: I'm still considering the case where it actually *happens*, though.
19:22:35 <pikhq> ais523_: Even though it *seems* that they won't be able to get any legit patents in there.
19:22:55 <pikhq> IIRC VP8 was carefully designed to not violate any h.264 patents.
19:23:23 <pikhq> And I'd at least hope Google would have confirmed that before buying the company.
19:25:29 <quintopia> elliott: that last one sounds useless, since it really only ever has to generate the one program...
19:26:31 <elliott> quintopia: Gregor made it with a machine that generates a program based on the buttons you press.
19:26:33 <elliott> erm
19:26:38 <elliott> quintopia: Gregor made it with a machine that generates a machine that generates one specific program, based on the buttons you press.
19:26:50 <ais523_> pikhq: I've heard silly things like VP8 using a weird value for a constant because all the more sensible ones had been patented
19:26:56 <ais523_> and was thinking that that didn't make any sense at all
19:26:56 <elliott> $ ./lance '(++++)' '.'
19:26:57 <elliott> Sieve: (.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=
19:26:57 <elliott> Kettle: (.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=(.=
19:27:00 <elliott> Dude... it's +, not . ...
19:27:17 <ais523_> sieve calling the kettle black?
19:28:24 -!- Mannerisky has quit (Ping timeout: 264 seconds).
19:28:31 <elliott> :D
19:28:34 <elliott> hmm
19:28:46 <elliott> *p++ = (struct foo){a, b, c} is valid C99 right?
19:28:48 <elliott> that does what I want?
19:28:52 <elliott> for "struct foo *p"
19:29:13 <ais523_> elliott: I think so; you might have to expand it to *p++ = (struct foo){.first=a, .second=b, .third=c}
19:29:22 <ais523_> which is likely more readable anyway
19:29:27 <pikhq> ais523_: Patent laws in the US are just weird.
19:29:29 <elliott> ais523_: errr, why would you have to expand it?
19:29:30 <ais523_> but I think the short version works too
19:29:47 <pikhq> ais523_: Also, feel free to engage in revelry: none of this patent noise applies to you.
19:30:39 <ais523_> you never know, there have been repeated attempts to enforce software patents in the EU despite them being specifically banned in law
19:31:04 <pikhq> ...
19:31:19 <elliott> !c struct foo{int a,b,c} bar[256]; struct foo *p = bar; *p++ = (struct foo){1,2,3}; printf("%d %d %d\n",(p-1)->a,(p-1)->b,(p-1)->c);
19:31:23 <pikhq> Please do tell me your legal system doesn't have "most money wins".
19:31:30 <elliott> every legal system has "most money wins"
19:31:37 <EgoBot> 1 2 3
19:31:40 <elliott> hmm
19:32:04 <pikhq> elliott: And then you get charged more than you will ever make in your next three lifetimes?
19:32:26 <ais523_> pikhq: less so in the UK than in the US, but it still happens to some extent
19:32:34 <ais523_> the UK legal system is a lot less bullshit-tolerant than the US one is
19:32:57 <pikhq> "Let's kill all the lawyers" — Shakespeare.
19:33:01 <pikhq> Ah, the wisdom of the Bard.
19:33:08 <ais523_> you know about the cases you get in the US where the RIAA or whoever sue a huge number of people in the hope they'll settle, then drop the cases on whoever goes to court?
19:33:16 <ais523_> someone tried that in the UK, the judge wouldn't let them drop the case
19:33:22 <ais523_> and has decided to go through with it regardless
19:33:39 <ais523_> presumably to be able to sanction them for trying something so ridiculous
19:34:45 <ais523_> hmm, note in the README of a kernel keylogger submission: "I advise you not to try to run this code"
19:34:52 <ais523_> together with a screenshot of it crashing the kernel
19:34:57 <ais523_> I am not filled with confidence
19:35:13 <elliott> <pikhq> "Let's kill all the lawyers" — Shakespeare.
19:35:13 <elliott> <pikhq> Ah, the wisdom of the Bard.
19:35:15 <elliott> quote fail
19:35:49 <pikhq> elliott: Shaddup.
19:36:15 <ais523_> how is defend13 so much higher up the leaderboard than defend14, I wonder?
19:36:22 <ais523_> given how similar they are?
19:36:25 <elliott> Oh, looks like it being a statement actually in support of lawyers is a myth in itself
19:36:26 <elliott> WOOP WOOP
19:36:36 <elliott> ais523_: because we all tried to beat defend13
19:36:40 <elliott> and nobody cares about defend14 because it satrted lower
19:36:51 <ais523_> elliott: you have that backwards, possibly
19:36:55 <elliott> ais523_: ?
19:37:05 <ais523_> as in, defend13 is much higher than defend14
19:37:12 <ais523_> and used to be only marginally higher
19:37:23 <elliott> hmm, right
19:37:49 <ais523_> and they still have a similar win/loss record
19:38:01 <ais523_> also, I think antidefend13 just died
19:38:39 <elliott> question!
19:38:45 <elliott> for (int i = 0; i < n; i++) {
19:38:47 <elliott> lbl:
19:38:48 <elliott> ...
19:38:50 <elliott> goto lbl;
19:38:50 <elliott> }
19:38:56 <elliott> does i get incremented after the goto?
19:39:26 <ais523_> no, obviously
19:39:35 <ais523_> you're jumping backwards, not forwards round the forloop
19:39:46 <ais523_> you want "continue;" if you want the for loop header to run too
19:39:47 <elliott> ais523_: well, indeed
19:39:48 <Gregor> http://codu.org/tmp/death-2011-02-12-3.ogg Death ditty, try 3
19:39:52 <elliott> it's just it's behaving like it did get incremented
19:40:07 <quintopia> ais523_: i figured out a way to make wireless beat defend9 and wiggle3 with one change. let's see how it fairs with the rest of the hill...
19:40:18 <quintopia> !bfjoust wireless (>)*8+<-<(+)*18<(-)*19(<(-)*85<(+)*85)*2<(-)*17(>)*9([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*10[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
19:40:21 <elliott> Gregor: Too slow.
19:40:32 <Gregor> elliott: It's for a very mellow game.
19:40:38 <elliott> Gregor: Too tinkly, then :P
19:40:44 <ais523_> quintopia: what was the change?
19:40:49 <Gregor> elliott: lol
19:40:50 <EgoBot> Score for quintopia_wireless: 57.0
19:40:54 <elliott> Gregor: Get rid of the... bubbling tinkly part in the background.
19:40:55 <quintopia> \o/
19:40:55 <myndzi> |
19:40:55 <myndzi> /'\
19:40:56 <elliott> WOW I'M GOOD WITH WORDS
19:41:00 <elliott> 57? wow, congrats
19:41:08 <ais523_> also, that made it marginally worse
19:41:08 <quintopia> ais523_: it alternates cycle length :P
19:41:11 <ais523_> it was on 57.3 before
19:41:16 <quintopia> really
19:41:19 <quintopia> interesting
19:41:48 <quintopia> i think i'll leave it anyway :P
19:42:02 <ais523_> the difference is that it now loses to some of my defend programs on alternate tape lengths on one polarity
19:42:08 <ais523_> so it still beats them, but by not as much
19:42:41 <quintopia> ah
19:43:24 <ais523_> actually, that happens on both polarities vs. impomatic's chainmail
19:43:26 <quintopia> well the idea was to beat *all* defend programs on alternate tape lengths
19:47:42 <Gregor> Man, short sound effect tunes are TOUGH
19:48:23 <ais523_> !bfjoust dta2 (+)*20(++>)*4(-->[>(>[+[--[(-)*120[-][>]]]])*21])*23(>++[-])*2
19:48:35 <ais523_> tweaked to beat wireless, and similar programs
19:48:37 <EgoBot> Score for ais523__dta2: 45.9
19:48:38 <ais523_> let's see how that goes
19:49:05 <ais523_> oh, it doesn't beat wireless
19:49:06 <ais523_> let me see why
19:49:42 <ais523_> oh, duh
19:50:01 <ais523_> !bfjoust dta2 (+)*20(++>)*4(-->[>(>[+[--[(-)*120(.-)*16[>]]]])*21])*23(>++[-])*2
19:50:15 <EgoBot> Score for ais523__dta2: 29.7
19:50:33 <impomatic> !bfjoust charizard >(-)*6(>)*6(>[(>+[[-]])*29])*29[[-]+]
19:50:49 <EgoBot> Score for impomatic_charizard: 17.1
19:51:36 <ais523_> now it beats wireless, but loses to everything else
19:52:08 <ais523_> !bfjoust dta2 (+)*20(++>)*4(-->[>(>[+[--[(-)*120[-]>[>]]]])*21])*23(>++[-])*2
19:52:18 <ais523_> I think that's too slow to beat wireless
19:52:22 <EgoBot> Score for ais523__dta2: 30.3
19:52:42 <ais523_> yep
19:53:25 <ais523_> !bfjoust dta2 (+)*20(++>)*4(-->[>(>[+[--[(-)*120[-]>>>(>(-)*120[-])*10]]])*21])*23(>++[-])*2
19:53:31 <elliott> gah
19:53:34 <elliott> it parses right but doesn't execute right
19:53:36 <EgoBot> Score for ais523__dta2: 43.8
19:54:09 <elliott> ais523_: wrong nick wrong nick :(
19:54:17 <elliott> "!bfjoust dta2 <" and /nick ais523 :P
19:54:30 <ais523_> nope
19:54:52 <ais523_> !bfjoust dta2 (+)*20(++>)*4(-->[>(>[+[--[(-)*120[-]>>>>(>(-)*120[-])*10]]])*21])*23(>++[-])*2
19:55:01 <ais523_> OK, so now I'm just blatantly tuning it to beat wireless :)
19:55:09 <EgoBot> Score for ais523__dta2: 39.6
19:55:13 <ais523_> even though I hate that sort of tactic normally
19:55:20 <ais523_> it hurts it against other things too much, thoguh
19:55:22 <ais523_> *though
19:56:01 <elliott> ais523_: btw, you can kill other people's warriors by nicking to them... I killed one of yours to test... but I put it back :P
19:56:03 <elliott> </confession
19:56:12 <elliott> *</confession>
19:56:18 <ais523_> just as long as it wasn't defend7, I'm fine with that
19:56:39 <ais523_> (defend7 has a pretty ancient last-modified, I'd like to preserve that until it drops off the hill naturally)
19:57:37 <ais523_> !bfjoust dta2 <
19:57:50 <EgoBot> Score for ais523__dta2: 0.0
19:58:54 <elliott> ais523_: I think it was decoytuner
19:58:58 <elliott> some recent one, anyway
20:01:37 <ais523_> !bfjoust decoytuner3 (++>)*8(>[+++([-{[+.++]}>+<])%256])*21
20:01:56 <EgoBot> Score for ais523__decoytuner3: 17.7
20:02:03 <ais523_> !bfjoust decoytuner3 (++>)*8(>[+++([-{[+.++]}>-<])%256])*21
20:02:16 <EgoBot> Score for ais523__decoytuner3: 14.8
20:02:22 <ais523_> hmm
20:02:27 <ais523_> probably just too slow
20:02:35 <ais523_> !bfjoust decoytuner3 (++>)*8(>[+++([-{[+.++]}>+<])%256])*21
20:02:50 <EgoBot> Score for ais523__decoytuner3: 17.6
20:03:56 <quintopia> i'm impressed by the sticking power of patashu's program as well
20:04:29 <ais523_> yep, tactic works, it's just too slow, debugger confirms it
20:05:02 <elliott> !bfjoust
20:05:03 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
20:06:05 <elliott> ais523_: do you think that repeats longer than the max cycle count are useful?
20:06:11 <elliott> I'm trying to think if you could ever have one that works
20:06:19 <elliott> maybe with %
20:06:19 <ais523_> elliott: only in order to mean "forever"
20:06:28 <elliott> ais523_: that works with max cycle
20:06:59 <quintopia> no elliott
20:07:06 <quintopia> cap repeats at max cycle all you want
20:07:13 <elliott> yeah :P
20:07:21 <elliott> i just don't want to change these "metarules" too much
20:07:25 <elliott> trying to get it right the first time
20:07:33 <elliott> note that mine still lets you do ((foo)*-1)*-1
20:07:35 <elliott> so there's no real limti
20:07:36 <elliott> *limit
20:08:35 <ais523_> repeat > max cycle is indistinguishable from repeat = max cycle
20:08:45 <ais523_> if you aren't repeating the null string, you run out of repeats
20:08:48 <ais523_> if you are, the whole thing collapses
20:08:56 <elliott> right
20:09:27 <elliott> $ time ./lance '(()*9999999999999999)*999999999999999999999999' '((-)*9999999999999999999999999999)*99999999999999999999999'
20:09:27 <elliott> [hang]
20:09:28 <elliott> ouch
20:09:35 <elliott> that's strange, it must hang during parsing
20:18:31 <fizzie> elliott: It could be worse; I get match.asm:176: warning: dword data exceeds bounds
20:18:48 <elliott> fizzie: haha
20:19:27 <elliott> ah, no, doesn't hang on parsing
20:19:27 <elliott> hmm
20:19:32 <fizzie> I think my thing actually hangs in the fact that ()*9999999999 consumes no ticks, so the cycle-counter doesn't halt it.
20:20:26 <elliott> 999999 is greater than 100000 right?
20:20:57 <fizzie> Yes, but the ()-looping doesn't cost any cycles.
20:21:34 <elliott> no no no i'm just checking
20:21:38 <elliott> because my code shouldn't be bugged like this
20:21:41 <Vorpal> <elliott> 999999 is greater than 100000 right? <- no.... Aren't you up to scratch on the current mathematics?
20:21:52 <elliott> right, i blame oerjan then
20:22:07 <elliott> if (c >= '0' && c <= '9') {
20:22:07 <elliott> into->arg = (into->arg * 10) + (c - '0');
20:22:07 <elliott> if (into->arg >= MAXCYCLES) break;
20:22:08 <elliott> SPOT
20:22:09 <elliott> THE
20:22:12 <elliott> BUG(GERY)
20:22:47 <Vorpal> elliott, there is no } matching the {
20:22:48 <Vorpal> that is a bug
20:22:51 <Vorpal> ;P
20:22:57 <elliott> wrong, the answer is that I need
20:22:59 <elliott> into->arg = MAXCYCLES;
20:23:00 <elliott> otherwise
20:23:05 <elliott> you can go one digit over
20:23:10 <Vorpal> elliott, == then
20:23:13 <Vorpal> that looks like C
20:23:17 <elliott> ...no
20:23:23 <elliott> that wouldn't fix it
20:23:25 <elliott> that would break it more
20:23:41 <Vorpal> elliott, oh you mean outside the conditions
20:23:45 <impomatic> !bfjoust firefly http://corewar.co.uk/2.txt
20:23:48 <elliott> it should be
20:23:56 <elliott> if (into->arg >= MAXCYCLES) { into->arg = MAXCYCLES; break; }
20:23:57 <elliott> otherwise e.g.
20:23:59 <elliott> say maxcycles is 10
20:24:00 <elliott> you can say
20:24:01 <elliott> 999
20:24:03 <elliott> erm
20:24:08 <elliott> you can say
20:24:09 <elliott> 99
20:24:10 <elliott> because
20:24:12 <elliott> 9 < 10
20:24:12 <FireFly> impomatic, you impersonator
20:24:16 <elliott> 99 >= 10, so we just break
20:24:18 <elliott> without resetting it
20:24:18 <EgoBot> Score for impomatic_firefly: 27.2
20:24:21 <elliott> *capping it
20:24:22 <pikhq> _Nineteen Eighty-Four_ has gotten to be an *absurdly* depressing book of late.
20:24:28 <impomatic> FireFly: sorry :-P
20:26:17 <elliott> yay, all i have to do now is to retweak {}
20:26:51 <elliott> (I sane-ised my parser)
20:27:31 <ais523_> impomatic: anything innovative in that?
20:28:36 <impomatic> !bfjoust moonshine http://corewar.co.uk/2.txt
20:29:11 <EgoBot> Score for impomatic_moonshine: 13.4
20:29:22 <elliott> yay, now I handle ()*N efficiently
20:29:23 <elliott> by removing it :)
20:29:45 <elliott> also (comments)*N obviously
20:29:57 <elliott> also, I fully support (comment)*0 as the commenting standard for brainfuck joust
20:30:02 <elliott> and have used it in local work to great effect
20:30:09 <elliott> ais523_: can I get a RINGING endorsement from the LONG-TIME CHAMPION?!
20:30:17 <impomatic> ais523_: not really. I was thinking for the shortest tape the opponent would probably have (>)*9 and miss the cell I'm defending on. So I just tried to handle it differently.
20:30:35 <ais523_> elliott: not without a sample of what I'm supposed to endorse, and not until I have a non-Windows computer to run it on
20:30:48 <ais523_> impomatic: hmm, I've tried to exploit (>)*9-style programs before
20:30:49 <ais523_> it doesn't really work
20:31:10 <elliott> ais523_: you're meant to endorse ()*0 as commenting
20:31:23 <ais523_> oh, yes, good idea
20:31:28 <elliott> ( Go right 8 cells )*0
20:31:30 <elliott> (>)*8
20:31:32 <elliott> YES INDEED
20:31:51 <ais523_> also, I'm rarely at the top of the leaderboaard
20:31:54 <ais523_> *leaderboard
20:32:00 <ais523_> mostly, I'm hovering a little below the leaders
20:32:09 <impomatic> !bfjoust moonshine http://corewar.co.uk/2.txt
20:32:11 <ais523_> occasionally I submit a program and it goes straight to the top and surprises everyone, including me
20:32:24 <elliott> ais523_: you do pretty consistently well,t hough
20:32:26 <elliott> *well, though
20:32:37 <elliott> Compare with Gregor, whose programs either suck immensely or shoot straight to the top :P
20:32:41 <ais523_> yep, I like programs that hover around the middle of the leaderboard for ages
20:32:51 <EgoBot> Score for impomatic_moonshine: 16.4
20:34:23 <elliott> Gregor: You there?
20:34:51 <ais523_> hmm, is firefly a Nyarahtotep or however you spell it variant?
20:34:56 <elliott> Narlanrjnrkjentkarentlaerttop
20:35:01 <elliott> my spelling is _creative_
20:37:30 <elliott> ais523_: can you give me two competitors with repeats but no % (and no unbalanced repeats) that are well-matched?
20:37:40 <elliott> trying to "stress-test" here, so i want two good opponents that hopefully draw a lot
20:38:13 <ais523_> do they need to actually draw? or just have a hard time against each other?
20:38:40 <elliott> ais523_: that's fine too
20:38:48 <elliott> also, relatively short would be best
20:38:53 <elliott> because i pass via argv atm :P
20:39:07 <impomatic> ais523_: yes, the only real difference is the second link which tries to handle battles on the shortest tape
20:40:11 <coppro> pikhq: hrm?
20:41:10 -!- ais523_ has changed nick to ais523.
20:41:15 <pikhq> coppro: "Freedom is the freedom to say that 2 plus 2 makes 4. From that all else follows." I'd like that freedom.
20:41:26 <impomatic> !bfjoust half (>(-)*8>(+)*8)*4(>+++++[-]>)*10[-]
20:41:27 <ais523> !bfjoust decoybooster (>)*7(-)*64(<(-)*64<(+)*64)*3(>)*7([(+)*5[-.]]>)*21[-][-.--]
20:41:31 <elliott> the fact that you are talking in this channel means that this is not 1984
20:41:39 <ais523> just noticed that decoybooster doesn't finish off opponents on max-length tapes
20:41:45 <elliott> america may be fucked up, but that's a gross exaggeration.
20:41:49 <coppro> pikhq: oh right, your government is doing stupid shit
20:41:52 <pikhq> elliott: I'm not saying that we are literally in a Nineteen Eighty-Four scenario.
20:42:02 <EgoBot> Score for ais523_decoybooster: 41.2
20:42:02 <EgoBot> Score for impomatic_half: 1.3
20:42:28 <pikhq> elliott: I am saying "Fucking hell, that is getting eerie."
20:43:33 <impomatic> !bfjoust dumb (>(-)*8>(+)*8)*4(>+++++[-])*21
20:44:01 <ais523> elliott: my new decoybooster is pretty closely matched with the "half" that impomatic just posted
20:44:08 <elliott> heh, thanks
20:44:19 <EgoBot> Score for impomatic_dumb: 29.7
20:44:58 <elliott> $ time ./lance '(>(-)*8>(+)*8)*4(>+++++[-]>)*10[-]' '(>)*7(-)*64(<(-)*64<(+)*64)*3(>)*7([(+)*5[-.]]>)*21[-][-.--]'
20:44:58 <elliott> Sieve: <<<<<<<<<<<<<<<<>>>>>
20:44:58 <elliott> Kettle: <<<<<<<<<<<<<<<<>>>>>
20:44:59 <elliott> Left wins (-22)
20:45:00 <elliott> ais523: that correct?
20:45:02 <elliott> took 0.003s :P
20:45:09 <ais523> err, no
20:45:24 <ais523> ais523_decoybooster.bfjoust vs impomatic_half.bfjoust: ><><><><><><><><><>>< ><><><><><><><><><>>< ><><><><><><><><><>>< ><><><><><><><><><>>< impomatic_half.bfjoust wins
20:45:40 <impomatic> Yay! :-)
20:45:41 <elliott> ais523: "joy"
20:45:49 <coppro> ais523: what does that output indicate?
20:45:50 <elliott> ais523: at least i got the winner right.
20:46:01 <ais523> coppro: who wins on each tape length and polarity
20:46:11 <elliott> ais523: also, the order there is ++ polarity, +- polarity for the lines; and the line contents are 10 to 30 tape length
20:46:13 <ais523> those two programs match up the same regardless of polarity, incidentally
20:46:13 <elliott> but eh
20:46:26 <elliott> does Gregor's order the tape lengths logically? :P
20:46:29 <ais523> are "sieve" and "kettle" the names of your two polarities?
20:46:32 <ais523> and yes, it does
20:46:46 <coppro> ah
20:46:59 <elliott> ais523: they've always been the names of the polarities
20:47:01 <elliott> I named them that from the start
20:47:05 <elliott> then Gregor was all like
20:47:08 <elliott> OH I'M TOO COOL TO USE THE NAMES
20:47:12 <elliott> and then everybody forgot them.
20:47:18 <ais523> so why are the polarities named that?
20:47:27 <elliott> no reason at all :)
20:47:41 <ais523> my local egojoust-based testbench calls them standard and switched just so the names will be the same length
20:47:51 <elliott> ugh, another esolangs.org on proggit
20:47:59 <elliott> *esolangs.org link
20:48:07 <elliott> how did I guess! it's to a stupid joke language!
20:48:16 -!- zzo38 has joined.
20:49:04 <elliott> "I like it. There is a serious message behind the madness: a program that has no input or output is a null program.
20:49:04 <elliott> Of course, theoretically speaking there are two types of programs that have no output: eventually terminating ones and infinite loops. I wonder if this language as anything to say about that."
20:49:09 <elliott> I'm on proggit and I'm an intellectual!
20:49:13 <elliott> ok i should stop reading this thread
20:49:18 <ais523> it's not a joke AFAIK; it's a stupid OISC variant much like there are stupid BF variants
20:49:23 <ais523> *AFAICT
20:49:33 <ais523> but I don't consider the endless stream of stupid BF variants jokes
20:49:36 <elliott> ais523: it's clearly a joke language because of the example programs
20:49:41 <elliott> "Solve NP complete problem
20:49:42 <elliott> solves the np complete problem"
20:49:44 <elliott> "become self aware
20:49:45 <elliott> Cause the program to be self aware for a brief period"
20:49:52 <zzo38> Did you know? Abacists deaf dog hijacked luminous parquetry studio, avows ex-yakuza.
20:49:59 <elliott> ...
20:50:03 <ais523> I don't see those programs
20:50:05 <elliott> and zzo38 reaches new heights of coherence
20:50:08 <elliott> ais523: http://esolangs.org/wiki/Compute
20:50:17 <ais523> oh, there are /two/ esolangs links on reddit right now?
20:50:22 <ais523> I was looking at TinCan
20:50:39 <elliott> ah
20:50:42 <elliott> tincan looks stupid
20:50:44 <ais523> http://www.reddit.com/r/programming/comments/fjz71/i_created_my_own_esoteric_programming_language/ is what I thought you were referring to
20:50:49 <ais523> what were you referring to?
20:50:57 <elliott> the Compute link
20:51:02 <elliott> just grep (esolangs.org) on /r/programming
20:51:11 <ais523> ah, http://www.reddit.com/r/programming/comments/fk2kt/powerful_programming_language_only_one_drawback/
20:51:21 <ais523> what's the chance of two esolangs links that close time-wise?
20:51:32 <elliott> ais523: very high
20:51:40 <ais523> really?
20:51:46 <elliott> ais523: stupid thing gets posted on proggit, person sees it, likes stupid thing, looks around for another thing, finds another stupid thing
20:51:50 <zzo38> Finally I managed to make the DVI/GF processing codes in TeXnicard. Now it works.
20:51:52 <elliott> because they like stupid things, thinks it's worthy of posting
20:51:52 <elliott> posts it
20:53:04 <ais523> I was wondering if it was a concerted effort to bring /r/programming slightly more ontopic on average
20:53:09 -!- iamcal has joined.
20:53:27 <elliott> ais523: don't be silly; that belongs in /r/esolangs!
20:53:39 <ais523> hmm, has iamcal been here recently? IIRC, he/she was here ages ago and hadn't been here for ages
20:53:44 <ais523> but I'm not here all the time myself
20:53:50 <elliott> ais523: he
20:53:53 <elliott> it's cal157 or something
20:53:55 <elliott> i forget the name
20:53:58 <elliott> *nickname, rather
20:54:03 <elliott> he never talks when we don't ping him though
20:54:08 <elliott> hmm, that befunge interpreter seems to actually do jitting
20:54:10 <elliott> (on /r/esolangs)
20:54:12 <elliott> (-93)
20:54:41 <iamcal> iamcal == cal153
20:54:46 <ais523> there are only three posts on that reddit altogether
20:54:51 <ais523> iamcal: ah, that would make sense
20:54:51 <elliott> ais523: and one of them is me
20:54:54 <elliott> and contentless
20:54:54 -!- cal153 has quit (Ping timeout: 240 seconds).
20:54:55 <elliott> after creating it :P
20:55:20 <elliott> ais523: heh, it still links to ESO in the sidebar
20:55:33 -!- ais523 has changed nick to ais523_.
20:55:38 <elliott> ...
20:55:39 <ais523_> I should go back to my correct nick
20:55:45 <elliott> try ais523__
20:55:47 <elliott> :P
20:55:50 <ais523_> no
20:56:26 <zzo38> I invented a chess variant that the king is invisible. Did you invent any chess variant, too?
20:56:40 <ais523_> zzo38: do you know of Kriegspiel?
20:56:46 <ais523_> I didn't invent it, but it's along similar lines
20:56:48 <ais523_> and a really fun game
20:57:55 <elliott> ais523_: I wonder why on earth those programs have that wrong behaviour :(
20:58:09 <zzo38> ais523: Yes I do know of Kriegspiel chess.
20:58:26 <elliott> ais523_: you wrote one of them!
20:58:33 <elliott> ais523_: how can it not be your fault?
20:58:35 <ais523_> the programs work fine, it's lance that's broken
20:58:42 <elliott> ...what slander
20:59:07 <ais523_> technically speaking, it can't possibly be slander, this is a logged channel
20:59:16 <ais523_> thus it would automatically be libel rather than slander, were it illegal which it isn't
20:59:21 <zzo38> I also know of some other chess variants with incomplete information.
20:59:33 <elliott> 0[{0}
20:59:34 <elliott> 0-{0}
20:59:34 <elliott> 0]{0}
20:59:34 <elliott> 0-{0}
20:59:34 <elliott> 0]{0}
20:59:35 <elliott> 0-{0}
20:59:36 <elliott> 0]{0}
20:59:38 <elliott> 0-{0}
20:59:40 <elliott> well [-]s trace is correct
20:59:44 <Sgeo> I lie about elliott.
20:59:50 <elliott> wut
20:59:54 <Sgeo> In such a way as to harm his reputation.
21:00:41 <ais523_> also, gah
21:01:00 <ais523_> "while (1) sleep(UINT_MAX);" in a students' code
21:01:01 <elliott> Sgeo: how :D
21:01:08 <ais523_> and the worst part is, it isn't an infinite loop
21:01:22 <ais523_> I thought only INTERCAL was that spaghetti
21:01:23 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
21:01:27 <elliott> ais523_: hmm, what's wrong with that? I can't actually tell
21:01:31 <elliott> apart from sleep() failing
21:01:40 <elliott> well, being caused to exit early
21:01:43 <ais523_> it hides the logic
21:01:54 <ais523_> the whole of the rest of the program is in an interrupt handler
21:01:56 <elliott> ais523_: oh, in the middle of a student's code
21:02:01 <ais523_> including the exit
21:02:01 <elliott> err, and?
21:02:03 <elliott> ah
21:02:09 <elliott> is that avoidable?
21:02:10 <ais523_> and how would anyone be expected to look there?
21:02:28 <ais523_> typically it'd be while (volatile_sig_atomic_t_typed_flag) sleep(1) or whatever
21:02:39 <ais523_> then it's clearer what's happening
21:03:02 <fizzie> Hmm; I (for benchmarking) downloaded a copy of the hill, and ran "report egojoust tmp hill/*"; the resulting breakdown.txt contains 35 lines of "Right warrior failed to parse, left warrior wins!" and only 1046 valid reports, but the 35 bad lines don't correspond to a single program always, since all 47 unique names occur in the list of matches.
21:03:30 <ais523_> fizzie: there's some program that fails to parse only against certain opponents on certain tape lengths
21:03:35 <ais523_> which is a pain to track down
21:03:39 <Sgeo> "and so this week the first 20 minutes of each album are commercial free. "
21:04:09 <ais523_> Sgeo: I hope that's on a radio/radio-alike, rather than on a CD or download
21:04:16 <zzo38> One other incomplete information chess variant is Intrigue chess, which is as follows: Each player writes the name of any square on a paper, in secret, and then marks one of the pawns on the bottom in secret. If you capture the opponent's pawn, look to see if it marked.
21:04:19 <Sgeo> ais523_, Magnatune
21:04:34 <elliott> <ais523_> fizzie: there's some program that fails to parse only against certain opponents on certain tape lengths
21:04:37 <elliott> ais523_: you see *lance*...
21:04:44 <zzo38> If it is marked, look at the secret paper and put the king on that square. If anything else is already there, whatever is already there is removed from the board.
21:04:48 <Sgeo> http://blogs.magnatune.com/buckman/2011/02/short-adverts.html
21:04:58 <Sgeo> "So... this means less interruptions that ever before... for the first 20 minutes of each album. And then ads (every 30 secs) come in after the commercial-free 20 minutes"
21:05:07 <Sgeo> Ads every 30 sec? o.O
21:05:12 <elliott> Every 30 seconds? Hahahaha
21:05:13 <ais523_> during a piece of music?
21:05:28 <ais523_> that's... what?
21:05:31 <elliott> quick, someone remix the adverts into a track punctuated with silence every 30 seconds
21:05:36 <elliott> done so that it seems like the adverts are part of the track
21:05:49 <elliott> ais523_: obviously it's their way of moving to a pay-only model without actually saying "NO MORE FREE MUSIC FOR YOU"
21:06:52 <Sgeo> I think I accidentally clicked on a Braid soundtrack song
21:06:53 <Sgeo> Awesome
21:07:16 <Sgeo> No ads yet hmm
21:10:27 <Sgeo> I can't test the ad thing if it's not song but actually having to listen for 20 min
21:10:31 <elliott> $ time ./lance '[>[-]+]' '(-)*126(-+)*9999999999'
21:10:31 <elliott> Sieve: <><<><<><<><<><<><<><
21:10:31 <elliott> Kettle: >>>>>>>>>>>>>>>>>>>>>
21:10:35 <elliott> hmm... is that right? I think so
21:10:48 <elliott> Sgeo: You can't listen to something for 20 minutes?
21:11:43 <ais523_> elliott: it agrees with egojsout
21:12:04 <elliott> oh, right, i can just compare with egojstoustout
21:12:08 <elliott> !bfjoust
21:12:08 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
21:12:20 <ais523_> http://codu.org/eso/bfjoust/egojsout/egojsout.html
21:12:47 <elliott> aha
21:12:47 <elliott> (>[-])*30
21:12:49 <elliott> vs
21:12:50 <elliott> (-)*126(-+)*9999999999
21:12:51 <elliott> *vs.
21:12:56 <elliott> egojsout says it's > for all on sieve
21:12:58 <elliott> and < for all on kettle
21:13:01 <elliott> but my program DISAGREES
21:13:20 <Gregor> The "js" in "egojsout" is pronounced like some abominable amalgam of 'j' and 's' that nobody who isn't from China or the Czech Republic could even hope to pronounce.
21:13:26 <Sgeo> Sieve? Kettle?
21:13:39 <ais523_> Sgeo: apparently they're the names for the polarities
21:14:07 <Sgeo> Which is which?
21:14:16 <ais523_> sieve is unreversed, IIRC
21:14:17 <elliott> Gregor: perhaps like egoshout, but with the sh being more... abrasive
21:14:21 <elliott> sieve is normal, kettle is +-
21:14:42 <Gregor> elliott: Something like that, but you could never hope to pronounce it.
21:14:44 <Sgeo> How does polarity end up making any difference?
21:14:57 <elliott> because otherwise you can submit a program and swap + and -
21:15:00 <elliott> and it often does better
21:15:02 <elliott> which is just stupid
21:15:14 <Sgeo> Why would it do better?
21:16:00 <Gregor> Sgeo: Consider (-)*127 vs (>)*9(>[-])*21
21:16:27 <elliott> what Gregor said
21:16:47 <Gregor> elliott: In any disagreement between lance and egojsout, egojsout is right X-P
21:17:58 <Sgeo> So each program in a battle might have a different polarity?
21:18:16 <Sgeo> Instead of both having the same polairty, as I thought before?
21:18:36 <ais523_> elliott: those two programs where there's a disagreement, if there's a tape length dependency in lance, then lance is doing it wrong
21:18:45 <elliott> ais523_: indeed
21:18:48 <elliott> Sgeo: both programs having + and both programs having - is trivially equivalent
21:19:00 <elliott> even i can get that, and ais523_ has made a hobby of yelling SYMMETRY at me when i ask questions
21:19:11 <ais523_> sufficiently trivially equivalent that elliott tried to convince me it wasn't for five minutes
21:19:21 <Sgeo> elliott, that's why I didn't see how polarity made a difference
21:19:22 <elliott> ais523_: no
21:19:24 <elliott> that was +- and -+
21:19:30 <elliott> ++ and -- are trivially equivalent even to an ape
21:19:32 <ais523_> elliott: reverse one of the programs
21:19:33 <ais523_> now it's ++ and --
21:19:43 <Sgeo> Oh, that's what you mean by +-\
21:19:45 <elliott> ais523_: hey, that requires like a millisecond of thought
21:19:53 <elliott> realising ++ = -- doesn't
21:20:01 <elliott> Sgeo: + means + and - do the normal thing
21:20:04 <elliott> - means they're reversed
21:20:09 <elliott> basically the notation says what + does
21:20:12 <elliott> so +-, left program has normal
21:20:16 <elliott> right program has + and - swapped
21:20:22 <Sgeo> Ok, it's just that I thought that Sieve was ++ and Kettle was --, which made no sense
21:20:59 <elliott> Gregor: PLZ2BE s/, polarity inverted/, kettle/ in egojsout :P
21:21:28 <ais523_> elliott: you do realise that your polarity names make no sense, right?
21:21:29 <Gregor> Nevar
21:21:43 <elliott> ais523_: do names usually make sense?
21:21:56 <ais523_> well, sometimes
21:21:59 <elliott> ais523_: at least mine are memorable
21:22:02 <ais523_> and they're better when they do
21:22:08 <elliott> no they're not
21:22:11 <ais523_> it's hard to remember which is which for yours
21:22:14 <Sgeo> Source and Antisource
21:22:18 <elliott> also, + is dink and - is donk
21:22:33 <elliott> I invented this terminology days before egojoust even started being implemented, so no arguments :P
21:22:44 <Sgeo> Since in ++, the source programs are used as is, and in +-, one is inverted
21:22:49 <Gregor> elliott: *egojsout, right?
21:22:54 <elliott> No.
21:22:58 <Gregor> Wow :P
21:23:26 <elliott> Gregor: I started implementing lance a few days before egojoust came about, and about a day after we fleshed out the polarity system and I gave them the names.
21:24:05 <Sgeo> Where do the names come from?
21:24:14 <Sgeo> At least my names make sense, if they're a bit uncreative
21:24:43 <elliott> I made them up.
21:24:50 <elliott> And you're gonna learn to like them.
21:29:47 <elliott> ais523_: is Agora as dead as it looks? I haven't checked it in ages
21:30:03 <ais523_> quite a few major people ragequit for various reasons recently
21:30:04 <fizzie> Gregor: What do the first and the last numbers in the egojsout trace mean?
21:30:05 <ais523_> including me
21:30:11 <elliott> fizzie: death counter
21:30:17 <ais523_> and so it's sulking in comparison
21:31:11 <fizzie> elliott: What is a death counter? I mean, can you die more than once within one particular match?
21:31:32 <elliott> fizzie: When your flag goes to 0, it becomes 1.
21:31:35 <elliott> When the death count becomes 2, you die.
21:31:40 <elliott> When you go off the edge, your death count becomes 2.
21:32:06 <fizzie> Ohhhh, two consecutive cycles.
21:32:09 <fizzie> I didn't even know that.
21:32:17 <elliott> durpfizzie
21:32:19 <fizzie> I certainly shouldn't be implementing this stuff.
21:32:47 <fizzie> Well, it's so confusing with all this "original version" "ais523 revised version" "egojoust version" wikipage nonsense.
21:33:47 <ais523_> they don't really deserve separate pages
21:33:58 <ais523_> and they are different versions, so...
21:34:17 <fizzie> I don't seem to be any good at mental patch(1)ing.
21:35:48 -!- Mannerisky has joined.
21:39:22 <Gregor> There, I changed the numbers to have UNICODE FLAGS
21:39:29 <Gregor> YAY UNICODE
21:39:47 <elliott> Gregor: wat
21:39:50 <elliott> !bfjoust
21:39:51 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
21:40:12 <elliott> Gregor: make it go white when you lose :D
21:40:18 <Gregor> elliott: It does 8-D
21:40:38 <elliott> Gregor: :D
21:40:53 <elliott> Gregor: but it goes white when you lose due to going off the tape too
21:40:55 <elliott> that's not ok!
21:41:04 <elliott> well ok maybe it is
21:41:21 <Gregor> I'm waiting to have a more concrete idea of what the correct response to the infamous suicide-zero-flag-tie is.
21:41:28 <Gregor> Since I'll need to change something for that.
21:42:23 <elliott> Gregor: That's a tie.
21:42:30 <elliott> Both of you lost, at the same time.
21:42:37 <elliott> Neither program lost or won more than the other.
21:42:43 <elliott> It's a tie in the purest sense of the word, and lance has done that from the start.
21:42:45 <Gregor> That's my thoughts too, but the "spec" doesn't make it very clear.
21:43:00 <elliott> We hardly have any kind of spec :P
21:43:08 <elliott> Gregor: Also, < draws with itself.
21:43:15 <ais523_> [-] obviously ties with [-]
21:43:15 <elliott> Again, tie, for exactly the same reason.
21:43:27 <ais523_> or did you mean something else?
21:43:32 <elliott> nope, he meant that
21:46:08 <Vorpal> elliott, big news. See other channel.
21:46:48 <elliott> oh dear, Vorpal's pregnant again
21:47:39 <Gregor> Bleh, Unicode skull and crossbones is two small :(
21:48:37 * pikhq grins
21:49:04 <pikhq> So, Monty Python put a gigantic bunch of Flying Circus videos on Youtube for free. (I think it's nearly every sketch by now?)
21:49:13 <pikhq> This has apparently lead to a 23,000% increase in DVD sales for them.
21:49:31 <elliott> Gregor: *too
21:50:01 <Gregor> elliott: ... /me sobs
21:50:20 <pikhq> Argh, no, nowhere near every sketch.
21:50:34 <pikhq> Just quite a few of the more popular ones.
21:51:13 <coppro> so you mean free stuff lets you sell stuff?
21:51:14 <coppro> NO WAI
21:51:39 <Gregor> Maybe I'll just use UNICODE WHITE FROWNING FACE
21:51:43 <pikhq> coppro: I know, it's kinda obvious that letting people get an idea what your stuff is like gets people to want it.
21:52:54 <coppro> pikhq: not to *AA
21:53:41 <elliott> Gregor: Racist.
21:54:35 <pikhq> coppro: Well, no, they seem to think that the more they charge the more money they get.
22:00:54 <pikhq> o.O
22:01:12 -!- Leonidas has quit (Quit: An ideal world is left as an exercise to the reader).
22:01:16 <pikhq> In Canada, there is a legal tender million dollar coin.
22:01:37 <ais523_> all "legal tender" means is that you can use it to settle a debt
22:01:48 <pikhq> ais523_: I'm well aware.
22:01:55 <pikhq> Though, as the coin is made of gold, it is actually worth significantly more than $1 million.
22:02:22 <pikhq> (it is 100 kg)
22:02:53 <Ilari> Hmm... Last ~30 years, energy americans obtained from food has been going up. Also, obsesity epidemic. But is the enegy increase cause or effect?
22:02:57 <pikhq> The coin in question is in the Royal Canadian Mint, and for obvious reasons will likely never circulate as such.
22:03:16 <elliott> Two correlated factors! Clearly there must be causality!
22:03:39 <ais523_> piracy (the old-fashioned kind with ships) prevents global warming!
22:03:44 <pikhq> ais523_: :)
22:03:52 <Gregor> Maybe I should use PEACE SYMBOL :P
22:03:56 <elliott> ais523_: Hey, REAL piracy prevents global warming too!
22:04:06 <elliott> ais523_: If you don't think that's the case, that's just because there's not enough piracy yet.
22:04:12 <elliott> Only you can save Earth!!!
22:04:17 <elliott> Infringe copyright today!
22:04:20 <pikhq> elliott: Well, it actually seems reasonable that there is a causal link between higher food energy consumption and obesity.
22:04:26 <ais523_> you can actually make a plausible case for that
22:04:39 <elliott> ais523_: not _really_ :P
22:04:43 <ais523_> if you download something rather than buying it in a shop, it saves on transport and packaging, both of which release carbon
22:04:54 <ais523_> that applies equally well to legal and illegal downloads, ofc
22:05:07 <ais523_> but most things don't have legal downloads (although most of the things that actually matter do)
22:05:37 <pikhq> Legitimate purchase of copyrighted works does, indeed, usually involve shipping and packaging. Downloading uses electricity, most of which would be in use anyways.
22:05:37 <Gregor>
22:05:46 <Ilari> Or is there third factor that causes both at the same time?
22:06:04 <elliott> Gregor: ugh, stop being elliottcable
22:06:22 <ais523_> Ilari: rise of convenience foods, maybe
22:07:15 <ais523_> !bfjoust attack1 [>[-]-]
22:07:19 <pikhq> Sheer expense of more healthy goods.
22:07:28 <Ilari> Actually, the real question is: What bypasses / breaks down normal metabolic control systems?
22:08:37 <pikhq> I'd be tempted to say "corn syrup", but that probably isn't the whole problem. What with an obesity epidemic developing in other countries, where corn syrup is actually more expensive than sugar.
22:09:04 <ais523_> it's not as bad in most countries as it is in the US
22:09:16 <ais523_> I've seen a theory that obesity is actually caused by a virus, although that seems vaguely implausible
22:09:23 <elliott> hmm, maybe my timing is messed up here
22:09:26 <elliott> ais523_: you know those two programs you gave me?
22:09:38 <elliott> ais523_: do they ever run off the tape? ever?
22:09:40 <pikhq> (well, *technically* corn syrup already has a higher cost than sugar in the US, but most of that cost is in taxes, and would be paid *anyways*...)
22:09:47 <elliott> (>)*9 counts as running of the tape ofc
22:09:49 <elliott> *off
22:09:53 <pikhq> (fuck corn subsidies SO MUCH)
22:10:00 <ais523_> which two were they? fool and decoybooster?
22:10:06 <ais523_> *half and decoybooster
22:10:07 <ais523_> I think they do
22:10:08 <Ilari> Oh, there are also subsides for soy and wheat.
22:10:17 <pikhq> Ilari: The corn subsidies are much worse.
22:10:20 <elliott> ais523_: then quite possibly it's because i handle running off the tape between turns
22:10:35 <ais523_> no, it's not a minor timing difference like that
22:10:35 <pikhq> Though, really, all the subsidies on grains really distort the market a lot.
22:10:45 <ais523_> if one program runs off, the other one is nowhere near winning or losing
22:11:04 <elliott> ais523_: well, yeah...
22:11:06 <Gregor> pikhq: HEY, high_fructose_corn_philip resents that.
22:11:09 <elliott> but that's the only thing that's wrong :D
22:11:14 <pikhq> The various grain subsidies are a major, major part of why modern factory farming works at all.
22:11:18 <elliott> well
22:11:20 <elliott> wrong = differnet
22:11:22 <elliott> *different
22:11:22 <elliott> :/
22:11:46 <Ilari> And are the primary reason why food production is so unsustainable right now.
22:11:51 <pikhq> Quite true.
22:12:40 <Ilari> What was the calories in / calories out ratio of food production (ignoring solar input) right now? I have heard of figures like 10.
22:12:43 <pikhq> Corn subsidies are the worst, because they (IIRC) make producing corn profitable *before any sales occur*...
22:13:03 <ais523_> Europe subsidises farmers to keep on farming
22:13:08 <EgoBot> Score for ais523__attack1: 3.2
22:13:15 <ais523_> although I'm not sure if it subsidises particular sorts of farming more than others
22:13:49 <pikhq> ais523_: The US has megacorps doing most all the farming.
22:14:08 <ais523_> yep, in which case subsidy doesn't make a lot of sense
22:14:18 <ais523_> I think the EU subsidies are because they like the idea of farmland being tended by farmers
22:14:29 <pikhq> If it were just subsidising farmers *in the general case*, it'd be much less objectionable.
22:14:35 <ais523_> if they actually produce food, it's just a bonus
22:14:48 <ais523_> many people dislike the EU subsidies anyway, though, because they seem a little pointless
22:14:59 <pikhq> "We're going to make it easier for you to make a living producing food" is, at least, not something that horribly screws up the entire agricultural market.
22:15:10 <pikhq> It may not be that great an idea anyways, but... Yeah.
22:15:32 <Ilari> Oh, and US subsidies not only screw up US market. US exports lot of grains, screwing food production in lots of places.
22:15:39 <pikhq> Quite true.
22:16:12 <ais523_> how is it, that everything insane about the UK/Europe, seems to exist in a substantially more insane form in the US?
22:16:20 <pikhq> ais523_: We export insanity.
22:16:24 <ais523_> (except possibly for CCTV and similar government surveillance)
22:16:27 <pikhq> It is our major export.
22:16:42 <ais523_> clearly, we need to put large import duty on it
22:16:43 <ais523_> we'd make a fortune
22:16:59 <elliott> ugh, CCTV
22:17:03 <elliott> I wonder why it's such a uniquely British problem
22:17:09 <elliott> even Americans think it's insane
22:17:09 <pikhq> ais523_: You do realise that the CIA has installed logging devices all over the US's network infrastructure, right?
22:17:21 <Ilari> And farming of grains is extremely enviromentally destructive anyway.
22:17:29 <elliott> I guess because US crazies are insanely pro-personal-liberties
22:17:36 <ais523_> pikhq: yep, the US is worse wrt technological solutions to that sort of thing
22:17:47 <ais523_> the UK is more into tracking the movement of individual people
22:17:58 <ais523_> so it's a different kind of insanity
22:18:20 <pikhq> Ilari: It'd probably be much less so if there were less of an incentive to do it.
22:19:01 <Ilari> And grains also appear to be quite destructive to health (at least without proper processing, which just isn't done nowadays).
22:19:13 <ais523_> at least the CCTV has vague advantages as well as the disadvantages; it's reasonably good at stopping certain sorts of burglary, for instance
22:19:24 <elliott> ais523_: I don't care about CCTV in stores
22:19:33 <pikhq> I'd imagine that the amount of grain that's actually used in a "normal" way to get food is a very small percentage of what's produced.
22:19:40 <elliott> ais523_: but in public, it's unacceptable
22:19:49 <ais523_> the CCTV aimed at roads only happens in city centres, as far as I know
22:19:58 <ais523_> CCTV still requires warning signs wherever it's used
22:20:07 <pikhq> With most of it being used in various industrial processing methods simply because it's so fucking cheap.
22:20:09 <ais523_> and the nearest area like that is miles from my house, for instance
22:20:27 <elliott> ais523_: yep, but it could easily get more insidious quickly
22:20:54 <pikhq> Oh, and of course for feeding pretty much all livestock.
22:21:21 <pikhq> In a manner that is itself absurdly damaging to the environment.
22:21:40 <Ilari> That "ignore solar radiation in energy inputs" should be quite realistic approximation, since solar radiation is essentially free energy, but other forms of energy that are used on it aren't.
22:22:00 <quintopia> !bfjoust poke http://sprunge.us/IcjB
22:22:55 <pikhq> And it *all* depends so fucking heavily on petrochemicals that peak oil will probably break agriculture.
22:23:08 <elliott> ais523_: have you got any simple warriors that use ()*? it's hard to debug with the complex ones
22:23:25 <Ilari> Oh, and then there's corn ethanol. Using the highest EROEI figures I have heard, it is still insane.
22:23:37 <quintopia> elliott: did you try shudder? :P
22:23:39 <ais523_> !bfjoust simpleskip (>)*8(+>+++++[-])*21
22:23:41 <pikhq> *shudder*
22:23:43 <elliott> quintopia: against what?
22:23:49 <elliott> <quintopia> elliott: did you try shudder? :P
22:23:49 <elliott> <pikhq> *shudder*
22:23:56 <elliott> ais523_: ah, against what?
22:23:57 <pikhq> Corn ethanol.
22:24:06 <ais523_> elliott: oh, I just came up with that off the top of my head
22:24:14 <ais523_> it's not really meant to beat or tie with anything
22:24:23 <pikhq> AKA "burning money".
22:24:46 <elliott> $ time ./lance '(>)*8(+>+++++[-])*21' '(>)*8(+>+++++[-])*21'
22:24:47 <elliott> Sieve: >>>>>>>>>>>>>>>><<<<<
22:24:47 <elliott> Kettle: >>>>>>>>>>>>>>>><<<<<
22:24:47 <elliott> Right wins (22)
22:24:51 <elliott> HMM
22:25:04 <ais523_> are those two programs not identical?
22:25:09 <elliott> yes, yes they are
22:25:18 <ais523_> something's pretty wrong, then
22:25:25 <ais523_> the tape-length dependence is particularly hilarious
22:25:25 <elliott> JUST A BIT
22:25:38 <elliott> ais523_: or maybe lance just disproved symmetry!!!!
22:25:41 <elliott> IT COULD HAPPEN
22:27:10 * quintopia knocks on egobot
22:27:12 <quintopia> you there?
22:27:15 <EgoBot> Score for quintopia_poke: 52.0
22:27:17 <quintopia> hi there
22:28:37 <Gregor> O_O
22:28:46 <ais523_> quintopia: what sort of strategy does that use?
22:28:49 <EgoBot> Score for ais523__simpleskip: 5.3
22:28:53 <Gregor> I KIWW U WIT A SPOON
22:28:59 <Ilari> Animals usually defend against predation using speed, sharp things, camoflage, etc (sometimes also toxins, but those that do tend to be distinctive). Plants use toxins and antinutrients.
22:29:28 <quintopia> ais523_: exactly what it says. it pokes the opponent before building decoys. i could probably make it even better by having it build even more decoys.
22:29:43 <ais523_> oh wow, that's ingenious
22:29:58 <ais523_> it's obvious what it's doing looking at a debug trace
22:30:29 <Ilari> Of course, there's also resistance to toxins, not having the mechanisms those toxins affect and enzymes that can break down antinutrients.
22:30:51 <elliott> pokes how
22:31:22 <ais523_> elliott: it starts off by seeing where the opponent is on the tape
22:31:23 <pikhq> Ilari: And humans just figure out how to deactivate it.
22:31:27 <ais523_> then runs back over to its side and builds decoys
22:31:32 <elliott> what's a good opponent to show it against in a debugger
22:31:34 <ais523_> then it goes back to where it saw the opponent was
22:31:35 <pikhq> (see: half of food preperation)
22:31:40 <ais523_> try defend10
22:31:59 <ais523_> that doesn't show off any of the advantages of poke, but does show off the strategy well
22:32:12 <Gregor> Ohhhhhhhhhhhhhhhhhhhhhhh
22:32:22 <Gregor> I'm seein' it.
22:32:23 <Gregor> quintopia: Clever.
22:32:31 <ais523_> I am really impressed at that
22:32:36 <quintopia> the strategy can never be used to beat speedy2 though, because they always just cross
22:33:20 <Ilari> Some of those toxins/antinutrients are heat-unstable. But some are heat-stable (which makes them much nastier to deactivate).
22:34:06 <Gregor> Damn, decoys are almost totally useless in the face of poke.
22:34:27 <pikhq> Ilari: Mmmm, fermentation.
22:34:29 <Ilari> Oh, and grains have quite good complement of heat-stable ones.
22:34:35 <Ilari> Yeah, that's one way.
22:34:47 <ais523_> yep, this gives a large argument for /not/ trailing
22:34:48 <Ilari> Also soaking and sprouting.
22:35:12 <Gregor> ais523_: But only against poke :P
22:35:25 <Gregor> I think quintopia has officially introduced a unique strategy, not yet seen before.
22:35:29 <ais523_> I think poke automatically loses to any aggressive program that doesn't set decoys
22:35:36 <ais523_> because it'll be crossed and not have chance to set up again
22:35:40 <ais523_> Gregor: so do I
22:35:47 <ais523_> well, it's a variation on large-decoy-based rushing
22:35:53 <ais523_> but a really interesting one
22:36:04 <Gregor> ais523_: Yeah, >(>)*9([-]>)*21 beats poke.
22:36:19 <Gregor> ais523_: I'm referring purely to the "poke" part, not what it does after poking.
22:36:19 <elliott> What BF Joust needs is a way to tell whether the current cell is > or < 128 :P
22:36:28 <ais523_> that'd make things too easy
22:36:48 <elliott> ais523_: I know :P
22:37:13 <elliott> ais523_: But maybe a "closer to 0" instruction would be nice? I dunno.
22:37:29 <ais523_> I think poke beats most slow-rush programs; and loses to pretty much all fast-rush programs
22:37:38 <ais523_> but fast-rush programs are a rare breed nowadays because they tend to lose hard to slow-rush programs
22:37:46 <ais523_> unless they screw around with dodging tripwires
22:37:57 <Ilari> Oh, and with some of those, there's no way to deactivate them, rendering the whole thing unedible (or requiring finding something to compensate the effects with).
22:39:24 <ais523_> double_tripwire_avoider really decimates poke in all sorts of ways, btw
22:39:38 <ais523_> even though it both decoys and trails
22:40:02 <zzo38> The GFtype program in MiKTeX appears broken
22:40:11 <ais523_> actually, a bit less than decimates, it doesn't make up 1/10 of the hill
22:42:13 <elliott> back 6
22:42:14 <Gregor> If not a history of BF Joust, somebody should write a wiki page detailing the various BF Joust strategies.
22:44:12 <quintopia> i modified it slightly and now it draws with speedy2 on all large tape sizes. interest.
22:44:29 <quintopia> for one polarity anyway
22:45:15 <elliott> ais523_: something a bit disturbing about bf joust
22:45:18 <elliott> you can effectively break out of a loop
22:45:35 <quintopia> hmm?
22:45:44 <elliott> [foo ...condition...[thing i want to do after breaking out(.)*-1]...]
22:46:51 <quintopia> ...on both polarities :P
22:46:58 -!- ais523_ has quit (Ping timeout: 245 seconds).
22:47:04 <elliott> quintopia: ?
22:47:19 <Gregor> Look at philip. Effectively breaks out of the loop by starting the loop again within the loop.
22:47:27 <elliott> yeah
22:47:47 <quintopia> that's pretty much how bf works, yeah
22:48:17 <elliott> !bfjoust ethernet http://sprunge.us/fMFW
22:48:26 <elliott> on longer tape lengths on both polarities this either draws with or beats wireless
22:48:41 <elliott> seems like it does terribly against anything else, though :)
22:48:42 <EgoBot> Score for elliott_ethernet: 0.0
22:48:46 <elliott> what?
22:48:46 <Gregor> lol
22:48:54 <elliott> no, really, what?
22:48:56 <elliott> Gregor: egojsout has a bug
22:49:09 <elliott> Gregor: run the program in http://sprunge.us/fMFW against wireless
22:49:14 <elliott> note how it draws or wins on higher tape lengths
22:49:19 <elliott> note that this doesn't happen with egojoust
22:49:22 <elliott> is *0 broken in egojoust?
22:49:23 <elliott> or?
22:49:46 <Gregor> It's possible that *0 has nonsense behavior on egojoust.
22:50:01 <elliott> btw i think that strategy is quite unique
22:50:04 <elliott> it's sort of like poke except stupid
22:50:26 <elliott> !bfjoust ethernet (>)*8+(>[<[(+)*80<]((-)*80<)*7(-)*127(-+)*-1]+)*-1
22:50:46 <EgoBot> Score for elliott_ethernet: 0.0
22:50:50 <Gregor> Where's lance? X-P
22:50:57 <elliott> Gregor: egojoust is totally broken.
22:51:03 <elliott> Gregor: Oh wait.
22:51:10 <elliott> Gregor: egojoust is broken because it caps repeats to 10K, not 100K.
22:51:18 <Gregor> ahlawl
22:51:26 <Gregor> Where's lance? X-P
22:51:28 <elliott> !bfjoust ethernet ((>)*8+(>[<[(+)*80<]((-)*80<)*7(-)*127((-+)*-1)*-1]+)*-1)*-1
22:51:36 <elliott> Gregor: Broken for some unknown reason, I'll fix it after playing a bit :P
22:51:49 <elliott> I think egojoust segfaulted or something.
22:52:27 <Gregor> Where's my CO2 >: (
22:53:52 <quintopia> okay, no it kicks speedy2's ass. let's find out if it still beats other things...
22:54:10 -!- Mathnerd314 has joined.
22:54:17 <elliott> quintopia: I beat your fucking #1 program and egojoust is withholding my victory
22:54:19 <elliott> Bitch
22:54:40 <quintopia> !bfjoust poke http://sprunge.us/eFgA
22:54:54 <elliott> You might be waiting a long while.
22:54:55 * quintopia waits to see the result before vamoosing
22:55:01 <quintopia> damn
22:55:06 * quintopia just goes then
22:59:10 <Sgeo> A program specifically designed to beat only the strongest program wouldn't score well, would it?
22:59:56 <Deewiant> Not unless it happens to beat a lot of other stuff too
23:06:49 <elliott> It would score okay
23:06:58 <elliott> Especially if it tied or beat one or two others.
23:08:14 <Sgeo> I can never remember the URL
23:08:19 <elliott> !bfjoust
23:08:21 <elliott> See above
23:08:34 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
23:10:35 <Sgeo> Would help if I understood what these programs were doing
23:10:56 <elliott> Sgeo: use egojsout
23:10:59 <elliott> easy to see any behaviour
23:13:19 <Sgeo> !bfjoust lame (>)*10(-)*127
23:14:00 <Sgeo> Slow
23:14:44 <elliott> Sgeo: What.
23:14:57 <elliott> Sgeo: That works for 11-length tapes, and the program has to decrement its flag by one first.
23:15:01 <elliott> You mean *128, for a start.
23:15:05 <elliott> *11-length tapes only,
23:15:45 <Gregor> http://esolangs.org/wiki/BF_Joust_strategies <-- please expand, particularly with defensive strategies.
23:15:46 <Gregor> I didn't even mention tripwire, for instance.
23:15:57 <elliott> Gregor: that really belongs as part of the BF Joust article...
23:15:57 <Sgeo> So, except for the 127 thing, it should win occasionally
23:16:02 <elliott> Sgeo: *never
23:16:07 <elliott> Nothing is stupid enough to let that work.
23:16:19 <elliott> Sgeo: And since you will lose on any non-11 tape length, you'll lose all your matchups.
23:16:25 <quintopia> wow
23:16:39 <quintopia> it still hasn't finished
23:16:46 <elliott> Gregor: Also, "BrainFuck" has two extraneous capital letters.
23:16:49 <Sgeo> Oh, so ulimately there's one result for each a vs b?
23:16:56 <Gregor> elliott: Well, then import it first :P
23:16:58 <elliott> Sgeo: Yes.
23:17:00 <elliott> <elliott> Gregor: Also, "BrainFuck" has two extraneous capital letters.
23:17:07 <elliott> Gregor: How can you even commit such a crime of capitalisation.
23:17:08 <Sgeo> What happens if they tie?
23:17:10 <elliott> *crime of orthography.
23:17:13 <Gregor> It hasn't finished because it'll tie in 100K cycles all the time.
23:17:56 <elliott> And because we're not using Lance(TM), the Fastmaker.
23:18:03 <Gregor> elliott: Then fix that AND import it into BF_Joust :P
23:18:05 <quintopia> anyway the new one will probably suck
23:18:16 <elliott> Gregor: Rather than working on lance??
23:18:27 <Gregor> elliott: AND WHY'S THAT
23:18:31 <Sgeo> 100K cycles?
23:18:36 <quintopia> anyway the new one will probably suck
23:18:36 <elliott> Sgeo: The limit.
23:18:40 <elliott> Gregor: And why's what
23:18:40 <quintopia> whoa
23:18:41 <elliott> quintopia: ?
23:18:43 <quintopia> weird
23:18:49 <quintopia> sorry
23:18:54 <Gregor> elliott: Why is it that we're not using lance :P
23:18:55 <Sgeo> Awesome, we can DDoS EgoBot
23:18:56 <quintopia> i'm running out of Gs
23:19:02 <quintopia> i started at 3G
23:19:08 <quintopia> and now it's laG
23:19:12 <Sgeo> Hmm, what should cause the most ties?
23:19:21 <Gregor> Sgeo: Not very effectively.
23:19:27 <elliott> !bfjoust tie_the_knot ((+)*-1)*-1
23:19:31 <elliott> Gregor: Because you want me to edit wiki pages instead!
23:19:36 <elliott> !bfjoust
23:19:52 <elliott> Cool, codu.org went down.
23:19:59 <Gregor> A) The first 'D' is a lie
23:20:04 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
23:20:05 <Gregor> B) It doesn't disable any other services
23:20:05 <Gregor> C) You can't even get it running two at once
23:20:15 <elliott> <Gregor> A) The first 'D' is a lie
23:20:17 <elliott> What?
23:20:23 <Gregor> "Distributed"
23:20:37 <elliott> I must be TEH LAGGING
23:20:50 <Sgeo> codu was slow before
23:20:58 <elliott> !bfjoust dos ((()*-1)*-1)*-1
23:20:59 <elliott> OH
23:21:00 <elliott> I WENT THERE
23:21:13 <Sgeo> What does *-1 do?
23:21:17 <elliott> *10K
23:21:58 <Sgeo> Surely (()*-1)*10 does the same?
23:22:07 <elliott> 10,000, not 10K
23:23:16 -!- MigoMipo has quit (Read error: Connection reset by peer).
23:23:27 <elliott> Gregor: Wow, it's actually running it.
23:23:46 <elliott> !bfjoust dos ((([)*-1)*-1)*-1
23:24:59 <Sgeo> Good question: Why did I type DDoS?
23:26:20 <Vorpal> <pikhq> This has apparently lead to a 23,000% increase in DVD sales for them. <--- *wow*
23:27:58 <Sgeo> Vorpal, what?
23:30:23 <Vorpal> Sgeo, see log
23:31:44 <elliott> And piracy contributes to sales too! Zomg it's unbeliebable, the RIAAAA says it ain't so!!!
23:32:05 <Sgeo> Depends on the piracy and pirated program, really
23:32:09 <elliott> What?
23:33:24 <Sgeo> Pirated single-player games might not encourage conversion to sales the way, say, Minecraft does
23:33:24 -!- myndzi has quit (Read error: Connection reset by peer).
23:33:24 <Sgeo> Of course, this is only a guess. I'd like to see actual studies
23:33:36 <elliott> That sentence was incoherent.
23:33:42 -!- myndzi has joined.
23:34:33 <Sgeo> Pirated copies of Minecraft necessarily do not have all features that the full version does (with regards to going online). Single player games don't have that advantage.
23:34:40 <elliott> Sgeo: What do you mean? The majority of Minecraft play is single-player.
23:34:43 <elliott> Also, that's quite irrelevant.
23:34:57 <elliott> There are many reports of Minecraft pirates whining about not being able to play multiplayer, but not buying the game.
23:35:12 <elliott> And similarly there are many people who buy the game after only playing it pirated in single-player without the desire for SMP.
23:35:23 <elliott> Sgeo: Also, WTF made you think I was referring to games only?
23:35:32 <Sgeo> But are there pirates who bought the game specifically for SMP?
23:36:23 <elliott> Possibly. But I see no indication that Minecraft's sales from piracy would be any worse if multiplayer was free for anyone.
23:36:41 -!- EgoBot has quit (Ping timeout: 240 seconds).
23:36:50 <elliott> I haven't heard much "I bought it to play on SMP" at all; I've heard a lot of "my annoying friend keeps whining that he can't play SMP with his pirated copy, and won't pay for it" and "I bought it after 3 SECONDS of playing singleplayer! SO AMAZING~~"
23:37:02 -!- FireFly has quit (Quit: swatted to death).
23:44:13 -!- Zuu has quit (Quit: Reconnecting).
23:44:17 -!- Zuu has joined.
23:58:15 -!- Zuu has quit (Read error: Connection reset by peer).
23:59:39 <elliott> Hey Gregor
23:59:47 <elliott> It's cool if lance has weird random bugs right?
23:59:51 <elliott> You'll TOTALLY STILL USE IT?
23:59:53 <elliott> (fixing sounds hard)
←2011-02-11 2011-02-12 2011-02-13→ ↑2011 ↑all