00:00:00 <EgoBot> Score for KingOfKarlsruhe_king: 7.4
00:00:02 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*6(>[+])*20
00:00:05 <EgoBot> Score for leonid__lols: 21.9
00:00:19 <ais523> !bfjoust isthata128 (>)*9((+)*128>)*21
00:00:22 <EgoBot> Score for ais523_isthata128: 5.0
00:00:33 <EgoBot> Score for KingOfKarlsruhe_king: 0.0
00:00:41 <ais523> heh, it lost to everything but boring
00:00:48 <ehird> lance.c:120: warning: control may reach end of non-void function ‘run_match’ being inlined
00:00:53 <ais523> which is strange, I expected it to beat defend6
00:00:57 <ehird> i wonder what that means
00:01:05 <ais523> ehird: it's like control may reach end of non-void function
00:01:12 <ais523> but the fact that it's inlined makes it worse
00:01:12 <ehird> i got one of them too :)
00:01:21 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*6(>[+][+])*20
00:01:23 <EgoBot> Score for leonid__lols: 22.4
00:01:25 <ehird> warning: REALLY TERRIBLE SHIT IS GOING TO HAPPEN.
00:01:27 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*7(>[+][+])*20
00:01:29 <EgoBot> Score for leonid__lols: 29.6
00:01:33 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*7(>[+][+][+])*20
00:01:36 <EgoBot> Score for leonid__lols: 30.7
00:01:47 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*7(>([+])*10)*20
00:01:49 <ehird> AnMaster: yes, I know what that part means
00:01:49 <EgoBot> Score for leonid__lols: 30.7
00:01:53 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*7(>([+])*20)*20
00:01:54 <AnMaster> int foo(void) { /noreturn here
00:01:56 <EgoBot> Score for leonid__lols: 27.1
00:01:59 <AnMaster> int foo(void) { /* noreturn here */ }
00:02:03 <ehird> *wonders if a warrior consists of anything else*
00:02:07 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*8(>([+])*10)*20
00:02:08 <ehird> I was talking about the rest.
00:02:10 <EgoBot> Score for leonid__lols: 30.7
00:02:14 <ais523> haha, I just figured out what's wrong with isthata128
00:02:19 <ais523> !bfjoust isthata128 (>)*9((+)*128.>)*21
00:02:22 <EgoBot> Score for ais523_isthata128: 27.5
00:02:59 <AnMaster> ais523, idea: make a program that won't draw against itself
00:03:04 <ais523> also, that beats defend6, although it wouldn't beat the parody version
00:03:12 <ais523> there's no way to break symmetry
00:03:20 <ais523> AnMaster: it's trivial to prove
00:03:27 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*10(>([+])*5)*20
00:03:28 <ais523> the thing's symmetrical and determinstic
00:03:30 <EgoBot> Score for leonid__lols: 42.9
00:03:30 <AnMaster> ais523, couldn't you make both loose at the same time
00:03:31 <ais523> that's all the proof you need
00:03:40 <ais523> AnMaster: both losing at the same time is a draw
00:03:45 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*11(>([+])*5)*20
00:03:48 <EgoBot> Score for leonid__lols: 16.9
00:03:52 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*9(>([+])*5)*20
00:03:55 <EgoBot> Score for leonid__lols: 30.5
00:04:01 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*10(>([+])*6)*20
00:04:03 <EgoBot> Score for leonid__lols: 36.3
00:04:06 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*10(>([+])*4)*20
00:04:09 <EgoBot> Score for leonid__lols: 7.8
00:04:25 <AnMaster> ais523, with the polarity thing it would be possible
00:04:29 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*10(>([+])*9)*20
00:04:32 <EgoBot> Score for leonid__lols: 23.5
00:04:36 <EgoBot> Score for KingOfKarlsruhe_king: 18.1
00:04:44 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*11(>([+])*10)*20
00:04:47 <EgoBot> Score for leonid__lols: 20.5
00:04:52 <ehird> ais523: how would you handle looping checking the value at the end of the turn?
00:04:55 <ehird> sounds like it'd be a bit sticky
00:05:16 <EgoBot> Score for KingOfKarlsruhe_king: 4.2
00:05:54 <ehird> ais523: as in, [] works
00:05:58 <ehird> = ] checks value at end of turn
00:06:01 <AnMaster> a bit boring with only two warriors at once
00:06:11 <ais523> ehird: hmm, I'm not sure
00:06:23 <ehird> AnMaster: more than two warriors at once sounds fun
00:06:33 <AnMaster> ehird, not sure how to implement it though
00:06:33 <ehird> but where would the flags go?
00:06:35 <ehird> you'd need an N-d array
00:06:45 <ehird> which, though it would be fun, sounds very scary
00:06:49 <ehird> nescience: that's just 2D
00:06:53 <ehird> you'd need number-of-warriors-D
00:07:03 <ehird> so that the flags could be at the end of them
00:07:05 <ehird> AnMaster: I did that
00:07:06 <Deewiant> Each program in its own corner
00:07:13 <Deewiant> They run simultaneously in both directions
00:07:17 <ehird> AnMaster: /old_hd/
00:07:36 <AnMaster> ehird, can you copy it from the old hd?
00:07:38 <Deewiant> Although I guess that you'd have to run it for the different orientations
00:07:46 <ehird> AnMaster: The interp had a bug of some sort that I didn't find
00:07:51 <ehird> I can easily rewrite it
00:08:04 <Deewiant> Since A might be killed by B before it can kill C, but if A isn't next to B it'd beat C
00:08:05 <ehird> AnMaster: Basically, it's befunge-93, but P is p on the enemy's board, G is g on the enemy's board.
00:08:07 <ehird> Hitting @ makes you lose.
00:08:24 <ehird> AnMaster: Oh, I think I may have added something to track the enemy's IP
00:08:31 <ehird> And what did you mean?
00:08:32 * pikhq discovered ~/pebble2 today. Good idea.
00:08:42 <ehird> AnMaster: That'd cripple a lot of things.
00:09:07 <AnMaster> ehird, it would make it different yes
00:09:40 <AnMaster> you have one program in each corner
00:09:48 <ehird> AnMaster: but BF has a cost to move from one place to another
00:09:48 <AnMaster> for each program it is rotated 90 degrees
00:09:50 -!- Sgeo has quit (Connection timed out).
00:09:55 <ehird> with befunge, you can access any cell of the board instantly
00:10:00 <AnMaster> so the program sees itself in the top corner
00:10:34 <AnMaster> you can access the closest 4x4 or something
00:10:51 <AnMaster> but other ones would need a few more cycles
00:10:59 <ais523> AnMaster: it's worth remembering that values above 16 take multiple cycles to represent in Befunge
00:11:05 <ais523> so simply make P and G relative to the current pointer
00:11:09 <ais523> and you get all that for free
00:11:13 <ehird> AnMaster: it needs to have linear increases as distance increases
00:11:23 <ehird> (it only increases once)
00:11:51 <AnMaster> ais523, what about making the VALUE relative then?
00:12:16 <AnMaster> so P added/substracted a valuue
00:12:37 <ehird> ahh, this code is very pretty
00:12:53 * ehird pats himself on the back for a good refactoring job.
00:12:58 * ehird continues w/ interpreter loop
00:13:22 <ehird> ais523: in [>[-]+] vs [>[+]-], it's always a draw, right?
00:13:45 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*4(>)*6(>([+])*10)*20
00:13:49 <EgoBot> Score for leonid__lols: 24.4
00:14:06 <ais523> ehird: yes, I think a program always draws with the polarity-flipped version of itself
00:14:07 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*4(>)*6(>([+])*5)*20
00:14:09 <EgoBot> Score for leonid__lols: 24.9
00:14:14 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*4(>)*3(>([+])*5)*20
00:14:16 <EgoBot> Score for leonid__lols: 21.3
00:14:28 <ehird> ais523: got a just-as-simple other warrior to pit it against as a test?
00:14:35 <ehird> as in, you could cycle-trace it in your sleep
00:14:58 <ais523> >>>>>>>>>((+)*128.>)*21
00:15:19 <ehird> ais523: and you could cycle-trace it without bashing on your keyboard :-)
00:15:28 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*4(>)*3(>([-[+]])*5)*20
00:15:30 <EgoBot> Score for leonid__lols: 24.7
00:15:38 <ehird> preferably something that doesn't make you think "let's use an abbreviation"; I haven't added them yet
00:15:45 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*10(>([-[+]])*5)*20
00:15:48 <EgoBot> Score for leonid__lols: 27.7
00:16:05 <leonid_> !bfjoust lols ((-)*10>(+)*10>)*10(>([-[+]])*5)*20
00:16:08 <EgoBot> Score for leonid__lols: 27.1
00:16:29 <leonid_> !bfjoust lols (->+>)*10(>([-[+]])*5)*20
00:16:32 <EgoBot> Score for leonid__lols: 20.2
00:16:45 <ehird> ais523: err, pitting that against [>[-]+] isn't likely to do much good, is it?
00:16:47 <ehird> it'll always beat it
00:16:49 -!- GregorR-L has quit (Remote closed the connection).
00:16:58 <ais523> ehird: what specifically do you want?
00:17:11 <ehird> ais523: just a super-trivial program that's worthy to pit against [>[-]+] in my tests
00:17:15 <ais523> two programs where sometimes one wins, and sometimes the other wins?
00:17:36 <ehird> just two programs that don't trivially beat each other
00:17:42 <ais523> >>>>>>>>>>>>>>>[>[-]+]
00:17:44 <ehird> e.g., a defense program may always beat an attack one
00:17:46 <ehird> but it isn't super-obvious
00:18:23 <ais523> and I think it beats /something/
00:18:30 <ehird> ais523: >[]? that terminates immediately, for certain
00:18:37 <ehird> the opponent can't reach there soon enough to do anything to it
00:18:48 <ais523> it was meant to be a simple tripwire program
00:18:51 <ehird> you should submit it
00:18:56 <ais523> with an awful-but-might-work defence after the tripwire
00:19:09 <ais523> !bfjoust stupid_tripwire >+[]<[-]
00:19:14 <EgoBot> Score for ais523_stupid_tripwire: 20.4
00:19:14 <EgoBot> Score for leonid__lols: 18.1
00:19:18 <ehird> !bfjoust less_stupid_tripwire >+[]<[+]
00:19:20 <leonid_> !bfjoust lols ([]+)*100000
00:19:21 <EgoBot> Score for ehird_less_stupid_tripwire: 19.0
00:19:23 <EgoBot> Score for leonid__lols: 18.1
00:19:25 <ehird> (fights against [-] which is more common than [+])
00:19:35 <ais523> ehird: err, mine was designed to fight against [-]
00:19:47 <ais523> if it cancels out, you're going to get a draw
00:19:58 <ehird> ais523: unfortunately, won't work
00:20:02 <leonid_> !bfjoust lols ([]+)*100(>[+])*20
00:20:02 <ais523> if they go in the same direction, and you're out of sync, you may win
00:20:04 <EgoBot> Score for leonid__lols: 18.1
00:20:09 <ais523> you have to be out of sync for that to work, though
00:20:15 <ais523> so I will make it out of sync
00:20:16 -!- GregorR-L has joined.
00:20:20 <ais523> !bfjoust tripwire >+[]<[--]
00:20:23 <EgoBot> Score for ais523_tripwire: 13.4
00:20:27 <ais523> heh, it did even worse
00:20:32 <ehird> ins_t *a = parse("[>[-]+]", "attack");
00:20:32 <ehird> ins_t *b = parse(">+[]<[-]", "tripwire");
00:20:43 <ehird> !bfjoust primewire >+[]<[.-]
00:20:45 <EgoBot> Score for ehird_primewire: 17.6
00:20:49 <ehird> !bfjoust primewire >+[]<[.-]
00:20:52 <EgoBot> Score for ehird_primewire: 17.6
00:20:55 <nescience> won't synch with anything but another plus-wait-wait
00:21:08 <leonid_> !bfjoust lols ([.]+)*10000
00:21:10 <EgoBot> Score for leonid__lols: 18.1
00:21:13 <ehird> ais523: stupid_tripwire beats vibration
00:21:20 <ehird> 00:19 ais523: !bfjoust stupid_tripwire >+[]<[-]
00:21:24 <leonid_> !bfjoust lols ([+-]+)*10000
00:21:26 <EgoBot> Score for leonid__lols: 29.5
00:21:32 <leonid_> !bfjoust lols ([+-]+)*100000
00:21:35 <EgoBot> Score for leonid__lols: 27.4
00:21:39 <ais523> ehird: there must be a bug in vibration
00:21:40 <leonid_> !bfjoust lols ([+-]+)*1000
00:21:41 <ais523> or maybe in the interp
00:21:42 <EgoBot> Score for leonid__lols: 27.4
00:21:49 <EgoBot> Score for leonid__lols: 25.1
00:21:49 <ais523> I suspect a double-timeout causes vibration to lose
00:21:55 <leonid_> !bfjoust lols ([+-+-]+)*10000
00:21:59 <EgoBot> Score for leonid__lols: 25.7
00:22:03 <leonid_> !bfjoust lols ([+-]-)*10000
00:22:05 <ais523> maybe because its flag ends up at 0 at the end of the program?
00:22:06 <EgoBot> Score for leonid__lols: 21.0
00:22:12 <leonid_> !bfjoust lols ([++--]+)*10000
00:22:15 <EgoBot> Score for leonid__lols: 30.9
00:22:19 <leonid_> !bfjoust lols ([+++---]+)*10000
00:22:22 <EgoBot> Score for leonid__lols: 24.3
00:22:27 <leonid_> !bfjoust lols ([+++++-----]+)*10000
00:22:30 <EgoBot> Score for leonid__lols: 23.2
00:22:45 <leonid_> !bfjoust lols ([++--]-)*10000
00:22:48 <EgoBot> Score for leonid__lols: 30.9
00:23:12 <ais523> !bfjoust vibration_fool_faster >>>++++<----<++++<(-)*127(-+)*5000[>[-(.)*6]]
00:23:16 <EgoBot> Score for ais523_vibration_fool_faster: 39.5
00:23:32 <ais523> heh, exact draw with vibration_fool
00:23:42 <ais523> I know how to massively improve that
00:23:46 <ais523> !bfjoust vibration_fool_faster >>>++++<----<++++<(-)*127(-+)*5000[>[-(.)*6]+]
00:23:49 <EgoBot> Score for ais523_vibration_fool_faster: 41.9
00:24:07 <ais523> heh, now the defence programs are eating it for lunch
00:24:14 <ais523> !bfjoust vibration_fool_faster >>>++++<----<++++<(-)*127(-+)*5000[>[-(.)*256]+]
00:24:17 <EgoBot> Score for ais523_vibration_fool_faster: 35.7
00:24:18 <ehird> ais523: do you think it'd be possible for a program to detect its opponent out of a range of, say, 5 strategies, then do one it knows to beat it?
00:24:26 <ais523> !bfjoust vibration_fool_faster >>>++++<----<++++<(-)*127(-+)*5000[>[-..-.]+]
00:24:26 <ehird> just a complex checker thingy, then hardcoded strategies to jump to
00:24:29 <EgoBot> Score for ais523_vibration_fool_faster: 59.3
00:24:32 <ais523> ehird: that's how defence5 worked
00:24:41 <ehird> ais523: it's *defend5
00:24:44 <ehird> and it's "defense"
00:24:53 <ais523> except, I think the word is defence
00:24:58 <ais523> !bfjoust vibration_fool_faster >>>++++<----<++++<(-)*127(-+)*5000[>[---]+]
00:25:01 <EgoBot> Score for ais523_vibration_fool_faster: 67.9
00:25:07 <ehird> Also, American English has kept the Anglo-French spelling for defense and offense, which are usually defence and offence in British English
00:25:15 <ais523> thanks impomatic for the [---] counter-defence trick!
00:25:16 <ehird> defense sounds nicer, and fits with "defensive"
00:25:26 <ais523> also, 129 is divisible by 3
00:25:28 <leonid_> !bfjoust lols ([---]-)*10000
00:25:30 <EgoBot> Score for leonid__lols: 4.7
00:25:42 <ehird> ais523: try ------
00:25:45 <ehird> it might do it faster
00:25:46 <ais523> which means that it's pretty fast at beating the defensives
00:25:57 <ais523> and doesn't divide into 129 either
00:25:59 <leonid_> !bfjoust lols ([--]-)*10000
00:26:01 <EgoBot> Score for leonid__lols: 8.9
00:26:05 <leonid_> !bfjoust lols ([--++]-)*10000
00:26:07 <EgoBot> Score for leonid__lols: 36.5
00:26:10 <ehird> ais523: there's only one way to solve this
00:26:21 <leonid_> !bfjoust lols ([---+++]-)*10000
00:26:24 <EgoBot> Score for leonid__lols: 26.9
00:26:27 <leonid_> !bfjoust lols ([---+++]--)*10000
00:26:27 <ais523> I don't mind you submitting your own ripoff
00:26:30 <AnMaster> can you stop spamming those variants of vibration. Isn't it enough to have one
00:26:30 <EgoBot> Score for leonid__lols: 33.7
00:26:43 <ais523> AnMaster: well, they do work different ways
00:26:46 <ais523> vibration is pure defence
00:26:49 <ais523> vibration_fool_faster isn't
00:26:51 <AnMaster> ais523, sure. But the faster one?
00:27:02 <AnMaster> ais523, what is the diff between ais523_vibration_fool ais523_vibration_fool_faster
00:27:06 <ais523> and fool_faster and fool use rather different attack strategies
00:27:13 <ehird> AnMaster: Hyyyyyyyyypocrite.
00:27:16 <ais523> fool is a very slow attack strategy (deliberate, to fool defence programs into suiciding)
00:27:24 <ais523> fool_faster is a rather fast counter-defence attack strategy
00:27:29 <AnMaster> ehird, I'm learned from you :P
00:27:31 <ais523> it won't beat attack programs, but that's what the vibration was for
00:27:36 <AnMaster> ehird, you were the first hypocrite
00:27:36 <ehird> 00:25 ais523: and doesn't divide into 129 either ← what's this supposed to mean?
00:27:41 <ehird> AnMaster: different strategies deserve different programs
00:27:48 <ais523> ehird: the opponent's flag starts at 128
00:27:52 <ehird> ais523: 3 mod 129 == 3
00:27:57 <ehird> so 3 doesn't divide by 129
00:28:05 <AnMaster> ehird, that was what mine was all about tooo
00:28:06 <ehird> do you mean 129 mod x
00:28:08 <ais523> because the loop ends >+, the flag will end at 129
00:28:18 <ais523> actually, I've thought up another improvement
00:28:26 <ais523> !bfjoust vibration_fool_faster >>>++++<----<++++<(-)*127(-+)*5000[[[>[---]+]+]+]
00:28:29 <EgoBot> Score for ais523_vibration_fool_faster: 73.4
00:28:31 <ehird> AnMaster: instead of ---, try (-)*43
00:28:37 <ehird> 129 mod 43 == 0, and it's prime
00:28:49 <ehird> 3 and 43 are the only two primes in the first 1,000,000 primes that satisfy that :-)
00:28:54 <ais523> that prevents it stalling to decoys with the value -1
00:28:57 <ais523> which are rather common
00:28:59 <ehird> In[11]:= Select[Prime /@ Range[1000000], Mod[129, #] == 0 &]
00:29:26 <ais523> ehird: that is the sort of thing Mathematica is good at
00:29:26 <ehird> !bfjoust vibration_fool_fasting_because_it_is_lent_mathematica_edition >>>++++<----<++++<(-)*127(-+)*5000[[[>[(-)*43]+]+]+]
00:29:29 <EgoBot> Score for ehird_vibration_fool_fasting_because_it_is_lent_mathematica_edition: 61.8
00:29:44 <ehird> It doesn't do terribly, at leat.
00:29:54 <ehird> !bfjoust ehird_vibration_fool_fasting_because_it_is_lent_mathematica_edition <
00:29:57 <EgoBot> Score for ehird_ehird_vibration_fool_fasting_because_it_is_lent_mathematica_edition: 0.0
00:30:07 <ehird> !bfjoust vibration_fool_fasting_because_it_is_lent_mathematica_edition <
00:30:09 <EgoBot> Score for ehird_vibration_fool_fasting_because_it_is_lent_mathematica_edition: 0.0
00:30:21 <ais523> the problem there is that the 43 is sufficiently slow that it may be beaten by fast tripwire programs
00:30:26 <ais523> and there's probably one of those on the hill by now
00:30:31 <nescience> i had it in mind to do something like that
00:30:38 <ehird> i could probably get mathematica to tell me what a good way to decrease a cell is
00:30:41 <ehird> but I'd have to implement bf joust in it
00:30:47 <pikhq> !bfjoust do_nothing >
00:30:50 <EgoBot> Score for pikhq_do_nothing: 17.5
00:30:53 <ehird> mathematica needs a lot better interface with the outside world
00:30:58 <ehird> otherwise it's just too much rewriting
00:31:13 <nescience> oh great, now we have 5 versions of vibration instead of 5 versions of sit-and-wait
00:31:18 * pikhq observes that suicide isn't painless.
00:31:35 <ehird> nescience: stop being a malcontent, it's only three versions
00:31:41 <ehird> i agree fool/fool_faster is silly
00:31:51 <EgoBot> Score for leonid__lols: 18.6
00:31:53 <nescience> scuse me, i thought i counted 5, but its only 4
00:31:58 <ais523> I'll delete tripwire_fool if you like
00:32:00 <ais523> as it's a failed strategy
00:32:04 <ehird> nescience: I set mine to <
00:32:08 <ehird> so it doesn't count
00:32:13 <ehird> as it'll be knocked off really soon
00:32:24 <AnMaster> myndzi_slowrush still leads... hm
00:32:50 <EgoBot> Score for MizardX_mzx_fool: 8.4
00:33:00 <ehird> !bfjoust i_keelst_thou (>)*9((-)*128[-]>)*21
00:33:01 <ais523> nescience: it beats slowrush
00:33:02 <EgoBot> Score for ehird_i_keelst_thou: 42.5
00:33:05 <ais523> in the individual matchup
00:33:21 <ehird> beats maglev and vibration_fool and stuff
00:33:29 <ehird> !bfjoust i_keelst_thou (>)*11((-)*128[-]>)*21
00:33:31 <nescience> though slowrush isn't very defensive, i was actually really surprised it did so well
00:33:31 <EgoBot> Score for ehird_i_keelst_thou: 43.8
00:33:35 <ehird> !bfjoust i_keelst_thou (>)*17((-)*128[-]>)*21
00:33:38 <EgoBot> Score for ehird_i_keelst_thou: 40.0
00:33:41 <nescience> i woke up with this idea and hacked it up, then tweaked it a couple times and it was like whoa!
00:33:41 <ehird> !bfjoust i_keelst_thou (>)*15((-)*128[-]>)*21
00:33:44 <EgoBot> Score for ehird_i_keelst_thou: 41.6
00:33:51 <ehird> !bfjoust i_keelst_thou (>)*13((-)*128[-]>)*21
00:33:54 <EgoBot> Score for ehird_i_keelst_thou: 40.0
00:33:59 <ehird> !bfjoust i_keelst_thou (>)*12((-)*128[-]>)*21
00:34:01 <ais523> nescience: I suspect it's because defence caught on so much that everyone started writing counter-defence
00:34:02 <EgoBot> Score for ehird_i_keelst_thou: 40.1
00:34:04 <ais523> it's all about the metagame
00:34:08 <ehird> !bfjoust i_keelst_thou (>)*9((-)*128[-]>)*21
00:34:10 <EgoBot> Score for ehird_i_keelst_thou: 41.3
00:34:12 <AnMaster> I'm happy were have fewer of the huge programs now
00:34:31 <AnMaster> the shorter onces are less messy, easier to understand
00:34:44 <lament> what does the score mean?
00:34:47 <MizardX> !bfjoust mzx_fool (>)*128[-]
00:34:50 <EgoBot> Score for MizardX_mzx_fool: 0.0
00:34:54 <ais523> lament: you get a high score by beating lots of good programs
00:35:04 <ehird> ais523: where good program = high score
00:35:10 <ais523> the opponent would have to suicide very quickly to lose to that
00:35:13 <ehird> so if you keep recalculating...
00:35:15 <EgoBot> Score for lament_what: 7.3
00:35:17 <ais523> ehird: good program = beat lots of things
00:35:18 <MizardX> !bfjoust mzx_fool (>)*127[-]
00:35:19 <ais523> to avoid an infinite regress
00:35:21 <EgoBot> Score for MizardX_mzx_fool: 0.0
00:35:26 <ais523> at least, that's how I think GregorR's system works
00:35:30 <lament> why is the score for [-] 7.3
00:35:32 <ehird> lament: "you did badly w/ other programs"
00:35:34 <EgoBot> Score for leonid__lols: 18.2
00:35:35 <ehird> lament: see http://codu.org/eso/bfjoust/report.txt
00:35:51 <ehird> lament: note that [-] goes [-]-]-]-]
00:35:55 <ais523> ehird: i_keelst_thou beat vibration_fool_faster...
00:35:55 <ehird> so (-)*128 is more effective
00:36:05 <nescience> you get points equal to the wins(+ties?) of programs you beat
00:36:10 <leonid_> !bfjoust lols >([>][+])*20
00:36:12 <nescience> and 1/4 points equal to programs you tie
00:36:13 <EgoBot> Score for leonid__lols: 16.6
00:36:14 <EgoBot> Score for lament_what: 0.0
00:36:14 <ehird> ais523: it beat all vibrations
00:36:20 <ais523> I'm not sure if vibration_fool_faster's defence portion is all that good against everything
00:36:23 <ais523> it was rather experimental
00:36:26 <ehird> ais523: and because it doesn't loop
00:36:30 <leonid_> !bfjoust lols >([>][-])*20
00:36:32 <nescience> so if you don't beat a bunch of programs, but those programs beat everything else, you can still get a lot of points
00:36:32 <EgoBot> Score for leonid__lols: 20.3
00:36:32 <ehird> it decrements 128 before even thinking about looping
00:36:33 <ais523> so it seems you have a counter-vibration attack strategy
00:36:43 <lament> nescience: oh, so the score for a program that doesn't attempt to win is proportional to the number of suiciders
00:36:44 <ehird> so your petty messing about is dutifully ignored
00:36:44 <leonid_> !bfjoust lols (>)*9([>][-])*20
00:36:47 <EgoBot> Score for leonid__lols: 15.3
00:37:02 <leonid_> !bfjoust lols >([>>][-])*20
00:37:04 <EgoBot> Score for leonid__lols: 16.1
00:37:14 <nescience> ehird: ha, good to know that works, it was in my mental queue too :P
00:37:21 <ais523> !bfjoust vff_experimental >>>++++<----<++++<(-)*127(--++)*2500[[[>[---]+]+]+]
00:37:23 <nescience> it's like everything changes drastically though each time i look
00:37:24 <EgoBot> Score for ais523_vff_experimental: 63.5
00:37:34 <ais523> heh, exactly the same score
00:37:37 <ais523> !bfjoust vff_experimental <
00:37:40 <EgoBot> Score for ais523_vff_experimental: 0.0
00:37:42 <GregorR-L> http://codu.org/eso/bfjoust/SCORES // the scores, as people were asking
00:37:51 <nescience> no coding quickies for me till after work
00:38:04 <EgoBot> Score for lament_hello: 7.8
00:38:35 <ehird> The infrastructure is copied.
00:38:37 <ehird> 11 | + - 0 0 0 - + + + + + - - - - 0 + - - | 41.3 | -1 | ehird_i_keelst_thou.bfjoust
00:38:39 <ehird> [for my reference]
00:38:41 <GregorR-L> AnMaster: Oh, I copied that text from FYB :P
00:39:26 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]>)*21
00:39:28 <EgoBot> Score for ehird_i_keelst_thou: 53.6
00:39:45 <ehird> Up there with the big guys.
00:39:59 <ais523> ehird: it's like isthata128, only with a [-] afterwards
00:40:04 <EgoBot> Score for leonid__lols: 24.0
00:40:05 <ais523> so it does better against the defence programs
00:40:09 <ehird> ais523: well, the basic strategy is very simple
00:40:12 <ehird> I thought it up independently
00:40:24 <ais523> just interesting that yours does very well, and mine did terribly
00:40:28 <ais523> despite them working much the same way
00:40:34 <ehird> 11 | + - 0 + 0 - + + + + + - 0 0 + 0 + 0 - - | 52.6 | 4 | ehird_i_keelst_thou.bfjoust
00:40:47 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-[++[---[++++[-----]]]]]>)*21
00:40:47 <leonid_> !bfjoust lols (->[+][+])*20
00:40:50 <EgoBot> Score for leonid__lols: 18.2
00:40:51 <EgoBot> Score for ehird_i_keelst_thou: 48.5
00:40:56 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-[++[---[++++]]]]>)*21
00:40:58 <EgoBot> Score for ehird_i_keelst_thou: 17.1
00:41:02 <leonid_> !bfjoust lols (->[+-+])*20
00:41:05 <EgoBot> Score for leonid__lols: 13.6
00:41:10 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-[++[---]]]>)*21
00:41:13 <EgoBot> Score for ehird_i_keelst_thou: 48.9
00:41:16 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-[++]]>)*21
00:41:18 <EgoBot> Score for ehird_i_keelst_thou: 31.4
00:41:22 <ehird> Okay, this is a failed strategery.
00:41:28 <lament> !bfjoust what >+[>[(-)*128]>+]
00:41:31 <EgoBot> Score for lament_what: 22.2
00:41:37 <ais523> ehird: it no longer beats the vibrators
00:41:39 <ais523> if you do it like that
00:41:42 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]->(-)*128[-]+>)*21
00:41:45 <EgoBot> Score for ehird_i_keelst_thou: 58.5
00:41:55 <ehird> Setting up a bunch of decoys worked. :)
00:41:57 <lament> !bfjoust what >+[>[(-)*128]>++]
00:42:00 <EgoBot> Score for lament_what: 25.1
00:42:01 <ais523> ehird: it usually does
00:42:03 <lament> !bfjoust what >+[>[(-)*128]>+++]
00:42:06 <EgoBot> Score for lament_what: 20.7
00:42:11 <ais523> even though everything has anti-decoy tricks nowadays
00:42:17 <EgoBot> Score for leonid__lols: 10.8
00:42:23 <lament> decoys are slow to set up
00:42:29 <EgoBot> Score for leonid__lols: 22.9
00:42:48 <EgoBot> Score for leonid__lols: 16.1
00:42:57 <ais523> lament: not ridiculously slow
00:43:03 <ais523> and they slow the opponent down more
00:43:06 <lament> what does - do on an empty tape?
00:43:13 <ais523> lament: - on 0 changes it to 255
00:43:15 <ehird> lament: empty cell. 255
00:43:17 <ehird> current i_keelst_thou: 5 losses, 3 draws, 12 wins
00:43:22 <lament> !bfjoust what >+[>[(-)*128]>-]
00:43:25 <EgoBot> Score for lament_what: 19.9
00:43:35 <lament> !bfjoust what >+[>[(-)*128]>+]
00:43:36 <ehird> I do badly w/ impomatics' programs
00:43:38 <EgoBot> Score for lament_what: 20.4
00:43:43 <ehird> I don't think I beat any of his
00:43:52 <lament> why does my program with + beat my program with - ?
00:44:08 <ehird> lament: random tape length
00:44:12 <ehird> the change is small enough to be irrelevant
00:44:16 <ehird> myyyyy interp will fix that :p:p:p
00:44:17 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:44:19 <EgoBot> Score for ehird_i_keelst_thou: 58.9
00:44:24 <AnMaster> !bfjoust mad_changer5 >+>->+>->+<<<(+)*200000
00:44:27 <lament> !bfjoust what >+[>[(-)*128]>-]
00:44:27 <EgoBot> Score for AnMaster_mad_changer5: 19.8
00:44:29 <ehird> tiny increase, so I'll leave it
00:44:30 <EgoBot> Score for lament_what: 21.8
00:44:32 <AnMaster> !bfjoust mad_changer5 >+>->+>->+<<<(+-+)*200000
00:44:35 <EgoBot> Score for AnMaster_mad_changer5: 20.8
00:44:35 <ehird> ais523: i'm third!
00:44:39 <AnMaster> !bfjoust mad_changer5 >+>->+>->+<<<(+-++)*200000
00:44:43 <EgoBot> Score for AnMaster_mad_changer5: 29.6
00:44:53 <EgoBot> Score for leonid__lols: 20.4
00:44:56 <ehird> 00:43 ehird: current i_keelst_thou: 5 losses, 3 draws, 12 wins ← this is 4 draws now
00:45:01 <ehird> but it does much the same
00:45:09 <AnMaster> !bfjoust mad_changer5 >+>->+>>->+<<<<(+-++)*200000
00:45:10 <ehird> I lose against slow rush
00:45:12 <ehird> wonder if I can fix that
00:45:12 <EgoBot> Score for AnMaster_mad_changer5: 25.3
00:45:15 <AnMaster> !bfjoust mad_changer5 >+>->+>->+<<<(+-++)*200000
00:45:17 <EgoBot> Score for AnMaster_mad_changer5: 29.7
00:45:28 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(+)*128[+]->)*21
00:45:31 <EgoBot> Score for ehird_i_keelst_thou: 36.6
00:45:39 <EgoBot> Score for leonid__lols: 27.6
00:45:40 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[+]+>(+)*128[-]->)*21
00:45:42 <EgoBot> Score for ehird_i_keelst_thou: 13.5
00:45:46 <EgoBot> Score for leonid__lols: 12.5
00:45:51 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:45:51 <EgoBot> Score for leonid__lols: 21.7
00:45:54 <ais523> the programs that do well against vff are nested-loop programs and no-loop programs
00:45:54 <EgoBot> Score for ehird_i_keelst_thou: 58.2
00:45:54 <lament> AnMaster: i don't get it, how does that kill anything?
00:46:07 <ais523> lament: tricking them off the end of the tape
00:46:18 <leonid_> !bfjoust lols (>)*9(->[+])*19
00:46:21 <EgoBot> Score for leonid__lols: 32.7
00:46:22 <ehird> ais523: I have 6 draws now.
00:46:25 <leonid_> !bfjoust lols (>)*9(+>[+])*19
00:46:25 <ehird> that's increasing worryingly
00:46:28 <EgoBot> Score for leonid__lols: 29.8
00:46:31 <leonid_> !bfjoust lols (>)*9(+>[-])*19
00:46:33 <EgoBot> Score for leonid__lols: 36.7
00:46:33 <ehird> only 4 losses though
00:46:39 <leonid_> !bfjoust lols (>)*9(->[-])*19
00:46:41 <EgoBot> Score for AnMaster_no_decoy: 20.4
00:46:42 <EgoBot> Score for leonid__lols: 33.4
00:46:43 <ehird> rushpolarity beat me
00:46:45 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:46:46 <leonid_> !bfjoust lols (>)*9(+>[-])*21
00:46:48 <EgoBot> Score for ehird_i_keelst_thou: 56.6
00:46:49 <EgoBot> Score for leonid__lols: 39.3
00:46:53 <ais523> AnMaster: I find that pure defence can often be improved by putting an attack strategy there after it
00:46:54 <leonid_> !bfjoust lols (>)*9(+>[-])*30
00:46:56 <EgoBot> Score for leonid__lols: 27.2
00:46:58 <EgoBot> Score for AnMaster_no_decoy: 16.2
00:47:00 <leonid_> !bfjoust lols (>)*9(+>[-])*22
00:47:02 <EgoBot> Score for leonid__lols: 26.2
00:47:07 <leonid_> !bfjoust lols (>)*9(+>[-])*20
00:47:07 <EgoBot> Score for AnMaster_no_decoy: 17.8
00:47:08 <ais523> that's designed to work against tripwire defenders and other programs likely to be slow
00:47:09 <EgoBot> Score for leonid__lols: 49.0
00:47:11 <EgoBot> Score for AnMaster_no_decoy: 16.3
00:47:12 -!- psygnisfive has joined.
00:47:15 <EgoBot> Score for AnMaster_no_decoy: 19.8
00:47:18 <leonid_> !bfjoust lols (>)*9(+>[-])*20
00:47:18 <ehird> !bfjoust i_keelst_thou -----(>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:47:20 <EgoBot> Score for leonid__lols: 47.6
00:47:21 -!- psygnisf_ has quit (Read error: 104 (Connection reset by peer)).
00:47:22 <EgoBot> Score for ehird_i_keelst_thou: 36.7
00:47:23 <ehird> !bfjoust i_keelst_thou +++++(>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:47:26 <EgoBot> Score for ehird_i_keelst_thou: 30.7
00:47:27 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:47:30 <EgoBot> Score for ehird_i_keelst_thou: 56.3
00:47:39 <leonid_> !bfjoust lols (>)*9(++>[-])*20
00:47:42 <ais523> ehird: I've suddenly realised how well i_keelst_though would do against all the defend6-alikes
00:47:44 <EgoBot> Score for leonid__lols: 12.3
00:47:48 <AnMaster> ais523, maybe. But it is too long then
00:47:51 <ais523> it completely breaks the assumptions they make
00:47:51 <leonid_> !bfjoust lols (-)*64(>)*9(+>[-])*20
00:47:52 <psygnisfive> DOESNT ANYONE WANT SOME OF MY HOMEMADE BUTTER?!
00:47:54 <EgoBot> Score for leonid__lols: 19.5
00:47:54 <ehird> ais523: it barely even looks at you
00:47:57 <ehird> psygnisfive: yes please
00:48:03 <ehird> ais523: that's basically the idea
00:48:06 <leonid_> !bfjoust lols (>)*9(+>[+])*20
00:48:08 <EgoBot> Score for leonid__lols: 30.8
00:48:10 <ehird> ais523: don't rely on anything the opponent can manipulate unless you really have to
00:48:17 <leonid_> !bfjoust lols (>)*9(+>[-+-])*20
00:48:20 <EgoBot> Score for leonid__lols: 52.4
00:48:21 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[---]+>(-)*128[+++]->)*21
00:48:24 <EgoBot> Score for ehird_i_keelst_thou: 56.2
00:48:24 <leonid_> !bfjoust lols (>)*9(+>[-+-+-])*20
00:48:27 <EgoBot> Score for leonid__lols: 38.5
00:48:28 <ais523> ehird: all defence programs rely on things the opponent can manipulate...
00:48:33 <leonid_> !bfjoust lols (>)*9(+>[-+])*20
00:48:42 <ehird> ais523: what I meant, was
00:48:42 <EgoBot> Score for leonid__lols: 13.9
00:48:43 <ais523> still, I love the way I'm second with a program that deliberately zeros its own flag
00:48:53 <ehird> ais523: don't listen to what you're opponent's telling you. because they'll wind you up
00:48:58 <leonid_> !bfjoust lols (>)*9(+>[(-+)*10-])*20
00:49:01 <EgoBot> Score for leonid__lols: 46.5
00:49:06 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[---]+>(-)*128[+++]->)*21
00:49:08 <leonid_> !bfjoust lols (>)*9(+>[(-+)*4-])*20
00:49:09 <EgoBot> Score for ehird_i_keelst_thou: 61.5
00:49:10 <EgoBot> Score for leonid__lols: 26.5
00:49:13 <ehird> (just seeing if i'm getting sample variance here)
00:49:17 <leonid_> !bfjoust lols (>)*9(+>[-+-])*21
00:49:20 <EgoBot> Score for leonid__lols: 43.2
00:49:21 <lament> Wouldn't a looping memory tape be more fun?
00:49:22 <leonid_> !bfjoust lols (>)*9(+>[-+-])*20
00:49:24 <ehird> !bfjoust i_keelst_thou (+>->)*4((-)*128[---]+>(-)*128[+++]->)*21
00:49:25 <EgoBot> Score for leonid__lols: 50.4
00:49:27 <EgoBot> Score for ehird_i_keelst_thou: 50.1
00:49:29 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[---]+>(-)*128[+++]->)*21
00:49:31 <EgoBot> Score for ehird_i_keelst_thou: 56.2
00:49:32 <GregorR-L> lament: No, you could just do <[-]
00:49:36 <ais523> tricking opponents off the end is the whole point
00:49:36 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[---]+>(-)*128[+++]->)*21
00:49:39 <ais523> as is hiding your flag
00:49:39 <EgoBot> Score for ehird_i_keelst_thou: 56.2
00:49:46 <ehird> hmm I dropped a bit.
00:49:51 <ehird> 11 | + + - + - + + + + + + - + - + - - - - | 56.2 | 3 | ehird_i_keelst_thou.bfjoust
00:49:52 <lament> ais523: but this way, the optimal program relies too much on the fact that the field is between 10 and 30 cells. Change the limits, and a different program will be optimal.
00:50:06 <lament> ais523: that's not pretty!
00:50:08 <ais523> lament: the limits were chosen to make the game interesting, though
00:50:17 <ais523> they used to just be "random very large number"
00:50:20 <leonid_> !bfjoust lols +(>)*9(+>[-+-])*20
00:50:23 <EgoBot> Score for leonid__lols: 52.1
00:50:27 <ais523> but that made decoys an overwhelmingly good strategy
00:50:28 <leonid_> !bfjoust lols (>)*9(+>[-+-])*20
00:50:31 <EgoBot> Score for leonid__lols: 50.4
00:50:34 <ais523> keeping them small makes decoys more dangerous
00:50:36 <leonid_> !bfjoust lols ++(>)*9(+>[-+-])*20
00:50:39 <EgoBot> Score for leonid__lols: 41.0
00:50:44 <leonid_> !bfjoust lols +(>)*10(+>[-+-])*20
00:50:46 <EgoBot> Score for leonid__lols: 46.5
00:50:53 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[+++]->)*21
00:50:54 <leonid_> !bfjoust lols +(>)*9(+>[--++-])*20
00:50:55 <EgoBot> Score for ehird_i_keelst_thou: 44.6
00:50:56 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[---]+>(-)*128[+++]->)*21
00:50:57 <EgoBot> Score for leonid__lols: 25.2
00:50:59 <EgoBot> Score for ehird_i_keelst_thou: 58.2
00:51:05 <ehird> ais523: i think my strategy is nearing its optimum
00:51:07 <leonid_> !bfjoust lols +(>)*9(+>[---])*20
00:51:10 <EgoBot> Score for leonid__lols: 29.6
00:51:13 <ehird> !bfjoust i_keelst_thou (>++>--)*4>((-)*128[---]+>(-)*128[+++]->)*21
00:51:16 <EgoBot> Score for ehird_i_keelst_thou: 46.3
00:51:17 <leonid_> !bfjoust lols +(>)*9(+>[--])*20
00:51:19 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[---]+>(-)*128[+++]->)*21
00:51:20 <EgoBot> Score for leonid__lols: 32.9
00:51:22 <EgoBot> Score for ehird_i_keelst_thou: 62.0
00:51:27 <leonid_> !bfjoust lols +(>)*9(+>[-+-])*25
00:51:30 <EgoBot> Score for leonid__lols: 42.7
00:51:33 <ais523> ehird: yep, it's creeping up on vff
00:51:38 <leonid_> !bfjoust lols +(>)*11(+>[-+-])*18
00:51:41 <EgoBot> Score for leonid__lols: 39.3
00:51:50 <leonid_> !bfjoust lols +(>)*9(+>[-+-])*20
00:51:53 <EgoBot> Score for leonid__lols: 52.1
00:51:53 <ehird> ais523: WTF? it doesn't beat you
00:51:55 <ehird> ais523: it used to beat you
00:52:06 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:52:09 <EgoBot> Score for ehird_i_keelst_thou: 60.2
00:52:16 <leonid_> !bfjoust lols +(>)*9(+>[-+-])*20
00:52:18 <ehird> 10 | + + + 0 - + + + + + - + - + - - - + + | 63.2 | 6 | ais523_vibration_fool_faster.bfjoust
00:52:18 <EgoBot> Score for leonid__lols: 47.1
00:52:19 <ehird> 11 | 0 - 0 0 0 - + + + + + + + 0 + + + - - | 60.2 | 6 | ehird_i_keelst_thou.bfjoust
00:52:22 <ehird> ais523: it beats vff.
00:52:31 <ais523> ehird: I'm not surprised
00:52:35 <leonid_> !bfjoust lols +(>)*9(+>[-])*20
00:52:37 <EgoBot> Score for leonid__lols: 31.6
00:52:41 <ais523> foes it beat slowrush?
00:52:43 <leonid_> !bfjoust lols +(>)*9(+>[(-+)*5-])*20
00:52:46 <EgoBot> Score for leonid__lols: 38.2
00:52:49 <leonid_> !bfjoust lols +(>)*9(+>[(-+)*50-])*20
00:52:52 <EgoBot> Score for leonid__lols: 36.7
00:52:53 <ehird> ais523: nope; I don't even know how slowrush works.
00:53:12 <leonid_> !bfjoust lols +(>)*8(+>[-+-])*20
00:53:14 <EgoBot> Score for leonid__lols: 35.5
00:53:19 <lament> !bfjoust (-)*128(+-)*500000
00:53:20 <leonid_> !bfjoust lols +-+(>)*9(+>[-+-])*20
00:53:20 <EgoBot> Use: !bfjoust <program name> <program>
00:53:22 <EgoBot> Score for leonid__lols: 50.4
00:53:27 <lament> !bfjoust dangle (-)*128(+-)*500000
00:53:27 <leonid_> !bfjoust lols +-+-+(>)*9(+>[-+-])*20
00:53:29 <ehird> ais523: how does it work?
00:53:30 <EgoBot> Score for leonid__lols: 43.5
00:53:31 <EgoBot> Score for lament_dangle: 7.4
00:53:37 <ais523> ehird: decoys and attack
00:53:37 <leonid_> !bfjoust lols (+-)*20+(>)*9(+>[-+-])*20
00:53:40 <EgoBot> Score for leonid__lols: 45.7
00:53:43 <ais523> only they're rather large decoys
00:53:45 <leonid_> !bfjoust lols (+-)*20(>)*9(+>[-+-])*20
00:53:46 <lament> !bfjoust dangle (-)*127(+-)*500000
00:53:47 <EgoBot> Score for leonid__lols: 36.8
00:53:49 <EgoBot> Score for lament_dangle: 30.2
00:53:49 <ais523> and the attack has fallbacks to detect defenders
00:53:54 <ais523> and re-attack them a different way
00:53:55 <ehird> ais523: well, decoys don't bother mine, at worst it has to run a few loop iterations
00:53:57 <lament> !bfjoust dangle (-)*127(+-)*50000000
00:53:59 <ais523> in the hope at least one of the attacks will work
00:54:00 <EgoBot> Score for lament_dangle: 22.0
00:54:03 <leonid_> !bfjoust lols --+(>)*9(+>[-+-])*20
00:54:04 <ais523> ehird: and decoys slow you down
00:54:05 <EgoBot> Score for leonid__lols: 35.5
00:54:09 <ais523> so it beats you by attacking faster
00:54:11 <ehird> !bfjoust i_keelst_thou (>+>-)*4>([(-)*128[-]]+>[(-)*128[+]]->)*21
00:54:12 <leonid_> !bfjoust lols .(>)*9(+>[-+-])*20
00:54:14 <EgoBot> Score for ehird_i_keelst_thou: 40.1
00:54:15 <EgoBot> Score for leonid__lols: 21.9
00:54:21 <ehird> ais523: why doesn't that work?
00:54:28 <ehird> ais523: it should only run its attack if it's non-zero
00:54:30 <leonid_> !bfjoust lols +(>)*9(+>>[-+-])*10
00:54:32 <ehird> which should speed it up an awful lot
00:54:33 <EgoBot> Score for leonid__lols: 29.4
00:54:35 <ais523> ehird: more loops mean it's more vulnerable to farmers
00:54:39 <ais523> so you're getting locked in place more
00:54:49 <lament> !bfjoust dangle (-)*127[[+]+]
00:54:52 <EgoBot> Score for lament_dangle: 11.8
00:54:55 <ais523> AnMaster: programs that garble the values near their own flag
00:54:59 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:55:00 <ehird> ok, I have an idea
00:55:01 <EgoBot> Score for ehird_i_keelst_thou: 58.5
00:55:02 <leonid_> !bfjoust lols +(>)*9(+>[-[+]])*20
00:55:05 <EgoBot> Score for leonid__lols: 37.8
00:55:07 <AnMaster> ais523, oh and like madchanger
00:55:10 <leonid_> !bfjoust lols +(>)*9(+>[+[-]])*20
00:55:13 <EgoBot> Score for leonid__lols: 33.3
00:55:26 <leonid_> !bfjoust lols +(>)*9(+++>[-[+-+]])*20
00:55:29 <EgoBot> Score for leonid__lols: 57.5
00:55:38 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*64[(-)*64[-]]+>(+)*64[(+)*64[+]]->)*21
00:55:41 <EgoBot> Score for ehird_i_keelst_thou: 37.9
00:55:46 <leonid_> !bfjoust lols +(>)*9(+++>[-+-[+-+]])*20
00:55:46 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(+)*128[+]->)*21
00:55:49 <EgoBot> Score for ehird_i_keelst_thou: 30.9
00:55:49 <EgoBot> Score for leonid__lols: 41.1
00:55:53 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[-]->)*21
00:55:55 <EgoBot> Score for ehird_i_keelst_thou: 55.1
00:55:56 <leonid_> !bfjoust lols +(>)*9(+>[-[+-+]])*20
00:55:59 <EgoBot> Score for leonid__lols: 44.7
00:56:00 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:56:02 <leonid_> !bfjoust lols +(>)*9(+++++>[-+-[+-+]])*20
00:56:03 <EgoBot> Score for ehird_i_keelst_thou: 54.6
00:56:05 <EgoBot> Score for leonid__lols: 45.9
00:56:07 <leonid_> !bfjoust lols +(>)*9(++++>[-+-[+-+]])*20
00:56:10 <EgoBot> Score for leonid__lols: 39.4
00:56:11 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[-]->)*21
00:56:13 <EgoBot> Score for ehird_i_keelst_thou: 50.8
00:56:15 <leonid_> !bfjoust lols +(>)*9(++>[-+-[+-+]])*20
00:56:17 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[-]->)*21
00:56:18 <EgoBot> Score for leonid__lols: 42.2
00:56:20 <EgoBot> Score for ehird_i_keelst_thou: 50.9
00:56:20 <leonid_> !bfjoust lols +(>)*9(+++>[-+-[+-+]])*20
00:56:22 <lament> !bfjoust dangle (-)*127[-[+]]
00:56:23 <EgoBot> Score for leonid__lols: 35.5
00:56:26 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[-]->)*21
00:56:26 <EgoBot> Score for lament_dangle: 13.2
00:56:29 <EgoBot> Score for ehird_i_keelst_thou: 55.1
00:56:30 <ehird> ais523: I hate the large sample variance.
00:56:30 <leonid_> !bfjoust lols +(>)*9(+++>[-[+-+]])*20
00:56:33 <EgoBot> Score for leonid__lols: 57.4
00:56:36 <leonid_> !bfjoust lols +(>)*9(++>[-[+-+]])*20
00:56:37 <lament> yeah the sample variance is BS
00:56:39 <EgoBot> Score for leonid__lols: 47.2
00:56:41 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:56:44 <EgoBot> Score for ehird_i_keelst_thou: 54.8
00:56:44 <ehird> I dropped waaaaaaay down
00:56:46 <leonid_> !bfjoust lols +(>)*9(++++>[-[+-+]])*20
00:56:48 <EgoBot> Score for leonid__lols: 36.7
00:56:55 <leonid_> !bfjoust lols +-+(>)*9(+++>[-[+-+]])*20
00:56:56 <ais523> ehird: you're writing a hill that fixes that, though, aren't you?
00:56:58 <EgoBot> Score for leonid__lols: 42.0
00:57:02 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:57:02 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
00:57:06 <EgoBot> Score for ehird_i_keelst_thou: 54.3
00:57:06 <EgoBot> Score for leonid__lols: 58.1
00:57:13 <ehird> it should be done tomorrow; I stopped working on it to have fun here
00:57:24 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+-+]])*20
00:57:25 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:57:27 <EgoBot> Score for ehird_i_keelst_thou: 55.0
00:57:28 <EgoBot> Score for leonid__lols: 36.5
00:57:32 <leonid_> !bfjoust lols +(>)*9(+++>[-[+-+-+]])*20
00:57:34 <ehird> guess the opponents are tougher these days
00:57:35 <EgoBot> Score for leonid__lols: 44.9
00:57:39 <leonid_> !bfjoust lols +(>)*9(+++>[-+-[+-+-+]])*20
00:57:42 <EgoBot> Score for leonid__lols: 44.9
00:57:45 <leonid_> !bfjoust lols +(>)*9(+++>[-+-+-[+-+-+]])*20
00:57:47 <ehird> how does lols work?
00:57:48 <EgoBot> Score for leonid__lols: 31.4
00:57:50 <EgoBot> Score for lament_dangle: 0.0
00:57:56 <leonid_> !bfjoust lols +(>)*9(+>[-[+-+-+]])*20
00:57:58 <EgoBot> Score for leonid__lols: 42.7
00:58:02 <leonid_> !bfjoust lols -(>)*9(+>[-[+-+-+]])*20
00:58:05 <EgoBot> Score for leonid__lols: 45.5
00:58:06 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[-]->)*21
00:58:06 <ais523> ehird: a disruptive reducing loop
00:58:10 <EgoBot> Score for ehird_i_keelst_thou: 48.4
00:58:10 <ais523> so it's counter-disruption
00:58:13 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[-]->)*21
00:58:16 <EgoBot> Score for ehird_i_keelst_thou: 48.4
00:58:17 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+-+-+]])*20
00:58:17 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:58:19 <ais523> it's reducing the value in a non-monotonic way
00:58:22 <EgoBot> Score for ehird_i_keelst_thou: 52.8
00:58:22 <EgoBot> Score for leonid__lols: 55.7
00:58:24 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[+]+>(-)*128[+]->)*21
00:58:27 <EgoBot> Score for ehird_i_keelst_thou: 40.1
00:58:29 <ais523> so defence programs that rely on sensible ways to reduce the value get confused
00:58:31 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
00:58:32 <leonid_> !bfjoust lols -(>)*9(+++>[-[(+-)*10+]])*20
00:58:33 <ehird> That is so illogical
00:58:33 <EgoBot> Score for ehird_i_keelst_thou: 57.9
00:58:35 <EgoBot> Score for leonid__lols: 32.9
00:58:36 <ehird> -[-], but then -[+]
00:58:37 <ais523> it'll beat defend6, for instance
00:58:39 <ehird> consistently gets the best scores
00:58:41 <ais523> but lose to pure attackers
00:58:41 <ehird> how is that so, ais523?
00:58:41 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
00:58:44 <EgoBot> Score for leonid__lols: 59.2
00:58:46 <ehird> it makes no sense at all
00:58:53 <ais523> ehird: because it's being slow
00:58:56 <leonid_> why does it get so high score
00:59:02 <ais523> so it beats things which expect it to attack quickly
00:59:06 <ais523> which is most of the hill atm, I expect
00:59:22 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*25
00:59:25 <EgoBot> Score for leonid__lols: 42.2
00:59:28 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*19
00:59:30 <EgoBot> Score for leonid__lols: 33.6
00:59:31 <ehird> ais523: ah, interesting
00:59:32 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*21
00:59:35 <EgoBot> Score for leonid__lols: 39.7
00:59:37 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
00:59:40 <EgoBot> Score for leonid__lols: 59.2
00:59:41 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-](+)*10>(-)*128[+](-)*10>)*21
00:59:43 <EgoBot> Score for ehird_i_keelst_thou: 29.1
00:59:45 <ais523> leonid_: go back to the version which was third on the hill
00:59:49 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-](+)*3>(-)*128[+](-)*3>)*21
00:59:50 <ais523> and use a different name fo rthe others
00:59:52 <EgoBot> Score for ehird_i_keelst_thou: 45.0
00:59:56 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-](+)*2>(-)*128[+](-)*2>)*21
00:59:58 <EgoBot> Score for ehird_i_keelst_thou: 35.5
01:00:03 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
01:00:06 <EgoBot> Score for ehird_i_keelst_thou: 52.5
01:00:07 <ehird> so one is the sweet spot for decosy
01:00:10 <leonid_> i have no idea how my own code works
01:00:17 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->(-)*128[+]>(-)*128[+]>)*21
01:00:19 <EgoBot> Score for ehird_i_keelst_thou: 34.8
01:00:21 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
01:00:24 <EgoBot> Score for ehird_i_keelst_thou: 52.5
01:00:27 <ehird> ais523: heh, every change I make seems to worsen it
01:00:56 <lament> !bfjoust dangle (+)*384000
01:00:56 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*22
01:00:56 <ehird> ais523: do you think i _can_ improve the basic strategery? :-)
01:00:57 * ais523 wonders about evolutionary BF Joust
01:00:59 <EgoBot> Score for leonid__lols: 43.8
01:00:59 <EgoBot> Score for lament_dangle: 23.9
01:01:00 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:01:03 <EgoBot> Score for leonid__lols: 60.0
01:01:07 <ehird> !bfjoust i_keelst_thou (>+>->>)*2>((-)*128[-]+>(-)*128[+]->)*21
01:01:08 <ais523> ehird: I don't know, you might be at risk of overfitting
01:01:09 <EgoBot> Score for ehird_i_keelst_thou: 43.6
01:01:20 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:01:23 <EgoBot> Score for leonid__lols: 59.5
01:01:25 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
01:01:27 <ehird> ais523: overfitting?
01:01:28 <EgoBot> Score for ehird_i_keelst_thou: 54.5
01:01:38 <ais523> ehird: it's what happens if you train a neural network too much
01:01:42 <leonid_> !bfjoust lols -(>)*9(++>[-[+-+]])*20
01:01:44 <ais523> it ends up perfect at describing your test data
01:01:45 <EgoBot> Score for leonid__lols: 45.2
01:01:47 <ais523> and rubbish at anything else
01:01:48 <leonid_> !bfjoust lols -(>)*9(++++>[-[+-+]])*20
01:01:51 <EgoBot> Score for leonid__lols: 43.4
01:01:59 <ehird> ais523: how does that apply to this?
01:02:00 <leonid_> !bfjoust lols -(>)*9(+++>[---[+-+]])*20
01:02:03 <EgoBot> Score for leonid__lols: 39.9
01:02:04 <ehird> AnMaster: because only the test data gets reinforced
01:02:06 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:02:08 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*20
01:02:09 <ais523> ehird: a program that beats all the programs there on the hill, but nothing in general
01:02:09 <EgoBot> Score for leonid__lols: 60.0
01:02:11 <EgoBot> Score for ehird_i_keelst_thou: 35.8
01:02:13 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*22
01:02:16 <EgoBot> Score for ehird_i_keelst_thou: 56.9
01:02:26 <ehird> ais523: going one over the tape length sometimes improves me score.
01:02:30 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*22
01:02:33 <EgoBot> Score for ehird_i_keelst_thou: 56.9
01:02:44 <ehird> ... or actually worsens it
01:02:45 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
01:02:48 <EgoBot> Score for ehird_i_keelst_thou: 54.5
01:02:49 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
01:02:50 <leonid_> !bfjoust lols -(>)*9(--->[-[+-+]])*20
01:02:52 <EgoBot> Score for ehird_i_keelst_thou: 54.0
01:02:53 <EgoBot> Score for leonid__lols: 36.6
01:02:54 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*21
01:02:57 <EgoBot> Score for ehird_i_keelst_thou: 54.0
01:02:57 <ais523> ehird: maybe it's to do with tape length latency?
01:02:58 <leonid_> !bfjoust lols -(>)*9(+++-+>[-[+-+]])*20
01:03:01 <EgoBot> Score for leonid__lols: 44.9
01:03:01 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*22
01:03:04 <EgoBot> Score for ehird_i_keelst_thou: 59.8
01:03:05 <leonid_> !bfjoust lols -(>)*9(++-++>[-[+-+]])*20
01:03:05 <ais523> also, why don't you just remove the final > on the last iteration?
01:03:08 <EgoBot> Score for leonid__lols: 34.3
01:03:17 <leonid_> !bfjoust lols +(>)*9(+++>[-[+-+]])*20
01:03:20 <EgoBot> Score for leonid__lols: 56.5
01:03:22 <ehird> !bfjoust i_keelst_thou (>+>-)*4(>(-)*128[-]+>(-)*128[+]-)*22
01:03:24 <EgoBot> Score for ehird_i_keelst_thou: 49.2
01:03:25 <leonid_> !bfjoust lols +--(>)*9(+++>[-[+-+]])*20
01:03:28 <EgoBot> Score for leonid__lols: 41.4
01:03:29 <ehird> ais523: because that does worse
01:03:31 <leonid_> !bfjoust lols ++(>)*9(+++>[-[+-+]])*20
01:03:32 <ehird> !bfjoust i_keelst_thou (>+>-)*4(>(-)*128[-]+>(-)*128[+]-)*21
01:03:34 <EgoBot> Score for leonid__lols: 54.3
01:03:35 <EgoBot> Score for ehird_i_keelst_thou: 44.9
01:03:36 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*22
01:03:36 <ais523> wait, the number at the end shouldn't make a difference, if it's over 10
01:03:38 <EgoBot> Score for ehird_i_keelst_thou: 59.3
01:03:41 <leonid_> !bfjoust lols -(>)*10(+++>[-[+-+]])*20
01:03:42 <ais523> because you have two >s in the repeated bit
01:03:43 <EgoBot> Score for leonid__lols: 37.7
01:03:47 <leonid_> !bfjoust lols -(>)*8(+++>[-[+-+]])*20
01:03:48 <ais523> it must just be random tape length effects
01:03:50 <EgoBot> Score for leonid__lols: 51.7
01:03:51 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*10
01:03:54 <EgoBot> Score for ehird_i_keelst_thou: 21.2
01:03:59 <leonid_> !bfjoust lols -(>)*9(+++><>[-[+-+]])*20
01:04:01 <EgoBot> Score for leonid__lols: 41.3
01:04:03 <ehird> that's a bit dramatic for random effects
01:04:04 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*11
01:04:07 <leonid_> !bfjoust lols -(><>)*9(+++>[-[+-+]])*20
01:04:07 <EgoBot> Score for ehird_i_keelst_thou: 57.3
01:04:10 <EgoBot> Score for leonid__lols: 49.0
01:04:12 <ehird> okay, 11's a sweet spot
01:04:23 <ais523> ehird: I suspect there's an odd/even interaction agaisnt something that's floating around in the hill
01:04:31 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-]])*20
01:04:34 <EgoBot> Score for leonid__lols: 24.5
01:04:38 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+-+-+-+]])*20
01:04:41 <EgoBot> Score for leonid__lols: 44.0
01:04:43 <pikhq> !bfjoust ı (>)*9(-)*128[-]
01:04:45 <EgoBot> Score for pikhq___: 14.4
01:04:47 <leonid_> !bfjoust lols -(>)*9(+++>[-[+++---+]])*20
01:04:50 <EgoBot> Score for leonid__lols: 39.8
01:04:53 <leonid_> !bfjoust lols -(>)*9(+++>[-[++--+]])*20
01:04:56 <EgoBot> Score for leonid__lols: 39.3
01:05:00 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:05:02 <EgoBot> Score for leonid__lols: 60.0
01:05:13 <AnMaster> please, can we talk about something else tomorrow?
01:05:17 <ehird> AnMaster: no, this is fun
01:05:23 <ais523> !bfjoust anti_counterdefence_glue ([]+)*10000
01:05:26 <EgoBot> Score for ais523_anti_counterdefence_glue: 16.5
01:05:29 <AnMaster> this channel should be renamed joust
01:05:30 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-++]+>(-)*128[+--]->)*11
01:05:32 <EgoBot> Score for ehird_i_keelst_thou: 43.2
01:05:33 <ais523> !bfjoust anti_counterdefence_glue ([]+)*50000
01:05:34 <ehird> leonid_: noooooooo
01:05:36 <EgoBot> Score for ais523_anti_counterdefence_glue: 16.3
01:05:38 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[-]+>(-)*128[+]->)*11
01:05:39 <ais523> and I was just about to suggest making #bfjoust
01:05:41 <EgoBot> Score for ehird_i_keelst_thou: 56.9
01:05:46 <ais523> although we'd have to persuade EgoBot to move there
01:05:48 <ehird> ais523: it will die down eventually
01:05:53 <ehird> but we're not talking about anything else
01:06:04 <ais523> ehird: well, #feather-lang exists
01:06:07 <ais523> and it's pretty rarely used
01:06:18 <ehird> ais523: it's a crappy channel because of that :)
01:06:24 <leonid_> !bfjoust lols ---(>)*9(+++>[-[+-+]])*20
01:06:24 <ais523> !bfjoust anti_counterdefence_glue >>>>([]+)*50000
01:06:26 <EgoBot> Score for leonid__lols: 39.0
01:06:27 <EgoBot> Score for ais523_anti_counterdefence_glue: 9.8
01:06:31 <leonid_> !bfjoust lols ---++(>)*9(+++>[-[+-+]])*20
01:06:34 <EgoBot> Score for leonid__lols: 48.8
01:06:35 <ais523> !bfjoust anti_counterdefence_glue >>>>(+[])*50000
01:06:38 <EgoBot> Score for ais523_anti_counterdefence_glue: 10.4
01:06:39 <leonid_> !bfjoust lols ----+++(>)*9(+++>[-[+-+]])*20
01:06:41 <EgoBot> Score for leonid__lols: 44.8
01:06:54 <leonid_> !bfjoust lols -(>)*9.(+++>[-[+-+]])*20
01:06:57 <EgoBot> Score for leonid__lols: 39.5
01:07:04 <leonid_> !bfjoust lols -(>)*9(+++>[-[+[-+-]]])*20
01:07:07 <EgoBot> Score for leonid__lols: 34.6
01:07:12 <leonid_> !bfjoust lols -(>)*9(+++>[-[-[+-+]]])*20
01:07:15 <EgoBot> Score for leonid__lols: 45.4
01:07:30 <leonid_> !bfjoust lols -(>)*9(+++>[-[+[+-+]-[+-+]+]])*20
01:07:33 <EgoBot> Score for leonid__lols: 29.1
01:07:42 <ehird> 10 63.09 7 ehird_i_keelst_thou.bfjoust
01:07:43 <leonid_> !bfjoust lols -(>)*9(+++>[-[+[+-+]]])*20
01:07:46 <EgoBot> Score for leonid__lols: 29.9
01:07:51 <leonid_> !bfjoust lols -(>)*9(+++>[+[+-+]])*20
01:07:54 <EgoBot> Score for leonid__lols: 32.8
01:07:57 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:08:00 <EgoBot> Score for leonid__lols: 60.6
01:08:26 <pikhq> !bfjoust defense! [[.]+]
01:08:29 <EgoBot> Score for pikhq_defense_: 13.1
01:08:47 <pikhq> !bfjoust defense! [+[.]+]
01:08:50 <EgoBot> Score for pikhq_defense_: 12.8
01:09:04 <leonid_> !bfjoust lols -(>)*9(+++>([-[+-+]])*5)*20
01:09:07 <EgoBot> Score for leonid__lols: 45.9
01:09:10 <leonid_> !bfjoust lols -(>)*9(+++>([-[+-+]])*10)*20
01:09:10 <pikhq> !bfjoust lawlz [.]
01:09:12 <EgoBot> Score for leonid__lols: 45.2
01:09:13 <EgoBot> Score for pikhq_lawlz: 13.1
01:09:15 <leonid_> !bfjoust lols -(>)*9(+++>([-[+-+]])*100)*20
01:09:18 <EgoBot> Score for leonid__lols: 45.5
01:09:23 <leonid_> !bfjoust lols -(>)*9(+++>([-[+-+]])*1)*20
01:09:26 <EgoBot> Score for leonid__lols: 38.0
01:09:30 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:09:33 <EgoBot> Score for leonid__lols: 58.9
01:09:59 <pikhq> !bfjoust lawlz [(+)*64]
01:10:02 <EgoBot> Score for pikhq_lawlz: 5.0
01:10:20 <ais523> !bfjoust anti_counterdefence_glue ([](+)*128(>)*8(+)*20(<)*8)*10([](+)*128(>)*9(+)*20(<)*9)*10([](+)*128(>)*10(+)*20(<)*10)*10([](+)*128(>)*11(+)*20(<)*11)*10([](+)*128(>)*12(+)*20(<)*12)*10([](+)*128(>)*13(+)*20(<)*13)*10([](+)*128(>)*14(+)*20(<)*14)*10([](+)*128(>)*15(+)*20(<)*15)*10([](+)*128(>)*16(+)*20(<)*16)*10([](+)*128(>)*17(+)*20(<)*17)*10([](+)*128(>)*18(+)*20(<)*18)*10([](+)*128(>)*19(+)*20(<)*19)*10([](+)*128(
01:10:22 <ais523> >)*8(+)*20(<)*8)*10([](+)*128(>)*8(+)*20(<)*8)*10([](+)*128(>)*8(+)*20(<)*8)*10([](+)*128(>)*8(+)*20(<)*8)*10([](+)*128(>)*8(+)*20(<)*8)*10([](+)*128(>)*8(+)*20(<)*8)*10([](+)*128(>)*8(+)*20(<)*8)*10([](+)*128(>)*20(+)*20(<)*20)*10([](+)*128(>)*21(+)*20(<)*21)*10
01:10:23 <EgoBot> Score for ais523_anti_counterdefence_glue: 0.0
01:10:54 -!- inurinternet has quit (No route to host).
01:11:11 <ais523> !bfjoust anti_counterdefence_glue http://pastebin.ca/raw/1438788
01:11:15 <EgoBot> Score for ais523_anti_counterdefence_glue: 16.8
01:11:22 <ais523> heh, still doing rather badly
01:11:44 <ais523> it beat maglev and shade
01:11:58 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*15
01:12:00 <ais523> lesson learnt: don't attack a construct that hardly anyone uses
01:12:01 <EgoBot> Score for leonid__lols: 43.8
01:12:04 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*17
01:12:07 <EgoBot> Score for leonid__lols: 51.5
01:12:10 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*18
01:12:12 <EgoBot> Score for leonid__lols: 42.8
01:12:14 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*16
01:12:17 <EgoBot> Score for leonid__lols: 38.9
01:12:29 <leonid_> !bfjoust lols -(>)*20(+++>[-[+-+]])*10
01:12:32 <EgoBot> Score for leonid__lols: 35.4
01:12:37 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:12:40 <EgoBot> Score for leonid__lols: 59.5
01:13:05 <GregorR-L> In Star Trek, a planet with no life may have trees.
01:13:08 <GregorR-L> Because trees totally aren't life.
01:13:38 <leonid_> !bfjoust lols -(>)*9(+-+>[-[+-+]])*20
01:13:40 <EgoBot> Score for leonid__lols: 55.1
01:13:44 <leonid_> !bfjoust lols -(>)*9(+-+>[---[+-+]])*20
01:13:47 <EgoBot> Score for leonid__lols: 52.9
01:13:49 <leonid_> !bfjoust lols -(>)*9(+-+>[--[+-+]])*20
01:13:49 <pikhq> GregorR-L: Ah, Star Trek.
01:13:52 <EgoBot> Score for leonid__lols: 46.5
01:13:55 <leonid_> !bfjoust lols -(>)*9(+-+>[-----[+-+]])*20
01:13:58 <EgoBot> Score for leonid__lols: 51.2
01:13:59 <ais523> leonid_: put lols back to the version that gets almost 60
01:14:01 <pikhq> So bad, it's amazing that it's entertaining.
01:14:06 <leonid_> !bfjoust lols -(>)*9(+>[-[+-+]])*20
01:14:08 <ais523> and use a different filename for tests
01:14:09 <EgoBot> Score for leonid__lols: 50.5
01:14:17 <leonid_> !bfjoust lols -(>)*9(+>[-[+-+]])*20
01:14:20 <EgoBot> Score for leonid__lols: 49.9
01:14:25 <ais523> the good version had +++ before the >
01:14:31 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:14:34 <EgoBot> Score for leonid__lols: 59.5
01:14:51 <ais523> leaving the good one there while experimenting means that other players have better programs to aim for
01:15:06 <leonid_> !bfjoust lols2 -(>)*9(+++>[-[+-+]])*20
01:15:09 <EgoBot> Score for leonid__lols2: 55.4
01:15:35 <leonid_> !bfjoust lols2 -(>)*9(+-+>[-[+-+]])*19
01:15:38 <EgoBot> Score for leonid__lols2: 51.7
01:15:44 <leonid_> !bfjoust lols2 -(>)*9(+-+-+++>[-[+-+]])*19
01:15:47 <EgoBot> Score for leonid__lols2: 46.0
01:15:50 <leonid_> !bfjoust lols2 -(>)*9(+-+-+++>[-[+-+]])*23
01:15:52 <EgoBot> Score for leonid__lols2: 36.5
01:16:18 <leonid_> !bfjoust lols2 +(>)*9(+++>[-[+-+]])*23
01:16:21 <EgoBot> Score for leonid__lols2: 35.1
01:17:07 <leonid_> !bfjoust lols2 ---(>)*9(+++>[-[+-+]])*23
01:17:09 <EgoBot> Score for leonid__lols2: 40.7
01:17:20 <leonid_> !bfjoust lols2 (-+)*10000+(>)*9(+++>[-[+-+]])*23
01:17:23 <EgoBot> Score for leonid__lols2: 48.8
01:17:31 <leonid_> !bfjoust lols2 (-+)*100000+(>)*9(+++>[-[+-+]])*20
01:17:34 <EgoBot> Score for leonid__lols2: 22.1
01:17:48 <leonid_> !bfjoust lols2 (-+)*100+(>)*9(+++>[-[+-+]])*20
01:17:51 <EgoBot> Score for leonid__lols2: 30.4
01:18:04 <leonid_> !bfjoust lols2 +(>)*8(+++>[-[+-+]])*20
01:18:06 <EgoBot> Score for leonid__lols2: 31.8
01:19:43 <leonid_> !bfjoust lols2 +(>)*8(+++>[-[+-+-+]])*20
01:19:46 <EgoBot> Score for leonid__lols2: 34.8
01:19:50 <leonid_> !bfjoust lols2 +(>)*8(+++>[-[++--+]])*20
01:19:53 <EgoBot> Score for leonid__lols2: 30.7
01:20:00 <leonid_> !bfjoust lols2 +(>)*8(+++>[-[+-+-+-+]])*20
01:20:02 <EgoBot> Score for leonid__lols2: 37.6
01:20:11 <leonid_> !bfjoust lols2 +(>)*8(+++>[-[(+-)*1000+]])*20
01:20:13 <EgoBot> Score for leonid__lols2: 37.7
01:20:18 <leonid_> !bfjoust lols2 +(>)*8(+++>[-[(+-)*100+]])*20
01:20:21 <EgoBot> Score for leonid__lols2: 35.7
01:20:29 <leonid_> !bfjoust lols2 +(>)*8(+++>[-[(+-)*99999+]])*20
01:20:32 <EgoBot> Score for leonid__lols2: 24.6
01:20:52 <leonid_> !bfjoust lols2 +(>)*8((+)*64>[-[+-+]])*20
01:20:55 <EgoBot> Score for leonid__lols2: 41.2
01:21:02 <leonid_> !bfjoust lols2 +(>)*8((+)*129>[-[+-+]])*20
01:21:04 <EgoBot> Score for leonid__lols2: 41.8
01:21:08 <leonid_> !bfjoust lols2 +(>)*8((+)*131>[-[+-+]])*20
01:21:11 <EgoBot> Score for leonid__lols2: 41.8
01:21:19 <leonid_> !bfjoust lols2 +(>)*8((+)*131>[(-)*129[+-+]])*20
01:21:22 <EgoBot> Score for leonid__lols2: 36.6
01:21:24 <ais523> GregorR-L: vff beats slowrush in the head-to-head match
01:21:29 <ais523> just not percentagewise
01:21:39 <leonid_> !bfjoust lols2 +(>)*8((+)*131>[-[++-+-++]])*20
01:21:42 <EgoBot> Score for leonid__lols2: 41.2
01:22:01 <leonid_> !bfjoust lols2 +(>)*8(+>[-[+[+[-+-]+]+]-])*20
01:22:04 <EgoBot> Score for leonid__lols2: 24.8
01:22:10 <ais523> one thing that could be interesting, but difficult, would be updating the scoreboard to show /how/ each win/loss/draw happened
01:22:17 <ais523> e.g. timeout, off tape right, etc
01:22:29 <leonid_> !bfjoust lols2 +++(>)*9(++++>[-[+-+]])*20
01:22:31 <EgoBot> Score for leonid__lols2: 39.0
01:23:39 -!- coppro has joined.
01:23:43 <nescience> ais523: the bot just takes return values of 0, 1, 2... gonna have to get gregor to change the bot for something like that
01:24:00 <leonid_> !bfjoust lols2 +-+(>)*11(++++>[-[+-+]])*20
01:24:00 <ais523> which is why I said it was difficult
01:24:02 <EgoBot> Score for leonid__lols2: 36.0
01:24:19 <GregorR-L> The point is, not the bot itself, just stuff it runs.
01:24:34 <nescience> i saw earlier you say something about it going off the return values, but if not then even better
01:24:49 <ais523> GregorR-L: is egojoust in EgoBot's hg repo yet?
01:24:50 <nescience> i gotta sit down and make slowrush stop running off the tape vs vibration.. i assume that's what it's doing at least
01:25:18 <nescience> ais523: what commanad are you typing? i just get an error :\
01:25:32 <ais523> nescience: "hg update"
01:25:53 <ais523> ooh, I forgot to pull...
01:26:09 <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/
01:26:17 <GregorR-L> That's the correct URL to the source for EgoBot itself.
01:26:35 <nescience> i wonder if that makes a difference?
01:26:42 <leonid_> !bfjoust lols2 +-+(>)*11(+++++>[-[+-+-+]])*19
01:26:45 <EgoBot> Score for leonid__lols2: 30.2
01:26:49 <leonid_> !bfjoust lols2 +-+(>)*9(+++++>[-[+-+-+]])*19
01:26:52 <EgoBot> Score for leonid__lols2: 37.1
01:26:55 <leonid_> !bfjoust lols2 +-+(>)*9(+++++>[-[+-+-+]])*21
01:26:55 <GregorR-L> I have it set to https so that if somebody gets push access, they'll push to https
01:26:57 <EgoBot> Score for leonid__lols2: 41.6
01:27:24 <nescience> i'm still trying to get the bf_joust folder, but it just says it's not a repository
01:27:40 <GregorR-L> http://codu.org/eso/bfjoust/in_egobot/ you mean?
01:27:54 <leonid_> !bfjoust lols2 ++(>)*9(+++++>[-[+-+-+]])*21
01:27:56 <EgoBot> Score for leonid__lols2: 39.3
01:28:20 <leonid_> !bfjoust lols2 +++(>)*10(+++>[+++[+-+-+]])*20
01:28:23 <EgoBot> Score for leonid__lols2: 24.9
01:28:28 <leonid_> !bfjoust lols2 +++(>)*10(+++>[+++[+]])*20
01:28:30 <EgoBot> Score for leonid__lols2: 23.1
01:28:33 <leonid_> !bfjoust lols2 +++(>)*10(+++>[+++[-]])*20
01:28:36 <EgoBot> Score for leonid__lols2: 31.9
01:28:38 <myndzi> abort: 'http://codu.org/eso/bfjoust/in_egobot/' does not appear to be an hg repository!
01:28:40 <leonid_> !bfjoust lols2 +++(>)*10(+++>[-[-]])*20
01:28:43 <EgoBot> Score for leonid__lols2: 28.2
01:28:50 <leonid_> !bfjoust lols2 +++(>)*10(+++>[-[+]])*20
01:28:54 <EgoBot> Score for leonid__lols2: 26.8
01:29:05 <myndzi> i did apt-get install mercurial
01:29:12 <myndzi> if i need something else that could be the problem
01:29:45 <leonid_> !bfjoust lols2 +++(><><><>)*10(+++>[-[+]])*20
01:29:48 <EgoBot> Score for leonid__lols2: 37.3
01:29:59 <GregorR-L> Idonno what to tell you, that works for me. You could just do wget -r -l inf -np http://codu.org/eso/bfjoust/in_egobot/.hg/
01:30:04 <leonid_> !bfjoust lols2 +(><><><>)*9(+++>[-[+-+]])*20
01:30:07 <EgoBot> Score for leonid__lols2: 46.2
01:30:14 <leonid_> !bfjoust lols2 +(><><><>)*10(+++>[-[+-+]])*20
01:30:16 <GregorR-L> Then put that somewhere and `hg up` next to it.
01:30:17 <EgoBot> Score for leonid__lols2: 42.0
01:30:20 <leonid_> !bfjoust lols2 +(><><><>)*8(+++>[-[+-+]])*20
01:30:23 <EgoBot> Score for leonid__lols2: 49.8
01:30:25 <myndzi> maybe i'll just try to get the windows version and play ith that
01:30:29 <leonid_> !bfjoust lols2 +(><><><><>)*8(+++>[-[+-+]])*20
01:30:32 <EgoBot> Score for leonid__lols2: 47.0
01:30:35 <leonid_> !bfjoust lols2 +(><><><><><>)*8(+++>[-[+-+]])*20
01:30:38 <EgoBot> Score for leonid__lols2: 48.4
01:30:42 <ais523> myndzi: it could be an internet connectivity problem from inside the vm
01:31:09 <leonid_> !bfjoust lols2 +(><><<>><>)*8(+++>[-[+-+]])*20
01:31:12 <EgoBot> Score for leonid__lols2: 0.0
01:31:33 <leonid_> !bfjoust lols2 +(><><<>>)*8(+++>[-[+-+]])*20
01:31:35 <EgoBot> Score for leonid__lols2: 0.0
01:31:55 <leonid_> !bfjoust lols2 +(>><<><>)*8(+++>[-[+-+]])*20
01:31:58 <EgoBot> Score for leonid__lols2: 46.8
01:32:14 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[-[+-+]])*20
01:32:17 <EgoBot> Score for leonid__lols2: 51.5
01:32:31 <ais523> coppro: how did the Enigma-playing go?
01:32:43 <coppro> lots of work to do though
01:32:44 <leonid_> !bfjoust lols2 +(>><<>><<>><<>)*8(+++>[-[+-+]])*20
01:32:46 <EgoBot> Score for leonid__lols2: 47.3
01:32:52 <leonid_> !bfjoust lols2 +(>><<>><><<>)*8(+++>[-[+-+]])*20
01:32:54 <EgoBot> Score for leonid__lols2: 45.9
01:33:11 <leonid_> !bfjoust lols2 +(>><<>>><<<>)*8(+++>[-[+-+]])*20
01:33:14 <EgoBot> Score for leonid__lols2: 44.1
01:33:39 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[-[+-+]])*20
01:33:42 <EgoBot> Score for leonid__lols2: 52.0
01:34:02 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[-+-[+-+]])*20
01:34:04 <EgoBot> Score for leonid__lols2: 41.8
01:34:09 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[--[+-+-+]])*20
01:34:12 <EgoBot> Score for leonid__lols2: 42.6
01:34:15 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[-[+-+-+]])*20
01:34:17 <EgoBot> Score for leonid__lols2: 56.7
01:34:18 <myndzi> ais523: nah, apt-get worked
01:34:27 <ais523> myndzi: ah, good point
01:34:34 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[-[+-+-+-+]])*20
01:34:36 <EgoBot> Score for leonid__lols2: 41.8
01:34:40 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+>[-[+-+-+]])*20
01:34:42 <ais523> also, why using > and < to nop, rather than just .
01:34:43 <EgoBot> Score for leonid__lols2: 40.4
01:34:56 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+>[-[+-+-+-+]])*20
01:34:58 <EgoBot> Score for leonid__lols2: 36.2
01:35:15 <leonid_> !bfjoust lols2 +(>...<>)*8(+++>[-[+-+-+]])*20
01:35:17 <EgoBot> Score for leonid__lols2: 41.8
01:35:20 <leonid_> !bfjoust lols2 +(>....)*8(+++>[-[+-+-+]])*20
01:35:23 <EgoBot> Score for leonid__lols2: 37.0
01:35:32 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[-[+-+-+]])*20
01:35:35 <EgoBot> Score for leonid__lols2: 56.7
01:35:55 <leonid_> !bfjoust lols2 +(........>)*8(+++>[-[+-+-+]])*20
01:35:58 <EgoBot> Score for leonid__lols2: 36.6
01:36:04 <leonid_> !bfjoust lols2 +(....>)*8(+++>[-[+-+-+]])*20
01:36:07 <EgoBot> Score for leonid__lols2: 35.1
01:36:17 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(++++>[-[+-+-+]])*20
01:36:19 <EgoBot> Score for leonid__lols2: 47.3
01:36:37 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(++>[-[+-+-+]])*20
01:36:40 <EgoBot> Score for leonid__lols2: 42.0
01:36:43 <myndzi> the wget should do it i guess
01:36:45 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[-[+-+-+]])*20
01:36:48 <EgoBot> Score for leonid__lols2: 56.7
01:37:12 <leonid_> !bfjoust lols2 +><(>><<>><<>)*8(+++>[-[+-+-+]])*20
01:37:14 <myndzi> mostly i just wanted to get my code back
01:37:14 <EgoBot> Score for leonid__lols2: 48.6
01:37:19 <myndzi> i'm not so interested in keeping it up to date
01:37:20 <leonid_> !bfjoust lols2 +>-<+(>><<>><<>)*8(+++>[-[+-+-+]])*20
01:37:23 <EgoBot> Score for leonid__lols2: 47.3
01:37:27 <myndzi> but i guess i can figure that out later
01:37:29 <leonid_> !bfjoust lols2 +>-<(>><<>><<>)*8(+++>[-[+-+-+]])*20
01:37:31 <EgoBot> Score for leonid__lols2: 35.1
01:37:39 <leonid_> !bfjoust lols2 +(>><<>><<>)*8(+++>[-[++--+]])*20
01:37:41 <nescience> leonid_: you might consider doing that in a query with the bot
01:37:41 <EgoBot> Score for leonid__lols2: 44.0
01:37:48 <nescience> just so, y'know, people can see what they are saying in here
01:38:24 <nescience> i think i'm gonna make a mirc interpreter after all (lol slow)
01:38:34 <nescience> so i can test things out like that without messing with the bot
01:39:56 <nescience> i just fixed head 10, but it's still screwing up
01:40:01 <nescience> i have no idea what the problem is now :\
01:40:09 <nescience> maybe a bad solenoid, but it'll be hard to test..
01:45:23 -!- KingOfKarlsruhe has quit (Remote closed the connection).
01:50:19 <myndzi> the windows version of mercurial worked fine
01:50:26 <myndzi> i think maybe the debian packages are out of date
01:51:17 -!- inurinternet has joined.
02:01:22 <ais523> hmm... I reckon attack1 would beat lols2
02:01:31 <leonid_> i beat yours too nescience
02:01:50 <ais523> !bfjoust attack1 [>[-]+]
02:01:53 <EgoBot> Score for ais523_attack1: 18.9
02:03:01 <leonid_> making several attack1 clone will pull lols down
02:03:20 <ais523> and I'd have to submit them very quickly
02:03:34 <ais523> !bfjoust attack1_buffered [[[>[-]+]+]+]
02:03:37 <EgoBot> Score for ais523_attack1_buffered: 20.1
02:04:22 <ais523> heh, now it beats ehird's best program /and/ leonid's best program
02:04:26 <ais523> but still loses against most of the field
02:07:24 <myndzi> there's got to be an easy way to display the most recent version of a file that got deleted
02:07:35 <ais523> myndzi: in BF Joust, or in general?
02:07:53 <myndzi> i'm still trying to figure out how to FIND how to refer to the latest version of th efile
02:18:24 <nescience> !bfjoust creep >+>->+>->+>->+(>-++-(.)*132[+]++>-++-(.)*132[-]--)*15
02:18:27 <EgoBot> Score for nescience_creep: 25.3
02:21:33 <ais523> wow, ehird_i_keelst_thou.bfjoust is down to halfway already
02:21:53 <ais523> and impomatic_mirage is a new entry near the top
02:21:54 <EgoBot> Score for pikhq_lawlz: 13.1
02:22:01 <ais523> or has it just always been there, and started doing well, I wonder?
02:22:10 <pikhq> It wins by merit of not killing itself!
02:22:38 <ais523> nescience_shade assumes the opponent sets up at least one decoy
02:32:05 <ais523> clearly, I need a radically new idea
02:33:36 <ais523> !bfjoust speedy1 >>>>>>>>>([+[+[+[---]]]])*21
02:33:39 <EgoBot> Score for ais523_speedy1: 15.2
02:34:07 <ais523> beats only shade and mirage
02:34:20 <ais523> !bfjoust speedy1 >>>>>>>>>([+[+[+[-]]]])*21
02:34:23 <EgoBot> Score for ais523_speedy1: 11.2
02:34:59 <ais523> !bfjoust speedy1 >>>>>>>>>(+[+[+[+[---]]]]>)*21
02:35:02 <EgoBot> Score for ais523_speedy1: 40.1
02:35:10 <ais523> it would help if I remembered to enter the loop in the first place...
02:35:19 <ais523> !bfjoust speedy1 >>>>>>>>>(+[+[+[---]]]>)*21
02:35:22 <EgoBot> Score for ais523_speedy1: 30.1
02:35:28 * ais523 wonders why that does worse
02:35:34 <ais523> oh, it's slower against a flag
02:35:47 <ais523> !bfjoust speedy1 >>>>>>>>>(-[++[++[---]]]>)*21
02:35:50 <EgoBot> Score for ais523_speedy1: 19.1
02:36:03 <ais523> !bfjoust speedy1 >>>>>>>>>(-[+[+++[---]]]>)*21
02:36:06 <EgoBot> Score for ais523_speedy1: 23.3
02:36:13 <ais523> !bfjoust speedy1 >>>>>>>>>(-[+[+[---]]]>)*21
02:36:16 <EgoBot> Score for ais523_speedy1: 50.7
02:37:36 <ais523> heh, vff's down to the bottom half of the leaderboard already
02:38:41 <ais523> !bfjoust stubborn >>>>>>>>>((.-)*256>)*21
02:38:46 <EgoBot> Score for ais523_stubborn: 26.5
02:39:11 <ais523> 5 wins, but nevertheless last
02:39:17 <ais523> !bfjoust stubborn >>>>>>>>>((.+)*256>)*21
02:39:20 <EgoBot> Score for ais523_stubborn: 12.2
02:39:27 <ais523> interesting how much difference that made...
02:40:42 <ais523> !bfjoust flagwire_vibration [](+-)*5000+>+++++[[[>[---]+]+]+]+[[[>[---]+]+]+]
02:40:45 <EgoBot> Score for ais523_flagwire_vibration: 13.8
02:41:21 <ais523> oh, of course; as ehird said, you can't use a [] on your own flag
02:43:01 <ais523> !bfjoust tripwire_sensor >+>+[]<(.)*48[<(+)*100000]<(-)*100000
02:43:02 <myndzi> that's the main reason for my wiki comment about timing
02:43:04 <EgoBot> Score for ais523_tripwire_sensor: 13.9
02:43:15 * ais523 wonders why tripwire_sensor does so badly
02:43:27 <ais523> !bfjoust tripwire_sensor >+>+>+<[]<(.)*48[<(+)*100000]<(-)*100000
02:43:30 <EgoBot> Score for ais523_tripwire_sensor: 13.7
02:44:17 <ais523> !bfjoust tripwire_sensor >+>++++>+<[]<(.)*48[<(+)*100000]<(-)*100000
02:44:20 <EgoBot> Score for ais523_tripwire_sensor: 18.7
02:45:18 * ais523 tests locally against speedy1
02:46:24 <ais523> !bfjoust tripwire_sensor >+>+++>+<[]<(.)*48[<(+)*100000]<(-)*100000
02:46:28 <EgoBot> Score for ais523_tripwire_sensor: 18.6
02:46:45 <ais523> strange, speedy1 still wins
02:48:15 <ais523> !bfjoust tripwire_sensor >+>+++++>+<[]<(.)*48[<(+)*100000]<(-)*100000
02:48:19 <EgoBot> Score for ais523_tripwire_sensor: 13.8
02:48:27 <ais523> !bfjoust tripwire_sensor >+>++>+<[]<(.)*48[<(+)*100000]<(-)*100000
02:48:30 <EgoBot> Score for ais523_tripwire_sensor: 20.4
02:48:38 <ais523> but still not good enough
02:49:33 <ais523> !bfjoust tripwire_sensor >+>>+<+++++[]<(.)*48[<(+)*100000]<(-)*100000
02:49:36 <EgoBot> Score for ais523_tripwire_sensor: 19.7
02:49:41 <ais523> !bfjoust tripwire_sensor >+>>+<++[]<(.)*48[<(+)*100000]<(-)*100000
02:49:45 <EgoBot> Score for ais523_tripwire_sensor: 13.5
02:49:52 <ais523> !bfjoust tripwire_sensor >+>>-<++[]<(.)*48[<(+)*100000]<(-)*100000
02:49:56 <EgoBot> Score for ais523_tripwire_sensor: 15.8
02:50:01 <ais523> !bfjoust tripwire_sensor >+>>-<+++++[]<(.)*48[<(+)*100000]<(-)*100000
02:50:05 <EgoBot> Score for ais523_tripwire_sensor: 21.5
02:56:36 <myndzi> ahh finally got it right
02:56:44 <myndzi> it's such a good vibration
02:56:52 <myndzi> but now i lose to speedy, must be timing
02:57:02 <ais523> myndzi: you boosted slowrush?
02:57:26 <ais523> heh, and you draw to tripwire_sensor, which is awful
02:57:42 <myndzi> haven't got to that point, tackling one at a time
02:57:45 <myndzi> first, the ones i was losing to
02:58:09 <coppro> this thing should allow forking!
02:58:27 <ais523> !bfjoust speedy_decoy >(-)*5>>>>>>>>(-[+[+[---]]]>)*21
02:58:30 <EgoBot> Score for ais523_speedy_decoy: 50.8
02:58:31 <coppro> that would add a whole new level of awesome
02:58:42 <leonid_> my lawlz still beats slowrush
02:58:54 <ais523> beh, slowrush still somehow beats it anyway
02:59:01 <myndzi> wonder why it ties to viper
02:59:17 <myndzi> like my solution to vibrate? :)
02:59:18 <coppro> did Gregor increase the heap size or is it another bug?
02:59:26 <myndzi> (current code: >(+)*19>(-)*19>+>->+>->+>-(>-.+[[-++++++++++++++[-.]]+>-.+]+)*20)
02:59:44 <ais523> myndzi: by vibrating a bit yourself to see if it kills the opponent
02:59:52 <myndzi> it's more precise than that
02:59:58 <myndzi> if i execute "-" and you don't die
03:00:07 <myndzi> and then i wait a beat and counteract it so you do
03:00:35 <myndzi> costs me 3 cycles on new cells but it is worth it
03:01:10 <myndzi> me and viper must be getting in +- loops
03:01:15 <myndzi> but i don't see how that can happen
03:01:36 <ais523> your use of 19 for the decoys in slowrush is really clever
03:02:00 <ais523> !bfjoust speedy_decoy <
03:02:03 <EgoBot> Score for ais523_speedy_decoy: 0.0
03:02:03 <myndzi> 18 loses me lots of points
03:02:07 <myndzi> so i am not really sure
03:02:13 <myndzi> i dropped it to 19 to beat your inverse
03:02:18 <myndzi> that's what i meant when i said cheap hack
03:02:24 <myndzi> just so i was a little faster than you
03:02:42 <myndzi> well, a tie to viper is ok
03:02:46 <myndzi> i reign supreme again!
03:02:46 <ais523> 19 works well because it slows all the modulo programs, being prime and 128-19 also being prime
03:03:04 <myndzi> yeah, i didn't study it enough, but that makes sense
03:03:21 <myndzi> so i wonder how 13 would work
03:03:44 <ais523> !bfjoust speedy2 >>>>>>>>>([-[++[---]]]>)*21
03:03:47 <EgoBot> Score for ais523_speedy2: 38.4
03:04:17 <myndzi> that resubmission cost me a win
03:05:57 <ais523> !bfjoust speedy2_with_19_decoy >(+)*19>(-)*19>>>>>>>([-[++[---]]]>)*21
03:06:01 <EgoBot> Score for ais523_speedy2_with_19_decoy: 43.8
03:06:14 <myndzi> i had an idea driving over here i wanted to mess with
03:06:17 <myndzi> now i can't think of it atm
03:06:18 <ais523> !bfjoust ais523_speedy <
03:06:21 <EgoBot> Score for ais523_ais523_speedy: 0.0
03:06:31 <EgoBot> Score for ais523_speedy2: 0.0
03:08:44 <ais523> !bfjoust monovibration (+)*5000(-[+[+[---]]]>)*21
03:08:47 <EgoBot> Score for ais523_monovibration: 5.5
03:09:01 <ais523> !bfjoust monovibration (+)*5000>(-[+[+[---]]]>)*21
03:09:06 <EgoBot> Score for ais523_monovibration: 28.3
03:10:52 <ais523> !bfjoust monovibration (-)*5000>(-[+[+[---]]]>)*21
03:10:55 <EgoBot> Score for ais523_monovibration: 12.7
03:11:20 <myndzi> !bfjoust test >+>->+>->+>->+>--<++<--<++<--<++<--<++(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16(>-.+[(+)*19[+[-.]]](+)*19)*20
03:11:24 <EgoBot> Score for myndzi_test: 86.9
03:11:35 <EgoBot> Score for myndzi_test: 0.0
03:11:45 <myndzi> !bfjoust 3pass >+>->+>->+>->+>--<++<--<++<--<++<--<++(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16(>-.+[(+)*19[+[-.]]](+)*19)*20
03:11:48 <coppro> hmm... my new program's gonna need some serious copy-paste
03:11:49 <EgoBot> Score for myndzi_3pass: 86.8
03:12:05 <ais523> you even beat slowrush
03:12:24 <myndzi> i guess i'm just good? ;p
03:12:30 <ais523> the strategy of crazy decoys seems to be a good one
03:12:32 <coppro> how do you beat something that does [-[+]]?
03:12:47 <ais523> coppro: defend6 beats that by locking it in place and capturing its flag
03:12:57 <myndzi> ais523: its purpose isn't to be "crazy" but to be thorough
03:13:04 <ais523> or, you could attack and get its flag faster, that's not a very fast way to defeat an opponent
03:13:04 <myndzi> i get "something" on the first 10 spots asap
03:13:09 <myndzi> then something less trivial
03:13:13 <ais523> coppro: basically by doing 128*(+) every 64 turns
03:13:13 <myndzi> and finally something fairly weighty
03:13:24 <myndzi> and then i continue to lay down big decoys, not that it's likely to help
03:13:28 <myndzi> i wonder if i'd do better for taking that out
03:13:32 <coppro> but that leaves you stuck in the same place, no?
03:13:37 <myndzi> !bfjoust 3pass >+>->+>->+>->+>--<++<--<++<--<++<--<++(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16(>-.+[(+)*19[+[-.]]]+)*20
03:13:39 <EgoBot> Score for myndzi_3pass: 79.4
03:13:44 <myndzi> !bfjoust 3pass >+>->+>->+>->+>--<++<--<++<--<++<--<++(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16(>-.+[(+)*19[+[-.]]](+)*19)*20
03:13:47 <EgoBot> Score for myndzi_3pass: 86.6
03:13:48 <ais523> coppro: the other 64 turns, you can go and capture the opponent's flag
03:13:48 <myndzi> well, guess it helps after all
03:14:30 <ais523> !bfjoust speedy2_with_19_decoy <
03:14:33 <EgoBot> Score for ais523_speedy2_with_19_decoy: 0.0
03:15:48 <ais523> !bfjoust jump >>>>>>>([>>>[[[-]>+]+]+[[[-]>+]+]]>)*21
03:15:51 <EgoBot> Score for ais523_jump: 29.5
03:16:16 <ais523> !bfjoust jump >>>>>>>([>>[[[-]>+]+]+[[[-]>+]+]]>)*21
03:16:19 <EgoBot> Score for ais523_jump: 56.2
03:16:31 <ais523> 2 decoys seems to be the standard amount
03:16:51 <ais523> and it beats both slowrush and 3pass
03:17:25 <ais523> I can't remember whose idea guessing that the first value is a decoy was
03:17:40 <ais523> but guessing /two/ decoys seems to do better
03:17:43 <myndzi> it's one of the many ways i beat the defend scripts
03:18:07 <myndzi> problem is you can go back and forth all day tweaking and countertweaking that
03:18:21 <ais523> but then you'll lose to programs doing an entirely different strategy
03:18:26 <ais523> most people seem to use two decoys at the moment
03:19:30 <myndzi> !bfjoust 3pass >>+>->+>->+>->+++<--<++<--<++<--<++(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16(>-.+[(+)*19[+[-.]]](+)*19)*20
03:19:32 <EgoBot> Score for myndzi_3pass: 79.4
03:20:02 <myndzi> i didn't catch how many wins it had before for comparison
03:20:06 <myndzi> !bfjoust 3pass >+>->+>->+>->+>--<++<--<++<--<++<--<++(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16(>-.+[(+)*19[+[-.]]](+)*19)*20
03:20:09 <EgoBot> Score for myndzi_3pass: 81.4
03:20:19 <myndzi> well i guess your program isn't worth it :P
03:20:28 <myndzi> i'm surprised at such a big difference though
03:21:10 <myndzi> !bfjoust 3pass >>+>->+>->+>->+++<--<++<--<++<--<++(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16(>-.+[(+)*19[+[-.]]](+)*19)*20
03:21:12 <EgoBot> Score for myndzi_3pass: 70.0
03:21:13 <myndzi> whoops i had a mistake
03:21:23 <myndzi> what i get for messin around i guess
03:21:26 <ais523> also, jump doesn't do badly against programs that leave a trail of 1s or -1s behind as they move
03:21:40 <leonid_> i will have to really think from now on
03:21:54 <myndzi> i am having trouble tracking pointers
03:22:18 <ais523> !bfjoust jump2 >>>>>>>([>>(-[+[+[---]]]>)*21]>)*21
03:22:21 <EgoBot> Score for ais523_jump2: 34.9
03:22:32 <ais523> !bfjoust jump2 >>>>>>>([>>(-[+[+[-]]]>)*21]>)*21
03:22:35 <EgoBot> Score for ais523_jump2: 60.0
03:22:45 <myndzi> !bfjoust 3pass >>->+>->+>->+>--<++<--<++<--<++<--(-)*16>(+)*16>(-)*16>(+)*16>(-)*16>(+)*16>(-)*16(>-.+[(+)*19[+[-.]]](+)*19)*20
03:22:48 <EgoBot> Score for myndzi_3pass: 83.3
03:22:52 <myndzi> that's what i wanted in the first place
03:22:55 <ais523> !bfjoust jump2 >>>>>>>([>>([-[++[-]]]>)*21]>)*21
03:22:58 <EgoBot> Score for ais523_jump2: 50.8
03:23:10 <ais523> !bfjoust jump2 >>>>>>>([>>(-[+[+[-]]]>)*21]>)*21
03:23:13 <EgoBot> Score for ais523_jump2: 51.9
03:23:30 <ais523> hmm... seems to be quite a tapelength dependence there
03:23:36 <coppro> ais523: do nested brace sets work as expected?
03:23:47 <ais523> coppro: they should do, but I haven't tested much
03:24:19 <ais523> !bfjoust jump2 >>>>>>>>>([>>(++++[-]>)*21]>)*21
03:24:22 <EgoBot> Score for ais523_jump2: 39.6
03:24:26 <ais523> !bfjoust jump2 >>>>>>>>>([>>(+[-]>)*21]>)*21
03:24:29 <EgoBot> Score for ais523_jump2: 50.7
03:24:37 <ais523> !bfjoust jump2 >>>>>>>>>([>>([-]>)*21]>)*21
03:24:40 <EgoBot> Score for ais523_jump2: 29.9
03:24:49 <ais523> !bfjoust jump2 >+++>--->>>>>>>([>>(+[-]>)*21]>)*21
03:24:53 <EgoBot> Score for ais523_jump2: 39.3
03:25:37 <ais523> !bfjoust jump2 >>>>>>>>>([>>(-[++[-]]>)*21]>)*21
03:25:40 <EgoBot> Score for ais523_jump2: 30.2
03:25:46 <ais523> !bfjoust jump2 >>>>>>>>>([>>(-[+[+[-]]]>)*21]>)*21
03:25:49 <EgoBot> Score for ais523_jump2: 19.7
03:26:08 <ais523> !bfjoust jump2 >>>>>>>>>([>>(-[++[-]]>)*21]>)*21
03:26:12 <EgoBot> Score for ais523_jump2: 31.0
03:26:25 <ais523> !bfjoust jump2 >>>>>>>([>>([-[++[-]]]>)*21]>)*21
03:26:28 <EgoBot> Score for ais523_jump2: 41.3
03:26:43 <ais523> !bfjoust jump2 >>>>>>>([>>(-[+[+[-]]]>)*21]>)*21
03:26:46 <EgoBot> Score for ais523_jump2: 53.2
03:27:06 <ais523> !bfjoust jump2 >>>>>>>([>>(-[+[+[-]]]>)*21]>)*21
03:27:09 <EgoBot> Score for ais523_jump2: 52.1
03:27:23 <ais523> that program gets a much higher score if it happens to get a short tape against 3pass...
03:28:10 <myndzi> right, because it gets a lucky win and all the points from beating 3pass
03:28:23 <myndzi> where's ehird with his exhaustive search interpreter
03:28:29 <ais523> I wonder what the tape range in which jump2 beats 3pass is?
03:28:31 <ais523> more or less than half?
03:28:43 <myndzi> that's just the reason for the point boost is all
03:29:51 <leonid_> lawlz beat slowrush and 3pass
03:30:06 <myndzi> !bfjoust keke2 ->>>>>>>>>(-.+(+)*128(-)*128(+.)*256(-.)*256(++.)*256(--.)*256>)*20
03:30:09 <EgoBot> Score for myndzi_keke2: 34.3
03:31:04 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(+)*128(-)*128(+.)*256(-.)*256(++.)*256(--.)*256>)*20])*20
03:31:07 <EgoBot> Score for myndzi_keke2: 49.6
03:31:38 <myndzi> seems to mostly get outraced
03:32:02 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(+)*128(-)*128(+.)*128(-.)*128(++.)*128(--.)*128>)*20])*20
03:32:05 <EgoBot> Score for myndzi_keke2: 43.2
03:32:15 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(+)*128(-)*128(+.)*256(-.)*256>)*20])*20
03:32:17 <ais523> I like the way speedy1 is doing so well
03:32:18 <EgoBot> Score for myndzi_keke2: 39.3
03:32:22 <ais523> because everyone's trying complicated stuff
03:32:32 <myndzi> most of my ideas have been pretty simple :P
03:32:36 <myndzi> but possibly inelegant
03:32:41 <myndzi> i agree that elegant simplicity is awesome
03:32:49 <ais523> wow, vibration_fool_faster just died
03:32:58 <ais523> from second to last in just a few hours
03:33:01 <myndzi> sorry for including vibration killers in everything
03:33:16 <ais523> myndzi: I don't mind, it'll just make them easier to kill with my other programs
03:33:27 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(+)*128(-)*128(+.)*256(-.)*256(++.)*256(--.)*256>)*20])*20
03:33:29 <EgoBot> Score for myndzi_keke2: 49.3
03:33:39 <leonid_> i don't know why my code works
03:33:39 <myndzi> i gotta stop giving leonid points
03:33:46 <leonid_> all I do is changing constants
03:33:46 <myndzi> time to work on beating lols
03:36:04 <coppro> anyone have somewhere I can upload my awful program?
03:37:24 <ais523> coppro: use a pastebin?
03:37:39 <coppro> can egobot handle that?
03:37:53 <ais523> pastebin.ca has raw links
03:37:57 <ais523> so it's a good one to use with egobot
03:38:47 <ais523> click on the raw link over the left
03:38:51 <ais523> after you've pasted your program
03:39:08 <coppro> !bfjoust awful http://pastebin.ca/raw/1438923
03:39:11 <EgoBot> Score for coppro_awful: 0.0
03:39:18 <ais523> coppro: there's probably a syntax error
03:39:31 <myndzi> 16 | + 0 + + + + + + + + + + + + + + + + + | 97.2 | 18 | myndzi_3pass.bfjoust
03:39:36 <myndzi> god damn i've come so close to 100 points so many times
03:39:55 <ais523> it's on the first line...
03:40:00 <ais523> that should be (+)*128
03:40:22 <ais523> because they're different operations
03:40:42 <coppro> !bfjoust awful http://pastebin.ca/raw/1438923
03:40:45 <EgoBot> Score for coppro_awful: 0.0
03:40:50 <coppro> but the {} should provide sufficient delimiting
03:40:50 <ais523> coppro: that's the same link
03:41:07 <coppro> !bfjoust awful http://pastebin.ca/raw/1438924
03:41:11 <EgoBot> Score for coppro_awful: 0.0
03:41:13 <ais523> well, I wrote the original parser at 3am
03:41:38 <coppro> the parens balance, I know that
03:41:58 <ais523> coppro: I just pointed out your error
03:42:04 <ais523> also, what a massive program!
03:42:12 <ais523> I might do a longer one, though
03:42:23 <ais523> as I've decided to make an all-new-improved version of defence6
03:42:31 <coppro> !bfjoust awful http://pastebin.ca/raw/1438930
03:42:34 <EgoBot> Score for coppro_awful: 18.9
03:42:42 <ais523> that attacks more loops than just [-] and [+]
03:43:29 <myndzi> i need a local interpreter to try and see why i'm tying
03:43:32 <myndzi> but that's ok i'll take the score
03:44:24 <leonid_> agj4i !@#%$!@#$@! !@#$@#$!@
03:51:21 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(+)*128(+.)*256(++.)*256>)*20])*20
03:51:24 <EgoBot> Score for myndzi_keke2: 38.2
03:51:33 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(-)*128(-.)*256(-.)*256>)*20])*20
03:51:36 <EgoBot> Score for myndzi_keke2: 42.1
03:51:40 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(-)*128(-.)*256(--.)*256>)*20])*20
03:51:43 <EgoBot> Score for myndzi_keke2: 34.6
03:51:50 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(-)*128(-.)*256>)*20])*20
03:51:53 <EgoBot> Score for myndzi_keke2: 23.8
03:52:01 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(-)*256(-.)*512>)*20])*20
03:52:04 <EgoBot> Score for myndzi_keke2: 44.9
03:52:24 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(--+)*256(-.)*512>)*20])*20
03:52:27 <EgoBot> Score for myndzi_keke2: 33.8
03:59:16 <coppro> ais523: in enigma, how do you get past a window?
03:59:47 <ais523> coppro: hit it at a medium speed
03:59:51 <ais523> too slow = it doesn't break
03:59:54 <ais523> too fast = you break too
04:04:34 <myndzi> keke2's doin alright too lol
04:04:40 <myndzi> i stopped codespamming the window
04:04:51 <myndzi> but last revision: ->>>>>>>>>(>[(-.+(-.)*256(+.)*256>)*20])*20
04:05:10 <myndzi> turns out i was experimenting with timing attacks that were unnecessary
04:05:19 <myndzi> just needed to be sure to sit on 0 two turns
04:06:45 <myndzi> leonid_: you realize your code doesn't even make sense right? :P
04:06:52 <myndzi> you're setting a "decoy" on your flag
04:07:05 <myndzi> and 37 iterations of > will be more than enough to run you off the edge
04:07:27 <leonid_> i'm trying to get some luck
04:21:37 -!- oerjan has joined.
04:47:09 -!- oerjan has quit ("leaving").
04:57:24 <myndzi> i accidentally pasted slowrush on the end of 3pass and it improved its score
04:57:40 <myndzi> even though it should have gone off the end
05:03:34 <myndzi> but if i change keke to 21 instead of 20 it loses points
05:04:04 <myndzi> probably different counts at the start
05:07:15 -!- bsmntbombdood has quit (Read error: 104 (Connection reset by peer)).
05:07:42 -!- bsmntbombdood has joined.
05:08:57 <ais523> aha, I just figured out why apparently pointless changes to a program can change its win percentage
05:09:08 <ais523> it seems that the random-number generator is seeded with hashes of the programs
05:09:19 <leonid_> that's what i was exploiting
05:09:25 <myndzi> i've been watching leonid twiddle dots for a while
05:09:33 <myndzi> who in their right mind would do that though
05:09:37 <myndzi> what happened to randomize timer
05:10:04 <myndzi> that'll definitely have to be fixed
05:11:22 <leonid_> lol putting a ',' boosts my point
05:14:08 <leonid_> you should fix this quickly to prevent me to get a high rank :p
05:14:21 <myndzi> he can't fix it, it's GregorR-L's bot
05:14:32 <myndzi> also it looks like no matter how much you randomize it you can't get #1
05:14:40 <myndzi> at some point there's nothing you can do ;)
05:15:02 <myndzi> but at least i can stop trying to fix the "bugs" that are earning me losses, heh
05:15:13 <myndzi> at this point i'm not quite sure what the original program was supposed to be
05:15:19 <leonid_> .....,,,,,(>(-)*18)*9([(-)*22[+]]>)*18
05:15:43 <myndzi> now a real exploit would be
05:16:04 <myndzi> >>>>>>>>>>(-)*128and a bunch of text here to tweak the hash so they all come out exactly in the right spot
05:26:28 -!- leonid_ has quit ("Leaving").
05:26:51 -!- leonid_ has joined.
05:28:46 -!- Patashu has joined.
05:29:40 <Patashu> !bfjoust lazy >(+)*5>(-)*5>(+)*5>(-)*5>(-)*5>(+)*5>(+)*5>(-)*5(>(-.)*128)*21[-]((-)*2048(+)*2048.)*2
05:29:43 <EgoBot> Score for Patashu_lazy: 48.5
05:29:44 <Patashu> !bfjoust matador >+[]<(++-)*1000+(--+)*1000(>)*9(>[+][-])*21
05:29:47 <EgoBot> Score for Patashu_matador: 37.6
05:29:48 <Patashu> !bfjoust waiter ((++-)*10000-(--+)*10000)*2(+)*50000(-)*50000(+-)*10000(-+)*10000(>)*8(>(-.)*128)*20
05:29:51 <EgoBot> Score for Patashu_waiter: 37.8
05:29:52 <Patashu> !bfjoust juggernaut +(>(-)*128.--++)*29
05:29:55 <EgoBot> Score for Patashu_juggernaut: 26.0
05:31:26 <myndzi> which does you no good as we have learned :P
05:31:53 <myndzi> apparently the RNG is based on hashed program contents
05:32:03 <myndzi> so no matter how many times you submit it, if you don't change it, you'll get the same results
05:32:04 <Patashu> you always get the same result
05:32:10 <Patashu> but these programs weren't on the hill until just then
05:32:22 <myndzi> oh, when you said 'cycling' i thought you meant something else
05:32:37 <Patashu> it's the cycle of get pushed off when hill is unfavourable, wait, push onto hill when favourable
05:32:53 <myndzi> how about the cycle of write a program that doesn't get pushed off as easy ;)
05:33:03 <myndzi> though to be fair, there was some fuckery earlier that probably knocked things off
05:33:08 <Patashu> comes some time after I just step into the door :P
05:33:29 <myndzi> eh, a bunch of duplicates that were getting all ties
05:33:35 <leonid_> the RNG being based on hash values
05:33:43 <myndzi> the scoring placed them mid-hill so i'm sure a number of things that actually .. i dunno, played, got knocked off
05:33:45 <leonid_> like my code becoming rank 2
05:33:47 <leonid_> !bfjoust lols ....,,,,(>(-)*18)*9(>[-[+]])*18
05:33:49 <EgoBot> Score for leonid__lols: 75.6
05:34:18 <Patashu> you made code that works best for a certain field length
05:34:28 <Patashu> then kept trying trivial permutations until it got that field length when it needed it?
05:35:01 <Patashu> word on the street is that it's being rewritten to run with all 21 lengths, then with one of the program's polarity flipped, then the remaining 21 lengths
05:35:48 <myndzi> yeah, that'll really change the current game, hopefully make it more stable
05:35:53 <myndzi> and more focused on writing code
05:38:46 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:38:49 <EgoBot> Score for Patashu_lolscounter: 45.6
05:38:57 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-].])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:00 <EgoBot> Score for Patashu_lolscounter: 40.8
05:39:02 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-]+])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:05 <EgoBot> Score for Patashu_lolscounter: 16.4
05:39:06 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-]-])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:09 <EgoBot> Score for Patashu_lolscounter: 12.3
05:39:14 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-].+])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:17 <EgoBot> Score for Patashu_lolscounter: 13.3
05:39:18 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-].-])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:22 <EgoBot> Score for Patashu_lolscounter: 9.3
05:39:31 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-][+]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:34 <EgoBot> Score for Patashu_lolscounter: 24.2
05:39:38 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-]-[+]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:42 <EgoBot> Score for Patashu_lolscounter: 20.9
05:39:48 <Patashu> why are all these permutations so BAD ARGH
05:39:56 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:59 <EgoBot> Score for Patashu_lolscounter: 42.1
05:41:23 <leonid_> i'm doing hashing stuff with lols
05:41:28 <leonid_> and not caring about 2 and 3
05:42:16 <Patashu> !bfjoust lolscounter (>(+)*8)(>(-)*8)*4(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:42:19 <EgoBot> Score for Patashu_lolscounter: 0.0
05:42:29 <Patashu> !bfjoust lolscounter (>(+)*8>(-)*8)*4(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:42:33 <EgoBot> Score for Patashu_lolscounter: 36.6
05:42:49 <Patashu> because now it doesn't beat lols
05:42:56 <Patashu> !bfjoust lolscounter (>++>--)*4(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:42:59 <EgoBot> Score for Patashu_lolscounter: 42.2
05:43:11 <Patashu> !bfjoust lolscounter (>+++>---)*4(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:43:14 <EgoBot> Score for Patashu_lolscounter: 44.1
05:43:28 <Patashu> !bfjoust lolscounter (>--->+++)*4(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:43:31 <EgoBot> Score for Patashu_lolscounter: 50.2
05:44:04 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:44:07 <EgoBot> Score for Patashu_lolscounter: 51.9
05:44:55 <Patashu> why is [+[-]] so effective?
05:44:58 <Patashu> we need some bf joust science in here
05:45:26 <myndzi> because it's reasonably fast and skips small decoys
05:46:50 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*18[[-]+])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:46:52 <EgoBot> Score for Patashu_lolscounter: 5.9
05:46:55 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*18[[-].])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:46:58 <EgoBot> Score for Patashu_lolscounter: 45.7
05:47:04 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*18[[-]-])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:47:07 <EgoBot> Score for Patashu_lolscounter: 16.7
05:47:17 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*18[[-].+])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:47:21 <EgoBot> Score for Patashu_lolscounter: 17.4
05:47:23 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*18[[-].-])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:47:26 <EgoBot> Score for Patashu_lolscounter: 12.9
05:47:27 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*18[[-]..])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:47:30 <EgoBot> Score for Patashu_lolscounter: 55.9
05:47:46 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*17[+[-]..])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:47:49 <EgoBot> Score for Patashu_lolscounter: 33.4
05:47:53 <Patashu> !bfjoust lolscounter (>---->++++)*4(>(+)*18[[-]..])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:47:54 <ais523> !bfjoust defend9 http://pastebin.ca/raw/1439042
05:47:56 <EgoBot> Score for Patashu_lolscounter: 61.4
05:48:08 <ais523> why don't I get a score?
05:48:10 <EgoBot> Score for ais523_defend9: 46.1
05:48:12 <myndzi> yep, i'm totally not going to bother with this until the random gets fixed
05:48:28 <Patashu> the defends work by waiting until your flag is under attack
05:48:32 <leonid_> !bfjoust lols ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,(>(-)*18)*9(>[-[+]])*18
05:48:35 <EgoBot> Score for leonid__lols: 64.8
05:48:37 <Patashu> then going back and forth and attacking the other side of the map while keeping your flag off 0?
05:49:15 <ais523> my program beats keke2, slowrush, lols, and lols3
05:49:23 <ais523> it's beaten 3pass too, in my tests at home
05:49:29 <ais523> just it doesn't on short tapes
05:49:32 <psygnisfive> nevermind. this is all completely ridiculous. :P
05:49:42 <Patashu> we are the philosopher god kings of bfjoust
05:49:46 <Patashu> you just can't comphrend our genius
05:49:54 <myndzi> well, obviously since i don't have a local interpreter and have only been using the bot
05:50:01 <leonid_> you spelled comprehend wrong
05:50:04 <myndzi> it would seem that my optimizations are probably crap
05:50:18 <Patashu> you can do a lot of it with just thought experiments
05:50:19 <myndzi> since they're more likely randomness exploits
05:50:24 <leonid_> myndzi, put some ','s at the end lmao
05:50:30 <myndzi> i'm not gonna stoop to that
05:50:38 <psygnisfive> especially if you put on thought lab coats and use thought chemicals
05:50:56 <myndzi> i'd rather get points based on the actual value of my code :P
05:51:04 <psygnisfive> everythings better with lasers. ESPECIALLY thought experiments
05:51:16 <Patashu> actually yeah it would be good if it ran every permutation instead of using hash-based randomness
05:51:42 <myndzi> or just use randomness NOT BASED ON USER INPUT
05:51:57 <Patashu> just resubmit the same thing
05:52:03 <leonid_> how about just setting the fixed tape size and revise some rule?
05:52:16 <ais523> I spent several /hours/ on defend9
05:52:17 <myndzi> fixed tape size has a fixed solution
05:52:34 <myndzi> Patashu: the thing about that is
05:52:40 <myndzi> at least the matchups will change every time
05:52:45 <myndzi> with hash based on programs
05:52:54 <myndzi> if someone else submits their program it'll change the results
05:54:28 <myndzi> you know what i mean, right!?
05:54:44 <ais523> Patashu: what are you doing to beat defend9 so much?
05:55:00 <myndzi> but yeah, i was saying it should probably be multiple samplings when i first got in here :P
05:55:05 <ais523> Patashu: hardly anyone else can beat it, you beat it a lot though
05:55:19 <Patashu> it's not like I set anything up specifically to counter defend9
05:55:34 <Patashu> your guess is better than mine
05:55:35 <myndzi> what he's doing is not looping on it
05:55:51 <myndzi> also i wouldn't use that word "can"
05:55:52 <Patashu> only juggernaut is a non-looping attacker
05:56:11 <leonid_> okay i'm going to rewrite my code from scratch without relying on hash values
05:56:29 <ais523> patashu_lazy never hits my tripwire
05:56:59 <Patashu> lazy is a non-looping attacker too yeah
05:57:09 <ais523> I should be able to deal with nonloopers
05:57:15 <myndzi> so is rushpolarity or whatever
05:57:16 <ais523> but only if the tripwire's actually hit at some point
05:57:32 <myndzi> ais523: we can go back and forth on cell-specific attacks and defenses all day :P
05:57:40 <myndzi> i can write programs to beat your defend* series
05:57:44 <Patashu> well that's the point isn't it
05:57:47 <myndzi> and you can modify them to beat my programs
05:57:50 <myndzi> which i can modify to beat yours
05:57:55 <ais523> myndzi: well, defend9 is general
05:57:57 <myndzi> nah, the point is to win regardless! :)
05:58:02 <ais523> it detects 12 different sorts of attack loops
05:58:08 <myndzi> ah, tbh they are sorta tl;dr
05:58:09 <ais523> and uses a lock-in-place for each of them
05:58:17 <Patashu> !bfjoust juggernaut +(>(-)*128.--++)*29
05:58:21 <EgoBot> Score for Patashu_juggernaut: 30.0
05:58:22 <Patashu> !bfjoust juggernaut +(>(-)*128.-.-.+++)*29
05:58:23 <myndzi> i'll have to take a closer look
05:58:27 <EgoBot> Score for Patashu_juggernaut: 22.8
05:58:33 <Patashu> !bfjoust juggernaut +(>(-)*128.--++.-.+.-+)*29
05:58:36 <EgoBot> Score for Patashu_juggernaut: 28.8
05:58:45 <Patashu> !bfjoust juggernaut +(>(-)*128.--++.-.+)*29
05:58:48 <EgoBot> Score for Patashu_juggernaut: 22.8
05:58:51 <Patashu> !bfjoust juggernaut +(>(-)*128.--++.-+)*29
05:58:54 <EgoBot> Score for Patashu_juggernaut: 22.8
05:58:57 <myndzi> i don't know how you can say it 'detects' anything when it's sitting on a [] though?
05:59:06 <myndzi> i guess by reading the aftermath to the right of your tripwire eh
05:59:08 <Patashu> !bfjoust juggernaut +(>(-)*128.--++)*29
05:59:08 <ais523> myndzi: it has two tripwires
05:59:12 <EgoBot> Score for Patashu_juggernaut: 28.6
05:59:22 <myndzi> ha, i knew that word would catch on btw :)
05:59:22 <Patashu> !bfjoust juggernaut +(>(-)*128.--++.-.+.-+)*29
05:59:25 <EgoBot> Score for Patashu_juggernaut: 29.4
05:59:26 <ais523> it times the difference in time it takes the enemy to trip the second, compared to the first
05:59:38 <ais523> and by using the timing, it works out how many instructions the opponent has in its main loop
05:59:51 <Patashu> whoops it got pushed off already :)
06:00:06 <myndzi> interestingly enough, i was playing with a counter to that earlier
06:00:06 <Patashu> this is how you use brainfuck
06:00:14 <Patashu> huge unwieldy constructs to solve simple problems
06:00:14 <myndzi> an attacker that tries multiple different timings in the attack
06:00:36 <Patashu> !bfjoust lazy >(+)*5>(-)*5>(+)*5>(-)*5>(-)*5>(+)*5>(+)*5>(-)*5(>(-.)*256)*21[-]((-)*2048(+)*2048.)*2
06:00:42 <EgoBot> Score for Patashu_lazy: 15.2
06:00:47 <Patashu> !bfjoust lazy >(+)*5>(-)*5>(+)*5>(-)*5>(-)*5>(+)*5>(+)*5>(-)*5(>(-.)*129)*21[-]((-)*2048(+)*2048.)*2
06:00:52 <EgoBot> Score for Patashu_lazy: 40.4
06:01:29 <Patashu> you know with the sheer -length- of defend9, shade, etc
06:01:33 <myndzi> oh, that's what the ([)*s are about
06:01:37 <Patashu> I think we need a bfjoust metalanguage
06:01:41 <Patashu> to express such immense constructs
06:01:43 <ais523> myndzi: I did it with ([{}]) first
06:01:48 <myndzi> Patashu: that was kinda the point of ()
06:01:51 <ais523> but despite the program being correct, egojoust couldn't parse it
06:01:54 <Patashu> that only handles one kind of expansion
06:01:55 <myndzi> ais523: yeah, i didn't think ([) was supposed to work
06:02:05 <ais523> bsmntbombdood: http://esolangs.org/wiki/BF_Joust
06:02:13 <Patashu> it doesn't handle something like (foo)*9(bar)*8(foo)*10(bar)*7...
06:02:17 <ais523> defend9 is autogenerated from a perl script, btw
06:02:29 <myndzi> i'd have done the same
06:02:42 <Patashu> only know visual basic and jav
06:02:53 <myndzi> you know, the idea behind defend (the back and forth) was one of the first ideas i had about this game, and i never wrote it
06:02:59 <myndzi> 'cause i saw defend6 and was like "oh, already been done" ;)
06:03:14 <myndzi> so it's nice to see it work!
06:03:44 <myndzi> the thing about detecting the program loop speed is pretty crazy though, well done
06:03:57 <psygnisfive> guys, do any of the languages you speak say things (roughly) like this: "John is at happy" or "John is at doctor" for "John is happy" and "John is a doctor", respectively?
06:06:24 <myndzi> hm, that gives me something of an idea
06:08:24 <myndzi> but i guess it doesn't apply to defend9
06:08:33 <myndzi> your tripwire sits on the +20 right?
06:12:23 <EgoBot> Score for leonid__lols: 0.0
06:12:25 <EgoBot> Score for leonid__lols2: 0.1
06:12:29 <EgoBot> Score for leonid__lols3: 0.1
06:12:37 <Patashu> suicide is your only option
06:12:59 <leonid_> i lost interest at all after realizing all my work was a cheat
06:13:18 <myndzi> i tried to set my programs back to their 'purest' forms
06:13:20 <Patashu> then we'll all have fun in our liberal utopia :)
06:13:21 <Patashu> !bfjoust matador >+[]<(++-)*1000+(--+)*1000(>)*9(>[+][-])*21
06:13:25 <EgoBot> Score for Patashu_matador: 31.2
06:13:27 <Patashu> !bfjoust juggernaut +(>(-)*128.--++.-.+.-+)*29
06:13:27 <myndzi> i.e. the ones that i can decide a reason for
06:13:30 <EgoBot> Score for Patashu_juggernaut: 30.8
06:13:34 <Patashu> I'll pop those on to replace your <s
06:13:39 <myndzi> rather than while i was trying to beat a certain program and wasn't sure why it worked
06:13:45 <Patashu> !bfjoust electrictrain (>(+)*10)*4(>(-)*10)*5([-][-][+][+]>)*20
06:13:49 <EgoBot> Score for Patashu_electrictrain: 31.9
06:13:54 -!- nooga has joined.
06:13:59 <myndzi> i'll take those wins thx
06:14:22 <leonid_> !bfjoust lols t(-_-t)....(>'-')>....\(+_+)/(>_>)
06:14:25 <EgoBot> Score for leonid__lols: 0.0
06:14:44 -!- whoppix has joined.
06:14:56 <Patashu> btw. if it doesn't parse it's like suicide on the 0th turn
06:15:08 <leonid_> !bfjoust lols t[-_-t]-....[>'-']>....\[+_+]/[>_>]
06:15:10 <EgoBot> Score for leonid__lols: 11.2
06:15:28 <myndzi> so that'd suicide on the 1st turn?
06:15:43 <Patashu> so random symbols are fine
06:15:49 <myndzi> yeah, they are comments
06:15:51 <Patashu> but you can't have () without a *num
06:16:13 <leonid_> !bfjoust lols How the fuck do I win this shit aahrgrgarghargarjgklsajgsgslskarjagrgj
06:16:17 <EgoBot> Score for leonid__lols: 17.5
06:18:52 <whoppix> Thing I was wondering about.. If one has a simple state machine, like f.ex. brainfuck, shouldn't it be relatively easy to detect infinite loops, by checksumming the machines state at the start of a loop, and after each iteration, check if the state (or any state in that loop) recurred?
06:19:03 <whoppix> Might be that I'm thinking wrong, I'm pretty tired already :)
06:19:29 <Patashu> you can make arbitrarily complex work happen within an infinite loop
06:19:37 <leonid_> didn't turing said halting problem isn't solvable
06:19:45 <Patashu> it's not in the general sense
06:20:22 <whoppix> Patashu, sure, I don't aim to solve the halting problem, I was just wondering if detection of simple infinite loops at runtime would work that way.
06:20:40 <leonid_> suppose a language LOL has only one instruction L, which loops forever
06:20:40 <ais523> you can detect some infinite loops, just not all of them
06:20:51 <leonid_> then one can check if a LOL program halts or not.
06:20:54 <Patashu> making an algorithm to detect simple infinite loops or a certain kind of infinite loop is easy
06:21:00 <pikhq> whoppix: Good luck.
06:21:39 <whoppix> pikhq, yeah, I know, input/output blows the whole thing up :)
06:21:59 <pikhq> And that method would fail with +[>+]
06:21:59 <Patashu> now the human is just part of the program :)
06:21:59 <psygnisfive> whoppix: some infinite loops are impossible to detect tho, because whether they exit or not depends on changes that occurred during looping
06:22:17 <psygnisfive> and in order to determine whether or not it will ever exit, you have to RUN the loop
06:22:29 <whoppix> pikhq, not if the array of cells wraps at some point
06:22:42 <pikhq> Then it's a finite state automaton.
06:22:47 <psygnisfive> if its an infinite loop, obviously running it will never end, and you will never get a "no, does not exit" notification.
06:22:48 <ais523> !bfjoust defend9 http://pastebin.ca/raw/1439062
06:23:00 <pikhq> The FSA halting problem is solvable by a Turing machine.
06:23:03 <EgoBot> Score for ais523_defend9: 58.9
06:23:26 <ais523> I decided to improve the detection
06:23:43 <ais523> and also, there's a small change to block patashu_lazy-like strategies
06:23:47 <whoppix> psygnisfive, yes, that was the intention - run it, and then check for a recurring state. If the state doesn't change, and there is no input in the loop, well, it must be infinite.
06:23:54 <Patashu> patashu_lazy is the laziest program
06:24:11 <ais523> although I see patashu_lazy beats it anyway
06:24:14 <psygnisfive> whoppix: its not just about recurring state
06:24:30 <ais523> oh well, I shall just have to wait for it to fall off
06:24:36 <ais523> unless you updated with *129, or something
06:24:39 <pikhq> psygnisfive: No. +[] is valid on a non-TC Brainfuck.
06:24:43 <pikhq> And it doesn't halt.
06:24:56 <whoppix> psygnisfive, well, assuming that we have a limited amount of cells (wrapped or not), somewhen the state has to recur
06:25:01 <ais523> I'd have to set the flag to 128+71 in order to block /all/ strategies of that kind
06:25:05 <ais523> and that would take too long
06:25:16 <ais523> so there's always going to be some amount of changing that hits the flag, but not the tripwire
06:25:23 <whoppix> (given that those cells also have a max value which wraps or throws an error if you try to increase it)
06:25:25 <psygnisfive> whoppix: if you have a limited number of cells, it cant be turing complete. unless im missing something.
06:25:50 <whoppix> psygnisfive, sure, I never said it had to be
06:26:02 <psygnisfive> so in those cases, yes, you should be able to detect infinite loops, since itd be an FSA.
06:26:06 <ais523> so: I lose to lazy, rushpolarity, speedy1, viper, and slowrush
06:26:19 <leonid_> !bfjoust lols http://pastebin.ca/raw/1439066
06:26:23 <EgoBot> Score for leonid__lols: 17.5
06:26:40 <whoppix> Talking about halting problems, has this been posted here already? http://www.getacoder.com/projects/detect_loop_106243.html
06:27:02 <ais523> the loss to viper is a misdetection
06:27:06 <pikhq> psygnisfive: But there are things that don't halt that aren't Turing machines!
06:27:19 <Patashu> I changed lazy so it doesn't beat defend9 but it beats more things overall
06:27:23 <pikhq> ((lambda (x x)) (lambda (x x))) ;!
06:27:36 <Patashu> but it might be because of ~~~:'(HASH BASED RANDOMNESS:'(~~
06:28:30 <ais523> as is the loss to speedy1, but despite the misdetection it would still win if the tape length were just right, by coincidence
06:28:54 <leonid_> !bfjoust lols http://pastebin.ca/raw/1439069
06:28:56 <EgoBot> Score for leonid__lols: 0.0
06:29:04 <ais523> the loss to slowrush is because slowrush is so slow in reducing a value to 0 the tripwire timing doesn't work
06:29:43 <Patashu> if it's modified to run all tape lengths and both polarities
06:29:50 <Patashu> should all tape length matches have equal weighting?
06:30:08 <Patashu> the case of 30 length in particular is interesting since you can trivially code a program to behave differently for the 30-length tape
06:30:35 <psygnisfive> anything that doesnt halt /is/ a turing machine, just not a UNIVERSAL turing machine.
06:30:54 <pikhq> Sorry; forgot that distinction.
06:30:55 <ais523> and rushpolarity acts different ways on alternate steps
06:31:02 <ais523> so the detection code doesn't help there
06:31:19 <psygnisfive> put another way, the only way to get non-halting behavior is to have a Type-0 grammar
06:31:34 <leonid_> !bfjoust lol http://pastebin.ca/raw/1439071
06:31:38 <EgoBot> Score for leonid__lol: 18.4
06:31:56 <psygnisfive> ignoring, ofcourse, trivial non-halting behavior like S -> S or similar.
06:31:57 <Patashu> or whenever it gets updated
06:32:05 <ais523> leonid_: weren't you second a while ago?
06:32:15 <Patashu> yeah by abusing ~~~:'(HASH BASED RANDOMNESS:'(~~
06:32:20 <leonid_> i was annoyed that those codes were hash code abusal
06:32:20 <psygnisfive> productions of recursive rules dont halt, but parsings of them do.
06:33:05 <psygnisfive> i suppose that sort of "infinite loop" is possible, but its trivial, and its the sort that is easily detectable.
06:33:08 <ais523> one interesting point is that there are some programs which have hovered at around the same board position forever
06:33:20 <ais523> and some which have been really near the top, then plummeted
06:33:29 <ais523> like vibration_fool_fast
06:33:40 <psygnisfive> but you do need a TM for non-trivial loops.
06:33:43 <Patashu> rushpolarity seems to have relatively good staying power
06:33:49 <leonid_> is vibration a good strategy?
06:34:03 <leonid_> if so, where's dossar when we need him
06:34:27 <ais523> just you'd need to combine it with something defend9-style
06:34:38 <ais523> also, it's more or less defeated by the [+[-]] trick
06:34:53 <leonid_> what specifically does [+[-]] do?
06:35:09 <ais523> leonid_ alternately increases and tests for zero
06:35:19 <Patashu> it goes like this: +, -]-]-]...until cell starts at zero on the turn a ] is executed
06:35:21 <Patashu> then next turn it tests again
06:35:22 <ais523> there are several cases
06:35:24 <whoppix> leonid_, increase the current cell, decrease it until its zero, increase it...
06:35:32 <ais523> but it won't leave the loop until the cell is zero twice in a row
06:35:34 <Patashu> if it's still zero it moves on, else it goes back to the + at the start and goes into -]-]-]... again
06:35:41 <Patashu> ] is a nop except for testing btw
06:35:46 <ais523> so the only way a vibration program could beat a [+[-]] program would be defend9-style
06:36:08 <ais523> but how would it know that the enemy was in a [+[-]] loop?
06:36:17 <ais523> it would have to guess, AFAICT
06:36:22 <ais523> which is why vibration tends not to do well
06:36:32 <Patashu> [+[-]] is pretty optimal innit?
06:36:41 <leonid_> will there be a bf code that wins every code?
06:37:07 <ais523> leonid_: I suspect any program could be beaten by another program specifically designed to beat it
06:37:28 <Patashu> basically if you're on a flag, [+[-]] won't leave until you've won
06:37:40 <Patashu> which means your opponent has to win first OR keep you stalled and run forward and try and win itself
06:37:41 <ais523> so the only thing the opponent can do is capture your flag
06:37:43 <Patashu> which is what defends try to do
06:37:51 <leonid_> then if a person designs beatrank1 and spams it throughout the hill, the rank will be reversed
06:38:01 <ais523> leonid_: but how to spam?
06:38:02 <Patashu> what if it ONLY beats the rank 1 program though
06:38:07 <ais523> each of the spam programs would be eliminated
06:38:15 <ais523> unless they were good enough to beat some of the other programs already there
06:38:19 <Patashu> so it can only go so high on the hill
06:38:26 <Patashu> as more copy programs beat the winner and nothing else
06:38:29 <Patashu> they'll gain less and less momentum
06:38:33 <Patashu> and only be able to fill spots up to a certain level
06:38:35 <leonid_> like a person in rank2 can do that
06:39:15 <ais523> in order to really pull off that strategy, your program would need to beat the whole hill...
06:39:33 -!- oerjan has joined.
06:39:39 <Patashu> beating the top player is a decent boost
06:39:52 <Patashu> the program has to be legitimately good for the most part
06:40:00 <ais523> I've been jousting all night
06:40:02 <oerjan> seen my Eodermdrome program?
06:40:11 <ais523> interp, or program written in Eodermdrome?
06:40:16 <ais523> the world is sadly lacking in either
06:40:31 <ais523> although IIRC someone here wrote an Eodermdrome interp, but I've never seen it
06:40:45 * oerjan vaguely recalls oklopol mentioning it
06:40:52 <ais523> oerjan: is it on Esolang?
06:41:11 <oerjan> also on my home page with ASCII drawings
06:41:22 * oerjan needs to add a small comment
06:42:20 <ais523> that certainly looks impressive
06:42:27 <ais523> I want to test it now, and can't...
06:42:32 <ais523> maybe I'll write an interp of my own to test it on
06:43:00 <oerjan> it would be even more impressive if it happens to have no bugs of course
06:43:11 <Patashu> !bfjoust rushpolarity >((+)*20>(-)*20>(-)*20>(+)*20)*2>((+)*10[+[-]](+)*20>(-)*10[-[+]](-)*20>)*11
06:43:15 <EgoBot> Score for Patashu_rushpolarity: 68.4
06:43:44 <ais523> oerjan: I like the way you tried to make your words pronouncable
06:45:02 <ais523> Patashu: gah, you pushed defend9 down to fifth by making rushpolarity better
06:45:15 <oerjan> added comment: Note: BCT program part should be at least 3 characters long.
06:45:44 <oerjan> (if the current command ends in 0 and that is the whole program, the deletion and appending of it conflict
06:45:57 <ais523> A much bigger challenge would be to write an eodermdrome BCT interp which was also valid English
06:46:05 <ais523> the whitespace deletion around punctuation was designed to make that possible
06:46:10 <ais523> but it would still be pretty difficult
06:47:00 <Patashu> best permutation I can find is:
06:47:00 <Patashu> !bfjoust rushpolarity >((+)*20>(-)*20>(-)*20>(+)*20)*2>((+)*20[+[-]](+)*18>(-)*20[-[+]](-)*18>)*11
06:47:01 <oerjan> ais523: my design just squeezes in btw, the 11/1 case uses 23 characters
06:47:04 <EgoBot> Score for Patashu_rushpolarity: 71.7
06:47:20 <ais523> oerjan: 23 /different/ characters?
06:47:47 <ais523> I'm relatively sure it would be possible to cut a long rewrite into two smaller rewrites
06:48:11 <oerjan> ais523: i think maybe if you handle program and data part separately that might work
06:48:30 <oerjan> i do each step in one substitution
06:49:17 <ais523> time to go home, anyway
06:49:23 <myndzi> < Patashu> basically if you're on a flag, [+[-]] won't leave until you've won
06:49:32 <myndzi> i am a little confused as to why [[-]] doesn't seem to do that
06:49:54 <myndzi> the cell would have to be 0 two instructions in a row to leave that loop
06:49:59 <myndzi> but every time i've tried it it hasn't worked
06:52:43 <myndzi> i was thinking possibly so
06:53:32 <Patashu> just to see if the comment breaks it up XD
06:54:01 <myndzi> i don't know, i wouldn't really be able to tell if it works or not atm
06:54:09 <myndzi> i'm hesitant to twiddle the programs i already have because of the randomness thing
06:54:26 <myndzi> it just seems like [[-]] or [[+]] never did nearly as well as expected
06:54:37 <myndzi> whereas something like [-.] did much better
06:55:07 <myndzi> i think i'll wait till something is done about the randomness or ehird completes his interpreter
06:56:34 <Patashu> if we changed the rule of 'flags need to be at 0 for 2 consecutive cycles' to 3 consecutive cycles
06:56:39 <Patashu> how would it change the nature of the game?
06:57:17 <myndzi> probably about the same as my suggestion to have [] test at the end instead of beginning of a cycle
06:57:27 <myndzi> or actually, you could do something like have [ test at the start and ] at the end, possibly
06:57:36 <myndzi> anyway, it would enable someone to sit on their flag and react when it became 0
06:57:54 <oerjan> ais523: a reasonably efficient Eodermdrome interpreter probably needs to be somewhat clever, since the language is based on an NP-complete problem
06:57:56 <myndzi> which would either give rise to a bunch of ties, unbeatable programs, or add a new aspect and some variety
06:58:46 <Patashu> what about loop while the enemy pointer is here/loop while the enemy pointer is not here?
06:59:00 <Patashu> but that was also multipointer
06:59:54 <myndzi> i think that would just give rise to either ties or uselessness at first blush
07:00:02 <myndzi> i mean, what would you use it for? obviously, keeping them from taking your flag
07:00:27 <Patashu> technically bfjoust is turing complete...err, bounded state machine :)
07:00:38 <myndzi> it's obvious that if one can tell exactly when and where the enemy pointer is, and react to it, they can wait until you leave and then win
07:00:42 <Patashu> but you're also limited on how much time you have to do computation in, and the manner of input you can expect
07:00:43 <myndzi> thus you would never leave since you can tell when they are waiting
07:00:49 <myndzi> and so the best you can hope for is a tie
07:01:09 * leonid_ 's brains can't understand the essence of bfjoust
07:01:25 <Patashu> have you ever looked at the brainfuck algorithms page?
07:01:29 <Patashu> most of them aren't directly applicable to bfjoust
07:01:29 <myndzi> more or less; i suppose you can do defend style trickery, if you decided to try and time things, then you basically have two programs struggling to get a timing that throws the other one off
07:01:40 <myndzi> but really it seems like you'd just end with less variety
07:01:46 <Patashu> but it shows how interesting bf actually is as a language
07:01:52 <Patashu> so simple and unwieldly-looking but turing complete
07:01:55 <myndzi> there's already not exactly an overwhelming variety to begin with :P
07:02:13 <Patashu> http://esolangs.org/wiki/Brainfuck_algorithms
07:02:40 <myndzi> i think if you want to add something, if !0 or if 0 would be good starts. yeah, you can do it with looping brackets, but to do so requires a lot of extra code that just ends up being baggage to the interpreter
07:03:00 <Patashu> ifs with elses or regular ifs?
07:03:05 <myndzi> most other comparisons would require two fields which is even more un-bflike
07:03:23 <myndzi> just regular ifs, i should think, but hey while you're fucking up brainfuck, elses too
07:03:35 <myndzi> let's also add LT and GT!
07:03:51 <myndzi> sit on their flag and div by 2
07:04:05 <Patashu> nothing that can alter a cell value by more than 1 is fair
07:04:18 <myndzi> i'm obviously being facetious :P
07:04:31 <myndzi> i think bfjoust worked out well
07:04:37 <myndzi> of course if it hadn't none of us would still be caring
07:04:48 <myndzi> i don't think there's much you can do to "fix it"
07:05:38 <Patashu> code in a different opcode every few days
07:05:49 <myndzi> i don't think opcodes is the thing to experiment with really
07:06:00 <myndzi> the framework seems a better choice
07:06:05 <myndzi> the goal, the environment, etc.
07:06:14 <Patashu> the environment of bfjoust?
07:06:22 <myndzi> i mean the 10-30 cells
07:06:22 -!- ais523 has quit (Read error: 110 (Connection timed out)).
07:06:25 <myndzi> or what they are initialized to
07:06:41 <Patashu> I think it would be interesting to make suicide NOT a loss
07:06:48 <myndzi> for example, making it wrap around..
07:06:53 <myndzi> would affect things weirdly
07:07:00 <myndzi> but at least keep it a playable game, i think
07:07:06 <Patashu> extend forever or wrap around or falling off is nopping forever
07:07:15 <myndzi> extend forever is just silly
07:07:28 <Patashu> you could have it sweep back and forth though
07:07:32 <Patashu> go to cell 30 then reverse
07:07:32 <myndzi> make it so once you've zeroed their flag you have to take it back to your "base"!
07:07:44 <myndzi> that would nullify lots of strategies
07:07:57 <Patashu> can't make an omlette etc etc
07:07:58 <myndzi> and everyone'd end up writing huge code like defend
07:08:11 <Patashu> and these would all be temporary changes
07:08:12 <myndzi> 'cause that's about the only way you can limit the number of cycles or keep track of where you are
07:08:14 <Patashu> to see who can adapt to each change best
07:08:23 <Patashu> once there's not much left to do in original bfjoust (should that day come)
07:08:26 <myndzi> better held as mini tournaments
07:08:34 <myndzi> not in place of the existing bot
07:08:39 <myndzi> sorta like some of the corewars events
07:09:03 <myndzi> there've been corewars tournaments held where somebody came up with a unique idea/twist
07:09:08 <myndzi> and people wrote programs to submit to them
07:09:26 <myndzi> they play out, winner wins, that's that :P
07:09:31 <myndzi> the hill setup is a lot more interactive
07:09:36 <myndzi> (and putting it as an irc bot even more so)
07:09:51 <myndzi> there's a lot more spamming the hill with multiple slight changes going on here than it seems happens with corewars
07:10:09 <myndzi> of course, most of us don't have local interpreters and debugging environments to get stuff done in before submitting i guess
07:17:33 -!- oerjan has quit ("leaving").
07:17:47 <Patashu> I'm pondering what kind of strategy I haven't tried yet
07:17:49 <leonid_> how do we calculate sqrt with bf
07:17:56 <Patashu> besides something I need to compile from a higher level language
07:18:08 <Patashu> leonid: it's possible because bf is turing complete but I dunno offhand o.O
07:18:30 <Patashu> I know you can do ^2 by copying a number and then multiplying it with itself
07:21:36 <Patashu> and there's code for doing relational operators so
07:21:50 <Patashu> you could implement a slow sqrt by squaring each natural number and comparing it to the original number
07:22:15 <Patashu> until it's greater than then use the number one before that
07:22:46 <Patashu> and I'm sure you can optimize it from there
07:24:57 <leonid_> !bfjoust ugh (>(+-)*10000)*20(>[-[+]])*10
07:25:01 <EgoBot> Score for leonid__ugh: 12.2
07:25:23 <leonid_> !bfjoust ugh nah arghaurgarubjnargefo
07:25:26 <Patashu> try removing the first > then multiply the last step by 30
07:25:26 <EgoBot> Score for leonid__ugh: 16.8
07:25:46 <leonid_> !bfjoust ugh (+-)*200000(>[-[+]])*30
07:25:50 <EgoBot> Score for leonid__ugh: 18.6
07:25:58 <Patashu> just so you know it's limited to 100k cycles atm
07:26:09 <leonid_> !bfjoust ugh (+-)*900000(>[-[+]])*30
07:26:12 <EgoBot> Score for leonid__ugh: 18.6
07:26:18 -!- nooga_ has joined.
07:26:26 <leonid_> bfjoust ugh (+-)*9999999999999999999999999999999999999(>[-[+]])*30
07:27:05 <Patashu> gj it overflows a long long
07:27:39 <Patashu> it ALMOST overflows a long long long
07:28:52 <leonid_> bfjoust ugh (+-)*`ruby -e'p 2**128'`(>[-[+]])*30
07:29:47 -!- GreaseMonkey has joined.
07:30:04 <leonid_> bfjoust ugh ((>[-[+]])*20(<)*20)*10
07:30:14 <leonid_> !bfjoust ugh ((>[-[+]])*20(<)*20)*10
07:30:17 <EgoBot> Score for leonid__ugh: 31.6
07:30:30 <leonid_> !bfjoust ugh ((>[-[+]])*25(<)*25)*10
07:30:34 <EgoBot> Score for leonid__ugh: 32.5
07:30:50 <Patashu> that's an actual mechanical change
07:31:12 <leonid_> !bfjoust ugh ((>[-[+]])*30(<)*30)*10
07:31:15 <EgoBot> Score for leonid__ugh: 36.4
07:31:22 <leonid_> !bfjoust ugh ((>[-[+]])*30(<)*30)*100
07:31:26 <EgoBot> Score for leonid__ugh: 27.7
07:32:04 <leonid_> !bfjoust ugh ((>[-[+]])*29(<)*29)*10
07:32:07 <EgoBot> Score for leonid__ugh: 26.6
07:32:10 <Patashu> if you go all the way to the end of the tape with a [-[+]] construct
07:32:13 <Patashu> and it ends you know you've hit the flag
07:32:31 <leonid_> !bfjoust ugh ((>[-[+]])*30(<[-[+]])*30)*10
07:32:34 <EgoBot> Score for leonid__ugh: 34.1
07:33:32 <leonid_> !bfjoust ugh ((>[-[+]])*20(<[-[+]])*20)*100
07:33:36 <EgoBot> Score for leonid__ugh: 19.3
07:33:55 -!- nooga has quit (Read error: 60 (Operation timed out)).
07:34:10 <leonid_> !bfjoust ugh ((>[-[+]])*30(<[-[+]])*30(-)*100000)*10
07:34:13 <EgoBot> Score for leonid__ugh: 29.9
07:34:27 <leonid_> !bfjoust ugh ((>[-[+]])*30(<[-[+]])*30(+-)*100000)*10
07:34:29 <EgoBot> Score for leonid__ugh: 25.8
07:35:03 <leonid_> !bfjoust ugh ((>[-[+]])*30(<[-[+]])*30(+)*100000)*10
07:35:05 <EgoBot> Score for leonid__ugh: 30.5
07:35:27 <leonid_> !bfjoust ugh ((>[-[+]])*30(<)*30(+)*100000)*10
07:35:30 <EgoBot> Score for leonid__ugh: 34.1
07:36:42 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*5(>)*5(>[-[+]])*15(<)*30)*10
07:36:45 <EgoBot> Score for leonid__ugh: 55.4
07:37:00 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<)*30)*10
07:37:03 <EgoBot> Score for leonid__ugh: 47.1
07:37:07 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<)*29)*10
07:37:09 <EgoBot> Score for leonid__ugh: 62.3
07:37:26 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<)*29(-)*100000)*10
07:37:29 <EgoBot> Score for leonid__ugh: 44.6
07:37:30 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<)*29(-)*10000)*10
07:37:33 <EgoBot> Score for leonid__ugh: 54.6
07:37:45 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*8(>[-[+]])*14(<)*30)*10
07:37:49 <EgoBot> Score for leonid__ugh: 37.4
07:37:58 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*5(>[-[+]])*10(<)*25)*10
07:38:01 <EgoBot> Score for leonid__ugh: 30.3
07:38:06 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<)*29)*10
07:38:08 <EgoBot> Score for leonid__ugh: 62.3
07:38:43 <leonid_> why does my code always beat slowrush lmao
07:39:44 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<[-[+]])*29)*10
07:39:48 <EgoBot> Score for leonid__ugh: 64.5
07:40:43 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*6(>[-[+]])*15(<[-[+]])*27)*10
07:40:45 <EgoBot> Score for leonid__ugh: 39.6
07:40:59 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<[-[+]])*29)*10
07:41:02 <EgoBot> Score for leonid__ugh: 64.5
07:41:12 <leonid_> !bfjoust ugh ((>(+)*31>(-)*31)*7(>[-[+]])*15(<[-[+]])*29)*10
07:41:15 <EgoBot> Score for leonid__ugh: 32.4
07:41:26 <leonid_> k going to spam EgoBot via PM
07:44:50 -!- olsner has joined.
07:50:03 <Patashu> you know, decoy setup time vs attack setup time is an arms race
07:50:19 <Patashu> it's only useful to make bigger decoys because people have bigger attack setup because people make bigger decoys because...
07:52:28 -!- whoppix has quit ("Verlassend").
07:54:35 <nooga_> Patashu: i've never seen you here?
07:54:53 <nooga_> excemp this day an yesterday
07:55:26 <Patashu> yup I recently migrated here
07:55:48 <nooga_> i've been here (probably) from the begining
07:56:46 <nooga_> where are you from? btw
07:56:50 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<)*29)*37
07:56:52 <EgoBot> Score for leonid__ugh: 72.3
07:56:54 <Patashu> (<leonid_> i moved from anagol) <-- same
07:57:26 <Patashu> you know he's korean because he's good at rhythm games
07:57:30 <Patashu> I'm good at rhythm games too O_O
07:58:51 <nooga_> i've tried to learn that script
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:31 <nooga_> i'd rather use <sarcasm>.*</sarcasm>
08:02:41 <myndzi> too bad there's no "age" stat on the hill
08:02:50 <myndzi> that'd be almost more useful/interesting than points at the moment
08:03:12 <myndzi> i guess we could always calculate it from the logs
08:03:23 <myndzi> but that wouldn't include replacement programs
08:03:23 <nooga_> myndzi: are you also from #anagol?
08:04:06 <myndzi> anyway, my nick's been registered for some time but i didn't really come to this network until #corewars did
08:04:30 <myndzi> but i've never been in #anagol
08:23:57 -!- oerjan has joined.
08:36:23 -!- lereah_ has joined.
08:43:19 <oerjan> ssh, i'm here incognito
08:43:52 <nooga_> did you sleep this night? ;p
08:45:45 <nooga_> condols sounds a bit like condoms
08:46:41 <oerjan> maybe to a pole, i hear you do strange things with l's
08:47:26 <nooga_> l in Polish is like l in lame
08:48:22 <olsner> oerjan: the strange things are done to a different l
08:48:23 <nooga_> but it's like wa in watch
08:48:29 <oerjan> yeah if that's not doing strange things with l's i don't know what would count
08:48:58 <oerjan> the poor thing is speared!
08:49:05 <olsner> point is, they're doing it to Ł, not L :)
08:49:57 <olsner> oerjan: have some sour milk, weird norwegian guy
08:50:00 -!- ais523 has joined.
08:50:14 <oerjan> sorry, allergic to milk
08:50:22 <nooga_> olsner: that makes me think that you're weird
08:50:34 <ais523> oerjan: I'm intolerant to milk, as it happens
08:50:41 <olsner> ais523: I involved it, I'm pouring it over oerjan
08:50:45 <nooga_> it's unhealthy to drink milk, for adults
08:50:46 <ais523> not quite the same as being allergic, but it's still unwise for me to drink too much
08:50:54 <myndzi> leonid_: i thought you decided better than to f* around with the rng
08:51:05 <oerjan> ais523: i started reacting to it a few years ago
08:51:28 <oerjan> since last spring i've had to cut it out
08:51:29 <olsner> kurwa is the only useful polish word I can pronounce
08:51:50 <myndzi> my two programs gain 10 and 12 points just for breaking from the tape length you managed to force with your nonsensical program :\
08:52:07 <nooga_> but it's used like fuck in english
08:52:24 <myndzi> you mean fuck as in fornication? :P
08:52:35 <myndzi> or fuck as an exclamation
08:52:51 <olsner> I've been told it's also a cognate of scandinavian 'kurva' (which simply means a bend in a road)
08:53:06 <nooga_> Polish cursewords are quite complez
08:53:28 <nooga_> you can create new oneswhen you need
08:53:37 <myndzi> every language needs that
08:54:09 <nooga_> zajebiście ~= zakurwiście ~= something like awesome
08:54:12 <oerjan> olsner: not cognate, kurva is from latin curvus
08:54:29 <nooga_> jebać is also a word that you can use to create maaaany cursewords
08:54:37 <oerjan> maybe the polish also borrowed it, or it could be polish/latin cognate
08:54:43 <nooga_> it means, literally: to fuck
08:54:56 <oerjan> (but germanic would have turned c/k -> h)
08:55:00 <myndzi> you can certainly create many curse (phrases) with a verb like that ;)
08:55:23 <oerjan> oh wait slavic languages are "satem" group, so they wouldn't keep k either
08:55:30 <nooga_> zajebać = to kill someone, to steal sth; wyjebać = to beat someone, rozjebać = to break sth
08:55:39 <nooga_> najebać (komuś) = to beat someone
08:56:08 <nooga_> przejebane = something is fucked up
08:56:08 <myndzi> i paste together nonsensical polish phrases!
08:56:26 <nooga_> wyjebane = something is awesme
08:56:38 <nooga_> rozjebane = something is broken
08:56:44 <myndzi> how do you even pronounce "prze"?
08:56:51 <olsner> oerjan: wiktionary says kurwa comes from proto-slavic *kury, from proto-indo-european *kowr-, which they say is a cognate with Latin caurio
08:56:55 <myndzi> well, that's a silly question
08:57:04 <myndzi> obviously you pronounce it like you would say it :P
08:57:08 <oerjan> olsner: ah, not the same word then
08:57:14 <nooga_> a bit like english: ptche
08:57:31 <nooga_> words mutate in Polish
08:57:55 <oerjan> nooga_: words mutate everywhere
08:58:01 <oerjan> just not in the same way
08:58:17 <nooga_> at least not in Norwegian AFAIK
08:58:22 <myndzi> i guess that's what you get when you import an alphabet(?)
08:58:29 <myndzi> it's the consonant cluster that is throwing me for a loop
08:58:29 <oerjan> um what do you mean by mutate?
08:58:34 <myndzi> is that supposed to be all one syllable?
08:58:54 <myndzi> since 'p' and 't' are both plosives(?), you can't do them at the same time
08:59:18 <nooga_> hard to explain in english
08:59:23 <myndzi> so i'm imagining some sort of fricative 'p' sound
08:59:41 * oerjan sics a pterosaur on myndzi
08:59:42 * myndzi sics a pterosaur on oerjan
08:59:50 <Gracenotes> I always say "plosive" like "ppppplosive"
08:59:51 <myndzi> (ha you tricky person, silent p!)
09:00:15 <oerjan> myndzi: it wasn't silent in greek
09:01:03 <olsner> almost as exciting as irc-pong
09:01:20 <lereah_> Or that IRC interactive adventure we did :D
09:02:07 <myndzi> must be two syllables then i guess
09:02:17 <oerjan> norwegian doesn't pronounce pt, but we do a mean kn
09:02:17 <nooga_> http://en.wikibooks.org/wiki/Polish/Basic_grammar << that's not all
09:02:54 <oerjan> myndzi: chew on this _georgian_ surname: mgrvgrvladje
09:02:55 <myndzi> at least kn don't conflict :D
09:03:02 <ais523> oerjan: Hungarian is fun, people will try to pronounce anything in that
09:03:12 <ais523> because suffices never change the stem of the word
09:03:16 <ais523> and you can string many of them together
09:03:40 <oerjan> the suffixes aren't really that clustered with consonants, though
09:03:41 <nooga_> you've got basically 5 tenses, 12 declensions, 2 pages, 6 conjugations and some other things
09:04:26 <nooga_> i've heard that Polish is second hardest language, after Finnish
09:04:43 <olsner> does that mean every word comes in 920 forms?
09:04:44 <myndzi> hardest to use or hardest to learn?
09:04:49 <nooga_> but i know Polish so idk
09:04:58 <nooga_> olsner: probably not every
09:05:14 <nooga_> declensions apply to verbs
09:05:20 <nooga_> conjugations apply to nouns
09:05:21 <oerjan> how can finnish be hard, it's agglutinating
09:05:44 <olsner> ah, ok, not as bad as I thought then :P
09:05:59 <oerjan> hardest in europe, _maybe_, but i'm sure there are far worse elsewhere
09:06:02 <ais523> nooga_: Navajo is generally considered to be one of the hardest languages in existence
09:06:12 <nooga_> i've tried to learn rusiian
09:06:24 <ais523> the US military used to use unencrypted Navajo as a secret code
09:06:28 <nooga_> they say it's A BIT simmilar
09:06:31 <ais523> they had to hire native speakers to translate...
09:06:45 <nooga_> but russian declensions ate me
09:06:51 <nooga_> and this stupid srcipt
09:07:36 <lereah_> It won't accept any extra space or newlines
09:07:43 <nooga_> with shitloads ofg macros
09:07:54 <lereah_> What are the macros for that shit?
09:07:57 <oerjan> lereah_: there are lots of spacing commands
09:08:02 <lereah_> I know it's supposed to format automatically
09:08:10 <lereah_> But what are the basic commands for that
09:09:41 <oerjan> lereah_: \hspace{...} and \vspace{...} at least
09:10:03 <oerjan> but the contents are special length units
09:10:12 <nooga_> my read beard is awful
09:10:36 <nooga_> i think i should sleep
09:11:39 <nooga_> my grey matter is black atm
09:12:16 <ais523> hmm... wouldn't that mean you were particularly brainy
09:12:28 <ais523> in the brain, the grey matter does the thinking, and the white matter sends messages long-distance
09:14:19 <nooga_> i'm retarded all the time
09:14:29 <nooga_> my IQ went from 137 to 50
09:14:40 <oerjan> ais523: no it would mean he were scatterbrained as the parts couldn't communicate ;D
09:14:53 <nooga_> i forgot basic words in englis, as well as in Polish
09:15:10 <nooga_> really, really annoying
09:16:43 <nooga_> my mac keyboard does not help though
09:24:08 <ais523> "Lambdas are relegated to relative obscurity until Java makes them popular by not having them."
09:25:03 <ais523> if you've ever tried to program in Java, you'll know how badly it needs lambda
09:25:31 <ais523> Java doesn't have lambdas
09:25:37 <ais523> at least, didn't when I last looked
09:25:56 <Patashu> and java doesn't have them
09:25:56 <ais523> you have to create anonymous classes to have the function you want as a method, which is ridiculous
09:25:58 <Patashu> if that statement was correct lambdas wouldn't be obscure
09:26:01 <ais523> and lambdas aren't really obscure nowadays
09:26:14 <ais523> they're all over the place, even in some of Microsoft's langs
09:29:19 <nooga_> lambdas are the coolest thing that exists in modern mixed paradigm langs
09:29:23 <ais523> Patashu: if you consider yourself a programmer and don't regularly come across lambdas, learn a new language
09:29:42 <Patashu> guess I shouldn't have learned java then
09:29:45 <ais523> although you might end up not repeatedly using them (say if you write in C, probably using a lambda is too high-level), it's common to drown in them
09:30:07 <ais523> Patashu: in Java, where do you put your callback functions for Swing/AWT/
09:30:16 -!- oerjan has quit ("leaving").
09:31:17 <ais523> that's one of the situations in Java where a lambda would be really useful
09:31:43 <nooga_> Jaca does not have closures?
09:31:50 <nooga_> FFFFFFFFFFUUUUUUUUUUUU
09:31:55 <ais523> it would let you specify the functions at the same time that you told the API what they were
09:32:08 <ais523> as opposed to having to find a random instance to attach the functions to
09:32:15 <ais523> you have to put them somewhere, and there's no really good place
09:32:59 <Gracenotes> Java has lexical closures via anonymous classes
09:33:13 <ais523> that's a really complex workaround, though
09:33:17 <ais523> for what /should/ be a simple operation
09:33:32 <Gracenotes> the proposed closures take inspiration from that form, though
09:33:52 <ais523> ah, glad to hear that they're planning to add them
09:34:02 <ais523> let's hope they don't mess them up as badly as they messed up templates
09:34:09 <Gracenotes> well. I'm not sure they'll be added. But there definitely is a proposal, and Gosling's looked at it
09:34:31 <Gracenotes> the template issue is mostly because they wanted backwards bytecode compatibility
09:35:10 <ais523> couldn't they have automatically added casts everywhere the object was used, in the bytecode?
09:36:10 <Gracenotes> casts? Well, you could have heterogenous collections in the older version
09:36:30 <Gracenotes> it'd have to make all casts be to Object.
09:36:34 <ais523> yes, but you had to cast them in order to get them to work
09:36:51 <ais523> I mean, type bleaching does nothing if you have a collection of Object anyway
09:37:06 <ais523> so suppose you have a new collection of Dog, or something
09:37:21 <ais523> you can cause the bytecode to, instead of returning a Dog, return an Object then cast it to Dog
09:37:22 <Gracenotes> well, you had to cast them to make them work, but that's usage, not internals...
09:37:31 <ais523> so that the new code uses Dogs, but the old bytecode uses Objects
09:37:39 <ais523> so you have bytecode compatibility + sanity
09:39:44 <ais523> but they were bought out by Oracle!
09:40:41 <Gracenotes> and they will send out their video game-like security to make you pay! :o
09:41:08 <ais523> what, video games use physical security nowadays?
09:41:53 <Gracenotes> I mean, it's tron. just go with it. >_>
09:43:22 <ais523> hmm... jump2 is now way down the rankings
09:43:29 <ais523> have people been taking steps specifically against it, I wonder?
09:43:44 <myndzi> ais523: leonid_ has been fucking with the RNG
09:43:54 <myndzi> that's all the activity i've noticed on and off
09:43:57 <ais523> myndzi: that's only one program, though
09:44:01 <myndzi> i keep tweaking my programs back and forth just to mess with him
09:44:09 <Patashu> you guys still going in secret?
09:44:25 <myndzi> once every hour maybe for me, i'm just keeping an eye out
09:44:30 <ais523> it's all logged by egobot anyway
09:44:59 <myndzi> i didn't do anything against jump that i didn't do when you put it on in the first place
09:45:20 <ais523> and it's not as if it affects most of your best programs
09:45:28 <myndzi> the rankings seem to change quite a bit with just the 2 or 3 move around
09:45:55 <myndzi> but it looks like Patashu's contributions and whatever the hell else has gone on in the past few hours seem to have cut into my lead :(
09:46:11 <ais523> yep, rushpolarity is way up
09:46:27 <ais523> I wonder if I could get away with using three tripwires in defend9 to beat that sort of thing?
09:46:29 <myndzi> and the other one is sometimes too
09:47:02 <myndzi> it doesn't appear to do anything particularly tricky
09:47:04 <Patashu> to try and figure out the opponent's loop
09:47:05 <ais523> myndzi: changing strategy from step to step
09:47:08 <Patashu> but it doesn't work if it alternates loops
09:47:10 <ais523> which confuses defence9
09:47:21 <ais523> I'm rather proud of defend9
09:47:26 <ais523> and have thought of some improvements to it
09:47:28 <myndzi> yeah, it's pretty impressive
09:47:29 <Patashu> but what if I used three different loops
09:47:31 <ais523> which I'll have to try sometime
09:47:38 <myndzi> i'm not sure there's anything you can do against a changing attack though
09:47:55 <ais523> yep, but changing attacks are possibly weaker anyway
09:48:07 <ais523> as you're using three strategies, one of them has to be suboptimal
09:48:08 <myndzi> Patashu: just curious, did you pick that up from keke2 earlier or just arrive at the same conclusion?
09:48:23 <myndzi> ais523: perhaps, but it may not need all that much effort
09:48:29 <myndzi> and many of them will succeed regardless
09:48:41 <Patashu> rushpolarity was my original idea, I didn't look at any other programs that alternated
09:48:54 <myndzi> it's not the same thing when i look at it
09:49:16 <myndzi> i was trying to (originally) do some sort of attack that kept changing timing
09:49:21 <myndzi> turned out most if it didn't matter
09:49:42 <myndzi> but the swap from + to - throws off his timing stuff i bet
09:50:20 <myndzi> ais523: you could potentially, at least to detect specifically Patashu's reversal thing, use numbers that count the same both ways .. if you know how to read them
09:51:05 <myndzi> anyway, it's well past my bedtime
09:51:31 <myndzi> i hope i still have anything on the hill tomorrow when i wake up ;P
09:51:34 <ais523> I specifically didn't use numbers that count the same both ways
09:51:44 <ais523> otherwise, how would I know which polarity to counteract with?
09:51:57 <ais523> more interesting would be counteractions which worked the same both ways
09:52:08 <ais523> defend6 had one of them for two-cycle loops
09:52:11 <myndzi> i was probably just confusing myself
09:52:14 <Patashu> you keep using + or - to push them over every 0 on your flag
09:52:20 <ais523> I wonder if that would be possible for other quantities
09:52:21 <Patashu> and use the intermittent time to run forward and attack each spot in turn
09:52:30 <Patashu> until every possible flag has been taken down
09:52:35 <ais523> I use a long string of + or - to prevent the value ever going near 0
09:52:43 <ais523> I can change faster than the opponent can
09:52:50 <ais523> as I'm doing (+)*128, they're in a loop
09:52:53 <Patashu> oh, because it's all unrolled
09:52:56 <myndzi> unless the opponent isn't looping
09:53:04 <Patashu> they don't know they're on your flag, but you do
09:53:09 <ais523> myndzi: defend9 doesn't deal with nonlooping opponents
09:53:17 <myndzi> i'm gonna run at you with a -.-..-... loop
09:53:25 <myndzi> (wait, that wouldn't work... :P)
09:53:36 <ais523> and I use the inbetween time to run over to all possible flags and sink them a bit at a time
09:53:43 <myndzi> better: (-.)*256>(-..)*256
09:54:06 <ais523> myndzi: then I'll just beat you with speedy1
09:54:40 <myndzi> i'm just thinking it'd be more fun to tweak your timing than do something else
09:54:55 <ais523> defend9 is definitely beatable, ofc
09:55:05 <ais523> I'm just wondering if taking steps just to beat it would hold you back against other programs
09:55:08 <myndzi> my favorite thing about defend6 was that it suicided
09:55:37 <myndzi> unless defend9 starts beating everything it won't gain you that many points to beat it
09:56:06 <myndzi> and if it's beating everything, it may become worth it (and also more feasible)
09:56:08 <ais523> defend6 does, indeed, suicide
09:56:11 <ais523> under certain circumstances
09:56:18 <myndzi> like, if you don't touch the flag
09:56:22 <ais523> defend9 can too, but it's a lot harder to persuade it to
09:56:33 <Patashu> !bfjoust juggernaut +(>(-)*128.(-.)*512>(+)*128.(++.)*512)*15
09:56:37 <EgoBot> Score for Patashu_juggernaut: 31.9
09:56:38 <ais523> however, hitting a decoy and two tripwires, but not the flag, would take quite some doing
09:56:39 <Patashu> not sure what to do with this one
09:56:56 <myndzi> just a slow moving program
09:57:00 <myndzi> that's how i did it the first time
09:57:04 <ais523> myndzi: trouble is, that wouldn't beat anything else
09:57:23 <myndzi> even after i slowed it down to handle the inverse
09:57:32 <myndzi> it didn't get top scores but it stuck around a while
09:57:38 <myndzi> i consider that one mark of usefulness at least
09:57:41 <Patashu> that beats defend 6,7,9, jump2, speed1 and ugh
09:57:59 <myndzi> ugh is just another pointless wtfscript
09:58:06 <ais523> Patashu: htf does that beat speedy1?
09:58:09 <myndzi> he advances to the right 30 times then goes back to the left(??)
09:58:18 <myndzi> and loops this process
09:58:19 <Patashu> misread, it doesn't beat speedy1
09:58:31 <Patashu> it beats waiter, defend6-7-9, jump2 and ugh
09:58:39 <lereah_> The tutorial sounds so smug
09:58:48 <lereah_> I just want to punch my screen.
09:58:50 <myndzi> he just wrote it wrong
09:58:51 <ais523> jump2 seems likely to fall off soon
09:58:57 <myndzi> it goes to the 30th position then tries to go back to the start
09:59:00 <myndzi> but then it only goes right 15
09:59:12 <myndzi> of course, it will only ever hit the 'go back to the left' stage 1/20th of the time
09:59:15 <ais523> going to the 30th position is dubious anyway
09:59:21 <ais523> if you get there, why not just sink the flag?
09:59:29 <Patashu> leonid has no idea what the fuck is going on that's why
09:59:29 <ais523> after all, you know it's there
09:59:37 <myndzi> he's just putting random shit in until he gets good random numbers that give him a good score
10:00:05 <ais523> well, I confess that I was seedtampering with defend9 to stop it getting random very short tapes
10:00:13 <ais523> but only against programs that lose to it on nearly every tape length
10:00:23 <ais523> but beat it on exceptionally short ones
10:00:30 <myndzi> heh, i did that unknowingly earlier too
10:00:40 <myndzi> most variants would win and all of a sudden a tie.. wat?
10:00:45 <myndzi> gotta fix that, try to change the timing a little
10:00:50 <myndzi> didn't know it wasn't timing that was doing it
10:01:09 <myndzi> now i was just doing it to drop leonid_ back down the hill :P
10:01:44 <myndzi> there's gotta be a better solution
10:01:48 <myndzi> i just don't know what
10:01:53 <ais523> I could probably improve defend9 by putting some counterdefence in
10:02:01 <ais523> myndzi: ehird's try-all-lengths interp might be it
10:02:09 <myndzi> i was thinking that may not be so hot
10:02:15 <myndzi> i was about to comment on it but i couldn't phrase it well
10:02:47 <myndzi> it's desirable in that it takes random chance out of the game and makes set-length attackers useless
10:03:21 <myndzi> i worked out what i was thinking about and it's probably not a big deal
10:03:26 <ais523> it also makes overaiming more interesting
10:03:35 <ais523> it's a strategy discovered in the original BF Joust
10:03:42 <ais523> where you assume that the tape length is, say, at least 15
10:03:56 <myndzi> "playing the odds" was on for a while, did pretty decent
10:03:56 <ais523> it gives you an instant loss in 1/4 of games, but an advantage in the other 3/4
10:04:25 <myndzi> it'd do better with rng manipulation ;)
10:04:39 <myndzi> the other thing about this hill is
10:04:45 <myndzi> beating useless warriors doesn't gain you anything
10:04:58 <myndzi> if you beat someone with 0 points, you get none
10:05:08 <Patashu> a counter for a specific warrrior type will only last if that warrior type is itself dominating
10:05:26 <myndzi> i think you ought to get a little more credit than that, meh
10:05:33 <myndzi> that leads back to fixed scores, which i think i'd prefer
10:05:43 <myndzi> but at least gregor dropped the points received from ties earlier
10:05:49 <myndzi> that seems to have worked out
10:11:28 <ais523> !bfjoust another_kind_of_timing (>[)*15(+[[-]>+]+[[-]>+]])*15+[[-]>+]+[[-]>+]
10:11:32 <EgoBot> Score for ais523_another_kind_of_timing: 11.7
10:12:04 <Patashu> beats juggernaut and shade
10:12:26 <ais523> heh, it's probably going too /fast/
10:12:30 <ais523> and I messed up the code anyway
10:12:47 <ais523> !bfjoust another_kind_of_timing (>[)*15 [[+[-]>+]+[[-]>+]]
10:12:50 <EgoBot> Score for ais523_another_kind_of_timing: 18.9
10:12:55 <ais523> I pressed return by mistake
10:13:05 <ais523> and that should be a syntax error, I don't know why it scored points
10:15:24 <ais523> !bfjoust another_kind_of_timing >>>>>[>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>[[+[-]>+]+[[-]>+]]>[[>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]][[+[-]>+]+[[-]>+]
10:15:27 <EgoBot> Score for ais523_another_kind_of_timing: 13.2
10:15:57 <ais523> I don't get why that's drawing against the defenders
10:16:00 <ais523> it should suicide against them
10:16:05 <Patashu> beats jump2 and shade. ties defends 679 and jump2
10:16:14 <ais523> !bfjoust another_kind_of_timing >>>>>[>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>[[+[-]>+]+[[-]>+]]>[[>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]+[[+[-]>+]+[[-]>+]
10:16:17 <EgoBot> Score for ais523_another_kind_of_timing: 13.2
10:16:32 <ais523> I wonder what I've messed up this time?
10:17:17 <ais523> !bfjoust another_kind_of_timing >>>>>[>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>[[+[-]>+]+[[-]>+]]>[[>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]+[[+[-]>+]+[[-]>+]]
10:17:21 <EgoBot> Score for ais523_another_kind_of_timing: 21.3
10:17:27 <ais523> missing square bracket at the end
10:17:46 <ais523> !bfjoust brackettest [
10:17:49 <EgoBot> Score for ais523_brackettest: 9.7
10:18:20 <ais523> yep, jump2 suicides against an opponent that doesn't set up decoys
10:18:48 <Deewiant> Ah, it jumps over the first X nonzero cells
10:19:01 <ais523> !bfjoust another_kind_of_timing >.>.>.>.>.[>>>>>[[+[-]>+]+[[-]>+]]>.[>>>>>>[[+[-]>+]+[[-]>+]]>.[>>>>>>>[[+[-]>+]+[[-]>+]]>.[>>>>>>>>[[+[-]>+]+[[-]>+]]>.[>>>>>>>>>[[+[-]>+]+[[-]>+]]>.[[>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]+[[+[-]>+]+[[-]>+]]
10:19:04 <EgoBot> Score for ais523_another_kind_of_timing: 25.7
10:19:23 <ais523> wow, it's now almost on the bottom of the leaderboard
10:19:35 <Deewiant> Beats jump2, ugh, 3pass, shade
10:19:37 <Patashu> beats jump2, ugh, pass3, shade
10:19:40 <Patashu> god everything beats shade :P
10:20:47 <ais523> !bfjoust another_kind_of_timing >.>.>.>.>.[(>)*5[[+[-]>+]+[[-]>+]]>.[(>)*6[[+[-]>+]+[[-]>+]]>.[(>)*7[[+[-]>+]+[[-]>+]]>.[(>)*8[[+[-]>+]+[[-]>+]]>.[(>)*9[[+[-]>+]+[[-]>+]]>.[[(>)*10[[+[-]>+]+[[-]>+]]>.[(>)*11[[+[-]>+]+[[-]>+]]>.[(>)*12[[+[-]>+]+[[-]>+]]>.[(>)*13[[+[-]>+]+[[-]>+]]>.[(>)*14[[+[-]>+]+[[-]>+]]+[[+[-]>+]+[[-]>+]]
10:20:50 <EgoBot> Score for ais523_another_kind_of_timing: 10.8
10:21:03 <ais523> heh, I wonder why it dropped so much?
10:21:15 <GregorR-L> shade seems to only beat important ones :P
10:21:16 <Deewiant> Ties against the defends and jump2
10:21:40 <ais523> !bfjoust another_kind_of_timing >+++>--->+++>--->+++[(>)*5[[+[-]>+]+[[-]>+]]>[(>)*6[[+[-]>+]+[[-]>+]]>[(>)*7[[+[-]>+]+[[-]>+]]>[(>)*8[[+[-]>+]+[[-]>+]]>[(>)*9[[+[-]>+]+[[-]>+]]>[[(>)*10[[+[-]>+]+[[-]>+]]>[(>)*11[[+[-]>+]+[[-]>+]]>[(>)*12[[+[-]>+]+[[-]>+]]>[(>)*13[[+[-]>+]+[[-]>+]]>[(>)*14[[+[-]>+]+[[-]>+]]+[[+[-]>+]+[[-]>+]]
10:21:43 <EgoBot> Score for ais523_another_kind_of_timing: 5.2
10:21:52 <Deewiant> Now it doesn't even beat shade
10:21:52 <ais523> I just don't get why it's tying against the defends
10:22:12 <ais523> anyway, I'll abandon that line of reasoning
10:22:57 * ais523 vaguely wonders if the average program is slow enough that I could set up a whole second dummy flag in defend9, so I wouldn't have to risk the real one
10:23:18 -!- olsner has quit ("Leaving").
10:23:33 -!- amca has joined.
10:24:09 <ais523> shade beating slowrush is probably why it's doing so well
10:26:43 -!- ais523 has quit ("mibbit.com: going to get breakfast").
10:30:20 <GregorR-L> Yeah, slowrush is a good one to beat.
10:36:25 <jix_> !bfjoust try [[+-]+]
10:36:29 <EgoBot> Score for jix__try: 24.1
10:36:35 -!- jix_ has changed nick to jix.
10:37:08 <Patashu> that wouldn't work very well
10:37:08 <jix> !bfjoust try [[(+-)*5]+]
10:37:11 <EgoBot> Score for jix_try: 17.6
10:37:15 <Patashu> once it realizes it's 0 ( on a ]) it's already too late
10:37:53 <jix> just read about bfjoust...
10:38:26 <Patashu> it goes like this: ]s take value, both programs execute a command
10:38:41 <Patashu> if either flag is at 0 and was 0 for the end of the previous round as well declare a winner
10:39:39 <jix> so basically i can never test whether my flag is zero....
10:41:04 <Patashu> you can test whether ANY other cell is zero :)
10:42:47 <jix> !bfjoust try [->[-]+]
10:42:51 <EgoBot> Score for jix_try: 26.5
10:43:21 <jix> !bfjoust try [>[-]+]
10:43:24 <EgoBot> Score for jix_try: 19.6
10:45:34 <jix> in a loop is a cycle taken for [ and ] of the loop during iterations?
10:45:49 <jix> ah no isn't
10:45:56 <jix> the spec sais isn't
10:46:06 <jix> ] jump to just after the matching [
10:46:28 <Deewiant> Yes, but the ] itself takes one cycle
10:46:41 <jix> Deewiant: but that wasn't what i intended to ask ^^
10:47:04 <Patashu> [-] is executed like -]-]-]-]...
10:47:10 <Deewiant> So if you have [-] then the execution is not [-][-][-], it's [-]-]-]
10:48:40 <jix> !bfjoust try <
10:48:43 <EgoBot> Score for jix_try: 0.0
10:48:55 <Patashu> if you die it's a win for your opponent
10:48:59 <Patashu> but if you nop forever it's not
10:49:04 <Patashu> watch out for that distinction
10:49:18 <Patashu> !bfjoust thisbeatssuiciding .
10:49:22 <EgoBot> Score for Patashu_thisbeatssuiciding: 13.2
10:49:29 <Patashu> this also beats programs that expect to see decoys or w/e
10:50:12 <Patashu> it's not a big deal though because scoring is weighed; if you beat a program that has a high score YOU get a higher score
10:50:26 <Patashu> so they don't lose much for not beating my terrible program that loses almost every fight
10:52:25 <jix> !bfjoust try [>(+)*10[-](-)*20]
10:52:28 <EgoBot> Score for jix_try: 34.7
10:53:19 <Patashu> that beats maglev, juggernaut, lolscounter, jump2, spyglass, ugh and slowrush
10:53:41 <Patashu> you know where to find the other programs to look at them?
10:53:54 <Patashu> http://codu.org/eso/bfjoust/in_egobot/
10:54:39 <Patashu> defend9 and shade were algorithmically generated, hence the size
10:55:01 <jix> genetic algorithm?
10:55:05 <Patashu> defend6 and defend7 have been around for -ages-
10:55:23 <Patashu> no. he made an algorithm that codes higher level computations in just brainfuck
10:55:36 <Patashu> which is a lot faster than handwriting it as you can imagine
10:55:41 <jix> because that would be worth a try too
10:55:44 <Patashu> no one's used genetic algorithms for bfjoust yet
10:55:53 <jix> well then it's time for that i guess ^^
10:56:28 <jix> nah i should continue my linker instead of doing esoteric stuff right now...
10:56:41 <jix> ... but otoh this is a really nice challenge
10:57:22 <Patashu> you should work on your linker now
10:57:33 <Patashu> because there's a flaw in the way it compares programs atm
10:57:44 <Patashu> it only runs one match, which uses a tape length seeded by the concatenation of the two algorithms
10:58:01 <jix> this is flawed
10:58:03 <Patashu> so it's vulnerable to insignificant changes
10:58:04 -!- nooga_ has quit (Read error: 60 (Operation timed out)).
10:58:13 <Deewiant> As a bonus it uses the unexpanded source
10:58:14 <Patashu> it's going to get fixed in one or two days when it runs all possible combinations
10:58:22 <Deewiant> So it sees -- and (-)*2 as different
10:58:35 <jix> and - (-)*1
10:58:36 <Patashu> only for the purposes of hashing the original tape length for each match yeah
10:58:40 <Patashu> it's not too bad right now
10:58:45 <Deewiant> Yes, and -this is a comment- etc.
10:58:48 <Patashu> but for genetic algorithms it would produce flawed results
10:59:23 <jix> Patashu: not if i adjust the interpreter i use for ranking to that
11:00:20 <Patashu> and just run it on your own for a while?
11:00:51 <jix> well for genetic algorithms i'd have to evaluate a few thousand programs / sec
11:01:38 <Patashu> 21 tape lengths: maybe randomly evaluate one length out of the first five, one out of the next six, one out of the next five, one out of the next five
11:01:47 <Patashu> gives a reasonable approximation
11:02:00 <jix> i don't thin so..
11:02:11 <jix> because i think for some programs even/odd length is more important
11:02:19 <jix> so i could just evaluate only one by random
11:02:24 <Patashu> force two even force two odd?
11:02:38 <jix> Patashu: for some the length mod 3 might be important ;)
11:02:58 <jix> i'd just rank them by one.... because in the next iteration they will be ranked by a different length
11:03:12 <jix> and only the good ones will survive for a long time
11:03:40 <Patashu> randomly flipping or not flipping the second program's polarity
11:03:57 <Patashu> to prevent trivial counters that are just the original program but using the polarity it handles worse
11:04:07 <Patashu> though I don't know how easy a genetic algorithm will derive those
11:04:22 <Patashu> if it can't do something like that in one step it's probably fine
11:04:38 <jix> yeah that's always the most tricky part ...
11:04:44 <jix> getting the mutations / crossovers right for the problem
11:05:28 <Patashu> you might want to seed it with, say, programs currently on the hill?
11:05:34 <Patashu> because the goal in bfjoust is reasonably specific
11:05:49 <jix> Patashu: i wouldn't seed it with that
11:05:57 <jix> but would rank all programs against them
11:06:25 <jix> so they get ranked against the #estoric hill and my own GA hill
11:07:21 <Patashu> what do you seed it with then?
11:07:56 <jix> well when i do GAs i also add random genomes to the population with each step
11:08:02 <jix> so i'd have to create an algorithm to do random programs anyway
11:08:36 <jix> does the hill use the perl implementation?
11:09:31 <Patashu> ehird was working on an interpreter. meant to be fast as nails
11:09:36 <Patashu> well nails aren't very fast
11:10:11 <Patashu> I assume every addition of a [ will also force a ] to be inserted?
11:10:30 <jix> i think i'll keep loops in a tree structure
11:10:37 <jix> so it'll never move a ]
11:10:47 <jix> because that will most probably result in a totally different program
11:10:59 <jix> while moving a [...] might just be a slight modification
11:11:52 <jix> well will code a bit on the linker now and come back to this later
11:19:33 -!- GreaseMonkey has quit ("YES -> thor-ainor.it <- THIS IS *DELICIOUS*!").
11:21:50 -!- ais523 has joined.
11:34:57 -!- Sgeo_ has quit (Read error: 60 (Operation timed out)).
11:37:08 <jix> !bfjoust try2 [>[>[-]<-]+]
11:37:12 <EgoBot> Score for jix_try2: 12.3
11:40:23 <jix> !bfjoust try2 [>[-]-[-]-]
11:40:27 <EgoBot> Score for jix_try2: 24.1
11:41:33 <jix> !bfjoust try2 [>[---]-[-----](-)*100]
11:41:36 <EgoBot> Score for jix_try2: 25.4
11:41:43 <jix> !bfjoust try2 [>[---]-[-----](-)*10]
11:41:47 <EgoBot> Score for jix_try2: 30.4
11:45:41 <ais523> jump's been pushed off, I see
11:45:52 <ais523> and defend6 and defend7 are gradually moving down the leaderboard
11:46:52 <jix> !bfjoust idle ([]+)*1000
11:46:56 <EgoBot> Score for jix_idle: 11.4
11:47:06 <Patashu> that wouldn't work very well
11:47:21 <Patashu> you take the cell value from the start of the round
11:47:23 -!- Corun has joined.
11:47:35 <Patashu> ] sees a 0 and says 'ah, time for the next instruction'
11:47:41 <Patashu> but before it can execute that instruction the game is over
11:47:50 <Patashu> [] on your flag is pointless
11:47:54 <Patashu> [] on a cell in front of it however... :)
11:48:02 <jix> yeah i've seen that
11:48:13 <jix> try2 assumes there is a [] on the cell next to it
11:48:48 <jix> and kills defend* and waiter
11:49:14 <jix> but for a lot of others it probably just moves past the end
11:50:22 <jix> !bfjoust idiot (-)*384000
11:50:26 <EgoBot> Score for jix_idiot: 24.2
11:50:38 <Patashu> max cycle count is current 100k
11:51:15 <jix> haha that one wins only against my other 2... and against shade...
11:51:26 <jix> so i just manged to lower the score of my other 2 programs
11:51:28 <leonid_> bfjoust idiot (-)*99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
11:51:48 <ais523> leonid_: but it can only run for 100000 cycles anyway
11:51:51 <ais523> so all those 9s are redundant
11:54:00 <jix> !bfjoust waitntry >(-)*128>(+)*128>(-)*128>(+)*128[][>(+)*10[-](-)*20]
11:54:03 <EgoBot> Score for jix_waitntry: 19.1
11:55:43 <jix> !bfjoust waitntry >>(-)*32>>>(+)*32>>+[]+[>(+)*10[-](-)*20]
11:55:47 <EgoBot> Score for jix_waitntry: 17.1
11:57:56 <jix> !bfjoust waitntry >(-)*32>(+)*32>(-)*32>(+)*32[]++[>(+)*10[-](-)*20]
11:58:00 <EgoBot> Score for jix_waitntry: 24.3
11:58:15 <jix> !bfjoust waitntry >(-)*16>(+)*16>(-)*16>(+)*16[]++[>(+)*10[-](-)*20]
11:58:19 <EgoBot> Score for jix_waitntry: 19.6
11:59:50 <jix> !bfjoust idiot2 (-)*128(+-)*100000
11:59:54 <EgoBot> Score for jix_idiot2: 8.5
12:02:22 <jix> !bfjoust keep >>(+[[]+])*30
12:02:26 <EgoBot> Score for jix_keep: 14.5
12:03:21 <leonid_> you guys were talking badthing about me
12:03:26 <jix> !bfjoust keep >>(+[])*300
12:03:30 <EgoBot> Score for jix_keep: 5.2
12:03:50 <jix> !bfjoust keep >>(+[])*100000
12:03:54 <EgoBot> Score for jix_keep: 15.0
12:04:39 <Patashu> by the time you exit the [] loop
12:04:53 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<)*29)*37
12:04:54 <jix> Patashu: yeah i know
12:04:56 <EgoBot> Score for leonid__ugh: 56.2
12:05:06 <jix> leonid_: huh?
12:05:44 <jix> !bfjoust keep >>>>>>>>(+[]<<)*100000
12:05:45 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*2(>[-[+]])*6(<)*9)*37
12:05:49 <EgoBot> Score for jix_keep: 5.1
12:05:49 <EgoBot> Score for leonid__ugh: 21.2
12:06:01 <leonid_> that's the reason why i keep putting random shit
12:06:26 <Patashu> why would you make code that goes backwards more than it goes forwards?
12:06:41 <jix> Patashu: i'm just experimenting
12:06:50 <Patashu> this is trivial optimization though
12:07:00 <Patashu> and would give a more accurate depiction of how your code's doing
12:07:26 <leonid_> !bfjoust ugh ((>(+)*32>(-)*32)*3(>[-[+]])*4(<)*9)*20
12:07:30 <EgoBot> Score for leonid__ugh: 34.8
12:08:03 <leonid_> !bfjoust ugh ((>(+)*32>(-)*32)*2>>(>[-[+]])*4(<)*9)*20
12:08:07 <EgoBot> Score for leonid__ugh: 26.7
12:08:17 <leonid_> !bfjoust ugh ((>(+)*32>(-)*32)*4>>(>[-[+]])*2(<)*9)*20
12:08:19 <EgoBot> Score for leonid__ugh: 23.1
12:08:27 <leonid_> !bfjoust ugh ((>(+)*32>(-)*32)*4>>(>[-[+]])*5(<)*12)*20
12:08:30 <EgoBot> Score for leonid__ugh: 29.8
12:08:53 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*4>>(>[-[+]])*5(<)*12)*20
12:08:56 <EgoBot> Score for leonid__ugh: 54.7
12:09:06 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*4>>(>[-[+]])*5(<)*12)*18
12:09:10 <EgoBot> Score for leonid__ugh: 55.0
12:09:12 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*4>>(>[-[+]])*5(<)*12)*17
12:09:16 <EgoBot> Score for leonid__ugh: 48.4
12:09:45 <jix> !bfjoust fib >>++++++++++>+>+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<<]>>>[[-]<[>+<-]>>[<<+>+>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>+>+<<<-[>+<-]]]]]]]]]]]+>>>]<<<]
12:09:48 <EgoBot> Score for jix_fib: 8.6
12:09:58 <Patashu> that's very complex looking
12:10:01 <Patashu> does it do what you think it does?
12:10:11 <jix> i just took http://www.hevanet.com/cristofd/brainfuck/fib.b
12:10:52 <Deewiant> !bfjoust rot13 http://www.hevanet.com/cristofd/brainfuck/rot13.b
12:10:55 <EgoBot> Score for Deewiant_rot13: 0.0
12:11:15 <Patashu> amazingly, brainfuck programs don't make good bfjoust programs
12:11:19 <Deewiant> !bfjoust squares http://www.hevanet.com/cristofd/brainfuck/squares.b
12:11:22 <EgoBot> Score for Deewiant_squares: 0.0
12:11:22 <Patashu> who knew that computing fibbonaci numbers was so useless?
12:11:36 <Deewiant> !bfjoust random http://www.hevanet.com/cristofd/brainfuck/random.b
12:11:39 <EgoBot> Score for Deewiant_random: 0.0
12:11:47 <Deewiant> !bfjoust fib http://www.hevanet.com/cristofd/brainfuck/fib.b
12:11:49 <jix> you have to add a > at the beginning
12:11:50 <EgoBot> Score for Deewiant_fib: 0.0
12:11:53 <jix> or they'll all sucide
12:12:06 <ais523> most BF programs don't start [-], though
12:12:15 <Deewiant> !bfjoust rot13 >[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>++++++++++++++<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>>+++++[<----->-]<<-[>+<-[>+<-[>+<-[>
12:12:18 <EgoBot> Score for Deewiant_rot13: 10.7
12:12:21 <Deewiant> +<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>++++++++++++++<-[>+<-[>+<-[>+<-[>+<-[>+<-[>++++++++++++++<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>>+++++[<----->-]<<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>++++++++++++++<-[>+<-]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]>.[-]<,]
12:12:33 <jix> !bfjoust err [
12:12:37 <EgoBot> Score for jix_err: 6.4
12:12:41 <jix> !bfjoust err ]
12:12:45 <EgoBot> Score for jix_err: 10.7
12:13:03 <jix> !bfjoust err ]+]
12:13:06 <EgoBot> Score for jix_err: 16.4
12:13:32 <Deewiant> !bfjoust random >>>++[<++++++++[<[<++>-]>>[>>]+>>+[-[->>+<<<[<[<<]<+>]>[>[>>]]]<[>>[-]]>[>[-<<]>[<+<]]+<<]<[>+<-]>>-]<.[-]>>]
12:13:35 <EgoBot> Score for Deewiant_random: 0.0
12:13:46 <Patashu> I'm not sure what exactly [ without ] does
12:15:03 <jix> hmm i should write a debugger for this at some time
12:15:57 <Deewiant> !bfjoust factorial >(+)*10>>>+>+[>>>+[-[<<<<<[+<<<<<]>>[[-]>[<<+>+>-]<[>+<-]<([>+<-)*9[>[-]>>>>+>+<<<<<<-[>+<-(])*11>[<+>-]+>>>>>]<<<<<[<<<<<](>)*7[>>>>>]++[-<<<<<]>>>>>>-]+>>>>>]<[>++<-]<<<<[<[>+<-]<<<<]>>[->[-]++++++[<(+)*8>-]>>>>]<<<<<[<[>+>+<<-]>.<<<<<]>.>>>>]
12:16:00 <EgoBot> Score for Deewiant_factorial: 8.8
12:16:11 <ais523> slightly afternoon AnMaster
12:16:16 <Deewiant> !bfjoust factorial >(+)*10>>>+>+[>>>+[-[<<<<<[+<<<<<]>>[[-]>[<<+>+>-]<[>+<-]<([>+<-)*9[>[-]>>>>+>+<<<<<<-[>+<-(])*11>[<+>-]+>>>>>]<<<<<[<<<<<](>)*7[>>>>>]++[-<<<<<]>>>>>>-]+>>>>>]<[>++<-]<<<<[<[>+<-]<<<<]>>[->[-]++++++[<(+)*8>-]>>>>]<<<<<[<[>+>+<<-]>.<<<<<]>.>>>>]
12:16:18 <EgoBot> Score for Deewiant_factorial: 4.2
12:16:35 <Deewiant> Beats mirage, loses against everything else :-P
12:18:20 <ais523> psewelklihiandnabarfrux chewelisksiamtmaybobyargruz
12:18:37 <Patashu> !rot13 psewelklihiandnabarfrux chewelisksiamtmaybobyargruz
12:18:38 <EgoBot> cfrjryxyvuvnaqanonesehk purjryvfxfvnzgznlobolnetehm
12:19:32 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*4>>(>[-[+]])*5(<)*12)*23
12:19:35 <EgoBot> Score for leonid__ugh: 65.4
12:20:33 <Patashu> rushpolarity :twisted::twisted::twis ted:
12:21:06 <Deewiant> !bfjoust collatz >[(-)*10[>>>[>>>>]+[[-]+<[->>>>++>>>>+[>>>>]++[->+<<<<<]]<<<](+)*6[>(-)*6<-]>--[>>[->>>>]+>+[<<<<]>-],<]>]>>>++>+>>[<<[>>>>[-](+)*9<[>-<-](+)*9>[-[<->-]+[<<<<]]<[>+<-]>]>[>[>>>>]+[[-]<[+[->>>>]>+<]>[<+>[<<<<]]+<<<<]>>>[->>>>]+>+[<<<<]]>[[>+>>[<<<<+>>>>-]>]<<<<[-]>[-<<<<]](>)*7]>>+[[-](+)*6>>>>]<<<<[[<(+)*8>-]<.([-]<)*3]
12:21:10 <EgoBot> Score for Deewiant_collatz: 13.1
12:21:44 <Deewiant> !bfjoust collatz >[(-)*10[>>>[>>>>]+[[-]+<[->>>>++>>>>+[>>>>]++[->+<<<<<]]<<<](+)*6[>(-)*6<-]>--[>>[->>>>]+>+[<<<<]>-],<]>]>>>++>+>>[<<[>>>>[-](+)*9<[>-<-](+)*9>[-[<->-]+[<<<<]]<[>+<-]>]>[>[>>>>]+[[-]<[+[->>>>]>+<]>[<+>[<<<<]]+<<<<]>>>[->>>>]+>+[<<<<]]>[[>+>>[<<<<+>>>>-]>]<<<<[-]>[-<<<<]](>)*7]>>+[[-](+)*6>>>>]<<<<[[<(+)*8>-]<.([-]<)*3]
12:21:48 <EgoBot> Score for Deewiant_collatz: 13.2
12:22:33 <Patashu> imagine making one that looks like this but still gets lots of wins
12:22:59 <Patashu> it may appear to be generating prime numbers innocently, but behind the scenes it thrashes all 19 other programs on the hill
12:24:58 <Deewiant> !bfjoust dbfi >>>+[[-]>>[-]++>+>(+)*7[<++++>>++<-]++>>+>+>+++++[>++>(+)*6<<-]+>>++[[>[->>]<[>>]<<-]<[<]<+>>[>]>[<+>-[[<+>-]>]<[[[-]<]++<-[<(+)*9>[<->-]>>]>>]]<<]<]<[[<]>[[>]>>[>>]+[<<]<[<]<+>>-]>[>]+[->>]<<<<[[<<]<[<]+<<[+>+<<-[>-->+<<-[>+<[>>+<<-]]]>[<+>-]<]++>>-->[>]>>[>>]]<<[>>+<[[<]<]>[[<<]<[<]+[-<+>>-[<<+>++>-[<->[<<+>>-]]]<[>+<-]>]>[>]>]>[>>]>>]<<[>>+>>+>>]<<[-(>)*8]<<[>.(>)*7]<<[>->>>>>]<<[>.>>>]<<[>+>]<<[+<<]<]
12:25:02 <EgoBot> Score for Deewiant_dbfi: 7.9
12:25:25 <Deewiant> Brainfuck interpreter beats keke2
12:26:48 <jix> huh something is wrong with the report?
12:27:07 <Patashu> sometimes it's screwed by tabs if a program scores only single digits
12:27:54 <jix> !bfjoust nothing .
12:27:57 <Patashu> but it should report fine otherwise
12:27:57 <EgoBot> Score for jix_nothing: 10.3
12:28:06 <Patashu> . beats programs that rely apon an assumption
12:28:11 <Patashu> i.e. my enemy will setup decoys
12:28:30 <leonid_> here goes a program that runs off the end and doesn't care
12:28:31 <jix> when is the report updated and what does it include?
12:28:31 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*4(>[-[+]])*7(<)*12)*59
12:28:35 <EgoBot> Score for leonid__ugh: 66.6
12:28:40 <Patashu> it's reported after every new submission
12:28:51 <jix> does it include the last submission always?
12:29:06 <Deewiant> leonid_: Thanks for raising maglev's score ^_^
12:29:12 <jix> because i don't see them often
12:29:19 <ais523> !bfjoust defend9 http://pastebin.ca/raw/1439379
12:29:42 <Patashu> defend9 teh best program!!
12:29:45 <ais523> also, if defend9 takes a long time to run, that's normally because it's winning
12:29:48 <Patashu> the 9 stands for over nine thousand
12:29:53 <ais523> so I have a good feeling about this
12:30:22 <ais523> it's almost the same program, I just fixed a couple of bugs and optimised the value of an important constant
12:31:34 <ais523> and wow, it /is/ taking a long time
12:31:38 <EgoBot> Score for ais523_defend9: 73.6
12:31:56 <ais523> top of the leaderboard
12:31:58 <Deewiant> Yay, you raised maglev's score too
12:32:22 <leonid_> i redesigned ugh to raise all the other scores
12:32:33 <Deewiant> maglev beats everybody above it except shade and rushpolarity
12:32:43 <EgoBot> Score for leonid__ugh: 0.0
12:32:49 <Deewiant> leonid_: Noo, now you reduced my score :-P
12:33:31 <ais523> I wonder if keke2 has been redesigned recently
12:33:34 <ais523> because I beat it locally
12:33:40 <ais523> but I lost to it in EgoBot
12:33:40 <jix> !bfjoust try2 <
12:33:50 <EgoBot> Score for jix_try2: 0.1
12:34:01 <ais523> heh, the two suicide programs tie with each other
12:34:08 <ais523> they're both on 0.1 now
12:34:17 <ais523> Deewiant: the random seed is based on a hash of both programs
12:34:25 <Patashu> !bfjoust the_greatest_program_ever!!! [>[-[+]]-]
12:34:25 <ais523> so any particular matchup should be deterministic
12:34:35 <EgoBot> Score for Patashu_the_greatest_program_ever___: 34.2
12:34:37 <Deewiant> ais523: Oh, so you're using the same impl
12:34:57 <ais523> Deewiant: almost the same
12:35:00 <Deewiant> ais523: I assumed that your local interpreter would do things differently
12:35:01 <ais523> I hacked it to produce debug output
12:35:15 <ais523> so I can see how any particular pair of programs functions
12:35:35 <leonid_> !bfjoust bluguerrilla_glasses [--]_[--]
12:35:38 <ais523> Patashu: incidentally, it beats rushpolarity now too
12:35:45 <EgoBot> Score for leonid__bluguerrilla_glasses: 5.5
12:35:55 <Patashu> !bfjoust the_greatest_program_ever!!! +[>[-[+]]-]
12:36:05 <EgoBot> Score for Patashu_the_greatest_program_ever___: 40.0
12:36:13 <Patashu> !bfjoust the_greatest_program_ever!!! +[>[-[+]]--]
12:36:23 <EgoBot> Score for Patashu_the_greatest_program_ever___: 40.5
12:36:26 <ais523> due to an architectural improvement; I made it polarity-independent
12:36:28 <Patashu> !bfjoust the_greatest_program_ever!!! +[>[-[+]]---]
12:36:38 <ais523> it now has two /different/ ways of gluing the opponent in place
12:36:38 <EgoBot> Score for Patashu_the_greatest_program_ever___: 47.7
12:36:46 <Patashu> !bfjoust the_greatest_program_ever!!! +[>[-[+]](-)*4]
12:36:56 <EgoBot> Score for Patashu_the_greatest_program_ever___: 32.4
12:37:02 <Patashu> !bfjoust the_greatest_program_ever!!! ++[>[-[+]]---]
12:37:10 <jix> the value should be coprime to 256
12:37:12 <EgoBot> Score for Patashu_the_greatest_program_ever___: 40.5
12:37:17 <Patashu> !bfjoust the_greatest_program_ever!!! +[>[-[+]]--]
12:37:21 <jix> oh wait you're moving there
12:37:27 <EgoBot> Score for Patashu_the_greatest_program_ever___: 40.5
12:37:34 <Patashu> !bfjoust the_greatest_program_ever!!! +[>[-[+]]---]
12:37:47 <EgoBot> Score for Patashu_the_greatest_program_ever___: 47.7
12:38:06 <ais523> wow, quickbeatinthestreetdanceonyo_feetcausethisissoneat has dropped a /lot/
12:38:11 <leonid_> !bfjoust idiot ((-)*1000><><><><><><><)*100
12:38:19 <Patashu> let's see what it's losing to...
12:38:21 <EgoBot> Score for leonid__idiot: 8.5
12:38:35 <leonid_> !bfjoust idiot (+-><-+)*100000
12:38:44 <Patashu> maglev, waiter, defend 6-7-9, neon glow, 3pass, keke2
12:38:45 <EgoBot> Score for leonid__idiot: 22.9
12:38:49 <Patashu> it was beating defend9 and now is not
12:39:07 <leonid_> !bfjoust idiot (+->(-)*19<-+)*10000
12:39:09 <ais523> leonid_: that's like my vff, just worse
12:39:16 <EgoBot> Score for leonid__idiot: 10.0
12:39:24 <ais523> if you're going to write a farmer, you may as well go all out
12:39:34 <jix> !bfjoust (>)*11(-.)*512
12:39:35 <EgoBot> Use: !bfjoust <program name> <program>
12:39:39 <jix> !bfjoust whoops (>)*11(-.)*512
12:39:44 <leonid_> !bfjoust idiot (+->+-<)*100000
12:39:54 <ais523> Patashu: a program that scrambles the tape elements near its flag
12:39:58 <EgoBot> Score for leonid__idiot: 17.0
12:39:58 <EgoBot> Score for jix_whoops: 7.8
12:40:04 <jix> !bfjoust whoops (>)*12(-.)*512
12:40:05 <ais523> I'm not entirely sure what good that does, except for scrambling the flag itself
12:40:14 <EgoBot> Score for jix_whoops: 15.2
12:40:18 <jix> !bfjoust whoops (>)*13(-.)*512
12:40:21 <Deewiant> Since when are they called farmers?
12:40:24 <leonid_> !bfjoust idiot ((+-)*100>(+-)*100<)*5000
12:40:30 <EgoBot> Score for leonid__idiot: 11.2
12:40:30 <EgoBot> Score for jix_whoops: 18.4
12:40:32 <ais523> I think someone submitted a program like that and called it farmer
12:40:36 <jix> !bfjoust whoops (>)*14(-.)*512
12:40:40 <ais523> I might be wrong, though
12:40:44 <EgoBot> Score for jix_whoops: 8.5
12:40:49 <EgoBot> Score for leonid__idiot: 0.0
12:40:52 <jix> !bfjoust whoops (>)*15(-.)*512
12:40:57 <Deewiant> I submitted some six or seven farmers
12:40:57 <ais523> Deewiant: well, you coined a BF Joust term, well done
12:41:02 <EgoBot> Score for jix_whoops: 6.2
12:41:10 <ais523> now, who came up with "tripwire"/
12:41:17 <jix> !bfjoust whoops (>)*13(-.)*256>(-.)*256
12:41:23 <Deewiant> The only one I've seen using that term is you :-P
12:41:27 <EgoBot> Score for jix_whoops: 10.6
12:41:35 <Patashu> !bfjoust kirbyhassuicidalfeelingsheneedstoexpress <(-.-)*3>
12:41:39 <jix> !bfjoust whoops (>)*12(-.)*256>(-.)*256
12:41:46 <ais523> hmm... I just noticed a *-160 in defend9's code
12:41:50 <ais523> it's in a bit that probably never runs
12:41:52 <EgoBot> Score for Patashu_kirbyhassuicidalfeelingsheneedstoexpress: 0.0
12:41:52 <EgoBot> Score for jix_whoops: 17.3
12:42:15 <jix> !bfjoust whoops (>)*12(-.)*129>(-.)*129
12:42:24 <ais523> I'll need to figure out what it /ought/ to say later
12:42:25 <EgoBot> Score for jix_whoops: 24.4
12:42:33 <ais523> probably *163, based on context
12:42:37 <jix> !bfjoust whoops (>)*12(-.)*129>(-.)*129a
12:42:47 <EgoBot> Score for jix_whoops: 8.9
12:42:48 <Patashu> so, maglev and keke2 beat defend9
12:42:51 <jix> !bfjoust whoops (>)*12(-.)*129>(-.)*129b
12:43:02 <ais523> Patashu: keke2 I don't know
12:43:06 <ais523> given that my local tests, it doesn't
12:43:08 <EgoBot> Score for jix_whoops: 9.6
12:43:08 <EgoBot> Score for leonid__idiot: 12.4
12:43:12 <leonid_> jix you are exploiting hash values D:
12:43:18 <jix> !bfjoust whoops (>)*12(-.)*129>(-.)*129>(-.)*129>(-.)*129>(-.)*129>(-.)*129>(-.)*129
12:43:28 <EgoBot> Score for jix_whoops: 29.7
12:43:31 <Patashu> wait what was that text macro I had
12:44:18 <Patashu> ~~~:'(HASH BASED RANDOMNESS:'(~~
12:44:23 <EgoBot> Score for leonid__idiot: 11.0
12:44:37 <EgoBot> Score for leonid__idiot: 30.8
12:44:40 <jix> we need a faster implementation for the hil
12:44:51 <EgoBot> Score for leonid__idiot: 26.0
12:45:15 <ais523> ah, keke2 starts with ten >s
12:45:27 <ais523> and in my local game, the random seed happens to give a tape length of 10
12:45:35 <ais523> so it's kind of hard to test
12:45:46 <ais523> presumably the RNG is different in the egobot version due to having a different libc
12:48:00 <ais523> that wasn't even a deliberate attempt to exploit the hash
12:48:14 <ais523> it just turned out that way when I finally got the detection code properly working
12:51:43 <ais523> speedy1's dropping down the leaderboard now
12:51:49 <ais523> at least it's done its bit to make programs a bit faster
12:53:19 <Patashu> the less it matters if you don't beat it
12:53:33 <ais523> same for any other program
12:53:43 <ais523> but the hill will be faster overall as a result
12:53:54 <ais523> you can tell it's faster, on the basis that speedy1 is doing badly on it
12:53:56 <ais523> but was doing well before
12:54:56 * ais523 wonders how long defend9 will stay up there
12:55:31 <ais523> it's not meant to be obfuscated
12:55:43 <Patashu> i.e. obfuscated by definition
12:57:18 * ais523 thinks it's interesting that even defence programs have to use decoys, to give themselves time to set up the defence
12:59:33 -!- Judofyr has quit (Remote closed the connection).
13:07:39 <Patashu> !bfjoust juggernaut +(>(-)*128.(-.)*512>(+)*128.(++.)*512)*15
13:07:50 <EgoBot> Score for Patashu_juggernaut: 17.5
13:07:52 <Patashu> !bfjoust juggernaut +(>(-)*128.--++.-.+.-+)*29
13:08:02 <EgoBot> Score for Patashu_juggernaut: 30.3
13:13:05 <lereah_> http://naitohorizon.blogspot.com/
13:15:10 <lereah_> leonid : It reminded me of this : http://ja.wikipedia.org/wiki/%E5%86%85%E8%97%A4%E3%83%9B%E3%83%A9%E3%82%A4%E3%82%BE%E3%83%B3#.E3.83.96.E3.83.BC.E3.83.B32
13:28:32 <lereah_> Mona font isn't monospaced
13:28:34 <Gracenotes> sorry. your home is 2ch, cute creature
13:29:04 <lereah_> Well, bu-n works on IRC, but only when using one line.
13:29:16 <lereah_> ⊂二二二（ ＾ω＾）二⊃ SPREAD YOUR ARMS AND BU-N
13:31:52 <leonid_> too lazy to bring up japanese keyboard
13:32:27 <lereah_> http://tanasinn.info/wiki/%28_%EF%BE%9F_%E3%83%AE%EF%BE%9F%29
13:34:23 <Gracenotes> I read a story about that when I was younger
13:34:39 <Gracenotes> the mittens who lost their kittens. Or actually it was the other way around.
13:35:00 <lereah_> "This page is small. You can help by making it huge. "
13:35:10 <ais523> Gracenotes: I thought they got them dirty, rather than losing them
13:35:28 <Gracenotes> ais523: I think we may have read different stories?
13:35:49 <ais523> it's a British nursery rhyme
13:35:53 <ais523> and not a particularly interesting one
13:35:56 <ais523> I can't remember it any more
13:36:09 <lereah_> http://www.rhymes.org.uk/three_little_kittens.htm
13:36:33 <lereah_> "Meeow, meeow, meeow, now we shall have no pie."
13:36:44 <Gracenotes> ais523: actually, it may be the same one :)
13:37:15 <ais523> and then got them dirty eating the pie
13:37:32 <ais523> the big question here is: why would a cat wear gloves to eat pie anyway/
13:38:21 <Gracenotes> it would be easier to wash their gloves than to wash their paws
13:47:48 <Gracenotes> oh man, reminds me of when I had the kirby rolling game on my gameboy color
13:56:57 <lereah_> She's more of the kind to wish on a dream and shit like that
13:58:31 <lereah_> http://tanasinn.info/images/4/42/PayDaddyCool.png
13:58:38 <lereah_> That picture always cracks me up.
14:00:41 <Gracenotes> lereah_: I don't exactly get the foodstuffs.
14:00:55 <lereah_> Yes, it is quite maddening
14:02:13 <Gracenotes> lereah_: if u eat teh cake i will give u access to my secret area of http://img.secretareaofvipquality.net/src/1234340335056.jpg
14:09:02 <jix> is nesting of ( and ) allowed?
14:09:26 <ais523> although nested ({})% doesn't seem to work
14:09:38 <ais523> so replacing with ()* for GregorR's interpreter is required
14:09:41 <ais523> even though that's against the spec
14:11:24 <jix> ([)*322 is illegal according to the spec
14:11:40 <lereah_> They're all stored in my old Game Boy bag
14:11:47 <jix> btu is in defend9
14:11:53 <lereah_> Except when I have to pay Daddy Cool.
14:12:17 <jix> ais523: i'm writing my own interpreter right now and want to make it compatible to what is out there...
14:14:25 <Gracenotes> I approve of this diagram. http://tanasinn.info/wiki/Mittens
14:16:19 <jix> what interpreter does egobot use?
14:16:32 <ais523> it's in the egobot distribution
14:18:33 <jix> ais523: which can be found where?
14:18:46 <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/
14:23:20 <Patashu> this looks like the original bfjoust interp https://codu.org/projects/egobot/hg/index.cgi/rev/1fdbcf450c99
14:23:32 <ais523> the Perl interp's my original
14:23:43 <Patashu> egojoust: https://codu.org/projects/egobot/hg/index.cgi/rev/d788867c80a2
14:23:48 -!- Corun has changed nick to Corun|away.
14:24:19 <lereah_> http://tanasinn.info/wiki/Haruhi_Mittens
14:24:35 <jix> ais523: and what about the spec saying that ([)*10 is illegal but it being used
14:25:09 <ais523> jix: if you don't support it, make sure you get nested ({})% working
14:25:17 <ais523> if you're aiming for compatibility, you should support both
14:25:48 -!- amca has quit ("Farewell").
14:26:03 <jix> what is annoying... that i don't know what kind of pattern i have on the opening (
14:27:06 <Patashu> why not scan ahead to see if you find a { on the same level as it
14:27:10 <Patashu> then jump back and continue
14:27:20 <jix> just found another solution
14:30:59 -!- Corun|away has changed nick to Corun.
14:33:19 <lereah_> Gracenotes, are you a /prog/lodyte?
14:34:40 <Gracenotes> I have been known to browse. and post.
14:35:21 <lereah_> There seems to be a lot of /prog/ people here
14:36:02 <lereah_> /prog/ seems pretty active for a textboard
14:52:51 -!- lereah_ has quit ("Leaving").
15:12:34 -!- ais523 has quit (Remote closed the connection).
15:18:43 -!- GregorR-L has quit (Remote closed the connection).
15:30:27 -!- FireFly has joined.
15:33:32 -!- GregorR-L has joined.
15:59:17 -!- oerjan has joined.
16:29:53 -!- inurinternet has quit (Connection timed out).
16:34:23 -!- coppro has quit (Read error: 110 (Connection timed out)).
16:38:57 -!- myndzi has quit (Read error: 110 (Connection timed out)).
16:48:55 -!- Patashu has quit (Remote closed the connection).
16:49:37 -!- myndzi has joined.
16:49:56 -!- inurinternet has joined.
16:57:12 -!- Laptop has joined.
16:57:21 -!- Laptop has changed nick to whtspc.
16:57:58 <whtspc> I'm a big time lurker here
16:58:31 <whtspc> so I speak out loud for once
16:58:50 <whtspc> Is there a standalone version of egobot
16:59:07 <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/
16:59:10 <whtspc> something alike that I can use without the channel
16:59:34 <oerjan> this version is fairly new
17:00:03 <oerjan> you can private message it, anyhow
17:00:29 <oerjan> also, GregorR is the person to ask
17:01:09 <whtspc> I would like to play around with it at work :)
17:01:36 <oerjan> oh when you are not on irc at all?
17:01:39 <pikhq> whtspc: hg clone https://codu.org/projects/egobot/hg egobot/
17:01:47 <whtspc> yes that's what I mean
17:02:48 <whtspc> pikhq: allthough I'm interested in esolangs, I'm not big computer-nerd
17:03:02 <whtspc> what can I do with that?
17:03:29 <oerjan> if you _were_ a big computer nerd, you could probably change the code to make it standalone
17:03:47 <whtspc> I hoped someone already did :)
17:04:20 * oerjan isn't a big enough computer nerd himself to do that
17:04:36 <oerjan> even if i program some esothings
17:06:23 <whtspc> Ok thanks anyway, I'll try to make some kind of multiple language interpreter myself, I think a not-nerd should be able to do that
17:09:03 <whtspc> I'll move back into anonymity now, speak to you someday, thanks!
17:09:17 <oerjan> whtspc: those are usually called "shells" ;D
17:09:19 -!- whtspc has quit ("ChatZilla 0.9.84 [Firefox 3.0.10/2009042316]").
17:10:11 -!- myndzi\ has joined.
17:20:52 -!- myndzi has quit (Read error: 110 (Connection timed out)).
17:23:59 -!- Corun has changed nick to Corun|away.
17:42:23 -!- Corun|away has changed nick to Corun.
18:23:53 -!- Judofyr has joined.
18:39:23 -!- Corun has changed nick to Corun|away.
18:44:42 -!- leonid_ has quit ("Leaving").
18:46:56 -!- jix_ has joined.
18:59:56 -!- jix has quit (Read error: 110 (Connection timed out)).
19:07:30 -!- oerjan has quit ("leaving").
19:13:58 <ehird> where i was: sleeping
19:17:36 -!- KingOfKarlsruhe has joined.
19:19:07 <ehird> 21:35:01 <Patashu> word on the street is that it's being rewritten to run with all 21 lengths, then with one of the program's polarity flipped, then the remaining 21 lengths
19:21:04 <ehird> 21:50:29 <psygnisfive> thought experiments are fun
19:21:04 <ehird> 21:50:38 <psygnisfive> especially if you put on thought lab coats and use thought chemicals
19:21:10 <ehird> truer words have never been spoken
19:24:25 <ehird> 22:02:38 <Patashu> I don't know any perl :(
19:24:25 <ehird> 22:02:42 <Patashu> only know visual basic and jav
19:24:26 <ehird> 22:02:43 <Patashu> +a
19:24:28 <ehird> AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
19:28:09 <ehird> 22:18:52 <whoppix> Thing I was wondering about.. If one has a simple state machine, like f.ex. brainfuck, shouldn't it be relatively easy to detect infinite loops, by checksumming the machines state at the start of a loop, and after each iteration, check if the state (or any state in that loop) recurred?
19:28:10 <ehird> 22:19:03 <whoppix> Might be that I'm thinking wrong, I'm pretty tired already :)
19:28:27 <ehird> you can't do it on a turing machine, for a turing machine
19:28:38 <ehird> you can do it on a turing machine for any finite program
19:28:47 <ehird> Patashu is evry wrong
19:28:56 <ehird> 22:21:59 <pikhq> And that method would fail with +[>+]
19:29:36 <ehird> 22:24:01 <psygnisfive> pikhq: thats because all non-TMs halt :P
19:29:39 <pikhq> ehird: Yes. After that I noted that the halting problem is solvable on a finite state machine.
19:29:46 <ehird> Absolutely incorrect, psygnisfive.
19:29:51 <ehird> Please don't say such stupid things.
19:29:57 <pikhq> *For* a finite state machine.
19:30:21 <ehird> 22:27:23 <pikhq> ((lambda (x x)) (lambda (x x))) ;!
19:30:38 <ehird> pikhq: that's fucked syntax
19:30:47 <ehird> in Scheme, that takes two arguments, both called x, and then syntax errors.
19:31:03 <ehird> (\x.x x)(\x.x x) -> (\x.x x)(\x.x x)
19:31:06 <ehird> so it's very state-repeating
19:31:09 <pikhq> I meant ((lambda x (x x)) (lambda x (x x))), of course.
19:31:22 <ehird> 22:29:43 <Patashu> if it's modified to run all tape lengths and both polarities
19:31:23 <ehird> 22:29:50 <Patashu> should all tape length matches have equal weighting?
19:31:28 <ehird> specialization is for insects
19:31:34 <ehird> pikhq: (lambda (x) (x x)), for Scheme
19:31:45 <ehird> 22:30:35 <psygnisfive> anything that doesnt halt /is/ a turing machine, just not a UNIVERSAL turing machine.
19:31:48 <ehird> ..................
19:31:55 <ehird> psygnisfive: where do your definitions come from?
19:32:03 <pikhq> I meant (x){x x} (x){x x}
19:32:21 <ehird> pikhq: No, you meant (λx. x x)(λx. x x)
19:33:16 <ehird> heh, this no-more-than-80-columns-and-four-indentations rule is helping my code a lot
19:33:24 <ehird> since I keep having to split functions :D
19:35:57 <ehird> 22:31:56 <psygnisfive> ignoring, ofcourse, trivial non-halting behavior like S -> S or similar.
19:36:06 <ehird> "ignoring the whole point"
19:37:16 <ehird> 22:35:24 <whoppix> leonid_, increase the current cell, decrease it until its zero, increase it...
19:37:19 <ehird> the loop ends when it's zero
19:37:34 <ehird> [+[-]] = while(cell){cell++;while(cell){cell--;}}
19:37:40 <ehird> ofc the outer while only runs once
19:45:13 <AnMaster> how would you translate this bf loop to a polynomial [-->+<] ?
19:46:36 <AnMaster> ehird, maybe you can help here
19:46:45 <AnMaster> to me it seems to be a form of division
19:46:47 <ehird> AnMaster: well, let's analyze the iteration
19:47:06 <ehird> while(0){0-2, 1+1}
19:47:14 <ehird> (where x+y is ptr+x = y)
19:47:18 <ehird> AnMaster: okay, so
19:47:23 <ehird> AnMaster: we decrease by two
19:47:33 <ehird> AnMaster: so, that is basically
19:47:52 <ehird> AnMaster: this is general, for example:
19:48:05 <ehird> [x] = value of cell x
19:48:11 <ehird> AnMaster: [-->+<] is
19:48:22 <ehird> times([0]/2){[1]+=1}; [0]=0;
19:48:26 <ehird> AnMaster: [->+<] is
19:48:33 <ehird> times([0]/1){[1]+=1};[0]=0;
19:48:38 <ehird> AnMaster: since x/1 = x, it works
19:48:43 <ehird> AnMaster: but do you see?
19:48:56 <AnMaster> but how do you avoid iterations in that times?
19:49:16 <ehird> AnMaster: oh, i see
19:49:31 <ehird> AnMaster: well, just do it as if it decremented one. then divide the values by 2
19:49:37 <AnMaster> ehird, I would expect [->++<] to be compiled to: p[1] = 2 * p[0]; p[0] = 0;
19:49:49 <ehird> AnMaster: we're talking about [-->+<]
19:49:56 <ehird> which is p[1] = p[0]/2;
19:50:07 <ehird> AnMaster: but, we need to handle odd numbers
19:50:18 <ehird> [-->+<] p[1]+=1, p[0]=1
19:50:27 <ehird> [-->+<] p[1]+=1, p[0]=255
19:50:50 <ehird> [-->+<] p[1]+=1, p[0]=253
19:50:51 <ehird> [-->+<] p[1]+=1, p[0]=251
19:50:56 <ehird> [-->+<] p[1]+=1, p[0]=249
19:51:09 <ehird> [-->+<] p[1]+=1, p[0]=1
19:51:18 <ehird> AnMaster: so we can conclude that
19:51:20 <ehird> if the number is odd
19:51:30 <ehird> AnMaster: so, it turns into
19:51:44 <ehird> if (p[0]%2==0){p[1]+=p[0]/2;p[0]=0;}else{for(;;);}
19:51:51 -!- olsner has joined.
19:51:57 <AnMaster> ehird, lets say we have one that must be finite then, as a better example. Like [--->+<]
19:52:07 <ehird> AnMaster: that doesn't have to be finite
19:52:15 <ehird> it's infinite if (cell % 3)!+0
19:52:42 <AnMaster> ehird, with 256-wrapping cells it is always finite
19:53:00 <ehird> AnMaster: the extended gcd stuff?
19:53:03 <ehird> AnMaster: well, then, it's just
19:53:07 <AnMaster> might take more than one crossing of 256
19:53:14 <ehird> AnMaster: lemme write a program to trace it
19:53:27 <ehird> AnMaster: let's say the value is 4
19:54:14 <AnMaster> ehird, if (positive_index_cell_diff%2 == 1) it is finite. Where -3 is thus 253.
19:54:48 <ehird> AnMaster: end values are
19:55:12 <ehird> AnMaster: I can run it for another starting value
19:55:21 <ehird> AnMaster: how about [0]=16, [1]=0?
19:55:49 <ehird> AnMaster: for [0]=4, [1]=172 at the end
19:55:59 <ehird> AnMaster: for [0]=16, [1]=176 at the end
19:56:31 <ehird> AnMaster: so, let's try with 2
19:56:35 <AnMaster> but question is, can you know this if you don't know what [0] is at compile time. I mean "know" here as in "know what arithmetic operation to turn it into"
19:56:35 <ehird> which is the smallest non-trivial even number
19:56:38 <ehird> ie the one that actually loops
19:56:54 <ehird> AnMaster: ok, for n=2, it loops 86 times
19:57:06 <ehird> 0-based indexing throwing me off
19:57:13 <ehird> AnMaster: it's probably some modulo thing
19:57:17 <AnMaster> ehird, "<ehird> 0-based indexing throwing me off" <-- you aren't alone
19:57:26 <ehird> yeah I always have to stop and think
19:58:01 <ehird> AnMaster: now, it should be calculating 2/3
19:58:15 <AnMaster> I can manage 0-based arrays pretty well. I kind of "learnt" the important edge cases. Anything else that is zero indexed though...
19:58:31 <AnMaster> ehird, question was. Does that actually map to /3... hm
19:58:35 <ehird> AnMaster: yes, absolutely
19:58:38 <ehird> it's integer division by 3
19:59:13 <ehird> >> while _0!=0; puts "[0]=#{_0} [1]=#{_1} -> [0]=#{_0 = (_0-3)%256} [1]=#{_1 += 1}" end
19:59:14 <ehird> [0]=9 [1]=0 -> [0]=6 [1]=1
19:59:16 <ehird> [0]=6 [1]=1 -> [0]=3 [1]=2
19:59:16 <AnMaster> ehird, can't map to an integer polynomial then. Expression sure. But not integer polynomial
19:59:18 <ehird> [0]=3 [1]=2 -> [0]=0 [1]=3
19:59:36 <ehird> yeah well, "polynomial" in bf optimization just means "constant expression on tape cells" :P
19:59:46 <ehird> now if only oerjan was here
20:00:02 <ehird> i'm sure there's an easy way to figure this out
20:00:07 <ehird> AnMaster: btw for [0]=1, [1]=171
20:00:18 <ehird> and for [0]=4, [1]=172 as I said
20:00:19 <AnMaster> ehird, so you mean I coded the "integer polynomial library" for nothing? With the distributive laws and simplification and so on
20:00:29 <ehird> AnMaster: haha, did you actually do that?
20:00:51 <AnMaster> ehird, sure. It handles addition and multiplications of two polynomials too
20:01:10 <ehird> AnMaster: [0]=5 → [1]=87, [0]=8 → [1]=88
20:01:24 <ehird> perhaps [0]=(N/2)-1 → [1]=(result_of_N)-1
20:01:31 <AnMaster> ehird, about 200 lines of erlang code, including the "special foldl" for generating backend output
20:01:43 <ehird> perhaps [0]=(N/2)+1 → [1]=(result_of_N)-1
20:02:01 <ehird> AnMaster: for non-divisors here)
20:02:09 <ehird> 20:00 ehird: AnMaster: btw for [0]=1, [1]=171
20:02:09 <ehird> 20:00 ehird: and for [0]=4, [1]=172 as I said
20:02:13 <ehird> 20:01 ehird: AnMaster: [0]=5 → [1]=87, [0]=8 → [1]=88
20:02:56 <ehird> AnMaster: so sometimes it's +1, sometimes it's -1
20:02:58 <AnMaster> ehird, I can handle loop with +1/-1 for index cell and which only contains adds/sets/"other polynomials"
20:03:29 <AnMaster> ehird, so not trivial integer division then?
20:03:43 <ehird> AnMaster: oh, it's trivial integer division if [0] % N == 0
20:03:47 <ehird> as in, if it divides properly
20:03:54 <ehird> it's just the edge-case that produces weird shit
20:04:02 <ehird> edge-case being [0]%N!=0
20:04:39 <ehird> AnMaster: number of -s
20:04:41 <AnMaster> ehird, problem if, if a compiler handles everything but edge cases just fine then you get GCC.
20:04:52 <ehird> it's just weird shit
20:04:58 <ehird> i mean, it's not an edge case in the code
20:05:04 <ehird> but it's an edge-case in the intention of the code
20:05:22 <ehird> AnMaster: i think esotope detects division
20:05:29 <AnMaster> if I know the number of iterations using a polynomial is pointless
20:05:54 <AnMaster> lists:flatten(lists:duplication(NumberOfIterations,BodyOfLoop))
20:06:01 <AnMaster> and then insert that where the loop was
20:06:09 <ehird> this is very interesting
20:06:41 <ehird> the edge case here
20:06:45 <ehird> the values it produces
20:06:48 <AnMaster> brb need to get some cookie or something
20:07:08 <ehird> AnMaster: the life of a bf joust implementor is much easier
20:07:12 <ehird> since we absolutely cannot optimize :)
20:07:22 <ehird> and i_keelst_thou died
20:07:36 <ehird> and your randomness is fucking up everything :D (see logs)
20:07:44 <ehird> before AnMaster says anything, yes I'm coding on my interp
20:08:46 -!- Corun|away has changed nick to Corun.
20:09:05 <ehird> i'm at the boring bit now
20:09:05 <AnMaster> wanted: Garlic and Bacon cookie.
20:09:07 <ehird> writing the interp loop :)
20:09:10 <ehird> AnMaster: Ohmigod.
20:09:20 <ehird> AnMaster: You should warn me before saying such amazing things.
20:09:32 <ehird> I might die of shock
20:09:43 <AnMaster> ehird, Plus I would have to warn all the time
20:09:44 <GregorR-L> ais who isn't here: srandom and random should be the same on any system, but my hash is different on 32- and 64-bit systems, so you need to be on 64-bit to get the same result.
20:10:20 <AnMaster> <ehird> AnMaster: the life of a bf joust implementor is much easier <ehird> since we absolutely cannot optimize :) <-- yeah, but I don't have to care about timing and running unoptimised code fast
20:10:57 <AnMaster> ehird, heck, I don't even have to care about running fast. As long as the generated output is fast.
20:11:10 <AnMaster> in-between is slow as shit. ~40 seconds for lostking
20:11:20 <ehird> AnMaster: mine has it even worse than egojoust
20:11:25 <ehird> egojoust just has to run every battle once
20:11:29 <ehird> i have to run each battle 42 times
20:11:33 <ehird> and be just as fast if not faster
20:11:52 <ehird> i may need to enroll your cfunge microöptimization skills, AnMaster
20:11:59 <AnMaster> rather, based on the old jousting
20:12:04 <ehird> AnMaster: riding on pigs, waving bacon at each other
20:12:10 <ehird> sounds more like a mating ritual than a fight.
20:12:25 <AnMaster> :D I worked out the name for it before the implementation.
20:12:45 <AnMaster> which means the name sounds awsome, but I have no idea how it would work.
20:12:58 <ehird> I meant prebacon, of course
20:13:06 <AnMaster> ehird, what about garlic joust
20:13:17 <ehird> AnMaster: riding on pieces of garlic, waving garlic at each other
20:13:20 <ehird> there may be a slight movement problem
20:13:28 <AnMaster> ehird, yeah I don't think that could work
20:13:36 <AnMaster> what about using the smell of it instead
20:13:47 <AnMaster> the jousters must not eat garlic before
20:13:52 <ehird> AnMaster: "make your opponent's eye water".
20:13:54 <ehird> while riding on a horse.
20:13:55 <AnMaster> so they can experience the full smell of it
20:14:10 <AnMaster> ehird, yes, or a gunniea pig (sp?)
20:14:34 <ehird> btw i have a guinea pig and i can tell you that you'd be stupid to try and test on them
20:14:46 <ehird> impossible to catch and escape all the time
20:14:52 <ehird> test on them as in labs, I mean
20:14:58 <ehird> so it's a bad phrase :)
20:15:06 <ehird> ah, uh, putting a tape element in the match structure and allocating it may help my interp compile
20:16:03 <AnMaster> ehird, still going for the polarity thing?
20:16:07 <ehird> AnMaster: of course
20:16:17 <ehird> AnMaster: yay, it runs 100k cycles instantly
20:16:21 <ehird> ofc, it doesn't handle wins or anything yet
20:16:28 <ehird> and the loop logic is ordering-sensitive
20:16:29 <AnMaster> ehird, adding that will slow it down
20:16:34 <ehird> AnMaster: not by much
20:16:40 <ehird> just a branch or two each iteration
20:17:01 <AnMaster> <ehird> and the loop logic is ordering-sensitive <-- err. Forgive my ignorance. But what the hell does this means in the context of BF loops
20:17:14 <ehird> AnMaster: if one program does + and the other does [
20:17:19 <ehird> the program that would do + does [
20:17:28 <AnMaster> isn't it checked at start of loop?
20:17:36 <ehird> AnMaster: the two programs run simultaneously
20:17:40 <ehird> (a,b) matchup = (b,a) matchup
20:17:53 <ehird> i haven't added that yet
20:18:04 <AnMaster> ehird, saving it would slow you down
20:18:11 <AnMaster> so try to work it out backwards
20:18:11 <ehird> AnMaster: dude. by 1 cycle.
20:18:29 <AnMaster> only overhead if there actually is a loop then
20:19:10 <ehird> ./lance 0.00s user 0.00s system 73% cpu 0.004 total
20:19:12 <ehird> i'm sure I can spare a few more miliseconds
20:19:39 <AnMaster> ehird, shouldn't the two input files be listed there too
20:19:40 <ehird> GregorR-L: run 200k cycles
20:19:43 <ehird> although not completely
20:19:45 <ehird> AnMaster: it's debugging code
20:19:48 <ehird> GregorR-L: err, 100k
20:19:50 <GregorR-L> Of what? You didn't give it any programs :P
20:19:55 <ehird> GregorR-L: it's my interp.
20:19:58 <ehird> it has built in ones
20:20:00 <ehird> it's testing code.
20:20:11 <ehird> but [>[-]+] and >+[]<[-]
20:20:15 <AnMaster> interpreter with built in programs!
20:20:20 <ehird> AnMaster: currently a total 42 match would take 0.168 seconds
20:20:41 <ehird> AnMaster: and remember
20:20:45 <ehird> there isn't any win logic
20:20:48 <ehird> so it runs forever
20:20:52 <ehird> admittedly, they probably just nop forever
20:21:10 <ehird> AnMaster: so if there's 10 other programs on a hill, and we run a new program for every polarity/tapelength change (which we won't)
20:21:12 <AnMaster> ehird, do you pre-expand * and %
20:21:15 <ehird> adding a new warrior would take 1.68 seconds
20:21:18 <ehird> which is just fine
20:21:28 <ehird> AnMaster: no, I'm going to use nescience's method which avoids expanding them altogether
20:21:33 <ehird> don't do anything with them atm
20:22:01 <ehird> AnMaster: hard to understand is what it is
20:22:29 <AnMaster> I'd guess it it would be interpret the code without expanding it
20:22:30 <ehird> i can't, i don't understand it.
20:22:34 <ehird> AnMaster: pretty much
20:23:30 <AnMaster> (+)*3 would then do get_next_instruction(), which would notice at the ) that there are some "not actually expanded" expansions left.
20:23:49 <AnMaster> seems simple enough to handle ({}) too that way
20:24:06 <AnMaster> I think it would possibly be slower for short programs though
20:24:34 <AnMaster> ehird, is that what you meant?
20:26:42 <AnMaster> ehird, do you understand what I mean though?
20:27:40 <AnMaster> nescience, was the above what you meant
20:27:53 <AnMaster> ehird, also how would you implement it if you didn't understand it
20:28:10 <ehird> AnMaster: difficultly
20:28:16 <bsmntbombdood> it would seem that hash tables are vulnerable to denial of service attacks
20:28:27 <AnMaster> ehird, yeah, that is why I haven't used extended gcd for polynoms yet!
20:28:37 -!- Hiato has joined.
20:28:41 <AnMaster> because I don't understand the maths behind it
20:28:45 <ehird> bsmntbombdood: s/tables //
20:28:53 <ehird> s/hash /hash functions /
20:29:16 <AnMaster> ehird, not cryptographically secure hash tables.
20:29:33 <ehird> AnMaster: hash functions are inevitably DoSable
20:29:45 <ehird> pigeonhole problem
20:29:59 <AnMaster> yes. But good luck doing that for something like sha512
20:30:13 <ehird> i don't think you understand.
20:30:26 <ehird> AnMaster: btw sha-1 is being attacked, sha-2 is next.
20:30:26 <bsmntbombdood> AnMaster: you can't use all 512 bits for indexing your table
20:30:32 <AnMaster> ehird, no I don't understand why you did "<ehird> bsmntbombdood: s/tables // <ehird> s/hash /hash functions /"
20:30:36 <ehird> brute force can only go far— and what bsmntbombdood said.
20:30:41 <AnMaster> ehird, and ok. What about Whirlpool.
20:30:46 <bsmntbombdood> you'll only end up having to collide 32 bits or so, which is very easy
20:30:50 <ehird> you need a 64-bit hash function
20:30:58 <ehird> or 128-bit if you have a weird supercomputer
20:30:58 <EgoBot> Score for nescience_whoops: 14.4
20:31:11 <nescience> not many using something susceptible to that now i guess
20:31:18 <AnMaster> nescience, ah, care to explain what you meant then above
20:31:44 <ehird> !bfjoust spoohw (-)*127>+[]<[[-+]+]
20:31:55 <EgoBot> Score for ehird_spoohw: 15.1
20:32:22 <EgoBot> Score for nescience_whoops: 13.6
20:32:52 <nescience> delay a beat because of double brackets
20:32:53 <EgoBot> Score for nescience_whoops: 14.4
20:33:29 <ehird> nescience: explain to AnMaster the avoid-expanding thang
20:33:40 <nescience> also lol i didn't notice there was already a 'whoops'
20:34:47 <GregorR-L> !bfjoust spleen (>(+)*128>(-)*128)*5
20:34:58 <EgoBot> Score for GregorR-L_spleen: 8.0
20:35:00 <nescience> for the case of ({})%N, evaluating left to right as normal, you should behave as follows:
20:35:25 <nescience> when you encounter {, increase a counter; if the counter is equal to N, proceed on, else jump back to (
20:35:38 <nescience> when you encounter ), decrease the counter; if it is equal to 0, proceed on, else jump back to }
20:35:50 <nescience> otherwise handle [] brackets normally, they can jump back and forth across {} with no trouble
20:36:11 -!- jix_ has quit ("leaving").
20:36:39 <ehird> nescience: hm, how is } handled there?
20:37:20 <ehird> nescience: how does egojoust handle (a{b}c)*N, I wonder?
20:37:23 <ehird> ignore the { and }?
20:37:39 <GregorR-L> Or, more accurately, repeat them in the output :P
20:37:45 <ehird> GregorR-L: does it still parse them as instructions
20:37:48 <ehird> but just treat them as nops?
20:38:35 <ehird> it just seems a pain, since you have to delay parsing until )
20:38:53 <nescience> yeah, you have to know if you have a %loop or a *loop
20:39:00 <nescience> i had it in mind to pre-process the program
20:39:01 <ehird> nescience: also, you can treat them as invisible nops
20:39:04 <nescience> and match up all the brackets, setting pointers
20:39:11 <ehird> "when {, perform next operation"
20:39:14 <nescience> yes, but { needs to do more than nop
20:39:25 <ehird> nescience: not when you're in a * loop
20:39:29 <ehird> which is the case I meant
20:39:32 <ehird> you can have nops that last 0 cycles
20:39:38 <ehird> by simply making them do "run-next-cycle"
20:39:44 <ehird> which seems like the simplest way to parse this
20:40:10 <nescience> it is probably possible to allow constructs of the form
20:40:34 <nescience> i mean, supposing the brackets are balanced
20:40:37 <Deewiant> http://www37.wolframalpha.com/input/?i=how%20to%20program
20:40:48 <ehird> Deewiant: BAHAHAHAHAHAHAHAHAHAHA
20:40:51 <nescience> actually, i'm unsure but i think that all you'd have to do to make that work is not discard your working counter
20:40:53 <ehird> ahahahhahaahahahaahahahaaa
20:41:22 <ehird> nescience: you could make (a[)*Nb(]c)*N work, by transforming it into (a[{b}]c)*N behind the scenes
20:41:26 <ehird> i.e., just having that as an internal syntax
20:41:31 <ehird> just for () including [/]
20:41:38 <ehird> orthogonality++, stillworks++
20:42:15 <nescience> you could, but i think the syntax is more confusing
20:42:22 <nescience> and you have extra syntax constraints (the Ns must match)
20:42:54 <ehird> nescience: not really
20:43:01 <ehird> nescience: i mean, intuitively, expansions happen beforehand
20:43:25 <ehird> nescience: which is, of course, an unmatched [
20:43:31 <ehird> you could just report it as that
20:49:34 <nescience> to be honest i don't like the ({}) syntax much
20:50:08 <nescience> people will be tempted to do something like
20:50:39 <nescience> which is still handlable without expanding, but would require more work
20:50:48 <nescience> and doesn't convert directly to the other syntax
20:51:21 <ehird> nescience: that is nice, though
20:51:28 <ehird> can you even do that easily with ({})?
20:51:47 <nescience> you know what might make things more pleasant to look at btw
20:51:58 <nescience> but if no () only apply it to the last char
20:52:26 <nescience> you could probably remove the * entirely
20:52:34 <nescience> if you assume decimal digits are multipliers
20:52:48 <nescience> in that case, i might be more tempted to agree with you to getting rid of ({})
20:52:52 <nescience> but parsing would be a lot more complicated
20:53:26 <nescience> you'd probably also have to "scan" ahead when processing
20:53:36 <ehird> that's LR(something)
20:53:38 <nescience> you can't just jump directly to the same bracket
20:53:51 <ehird> nescience: if you don't allow 0,
20:53:54 <nescience> that's the nice thing about it, you don't need any special handling for []
20:53:56 <ehird> you can just parse a number as "repeat last command"
20:54:20 <ehird> nescience: no, that's impossible
20:54:25 <ehird> +0 -> +, repeat -1
20:54:29 <ehird> i'm talking about avoiding lookahead
20:54:40 <nescience> you won't be able to avoid lookahead if you get rid of ({})
20:54:49 <nescience> well, you'll have more of it than otherwise
20:55:21 <nescience> it wouldn't be before execution, it'd be after
20:55:27 <nescience> but you'd have a lot more scanning instead of direct jumps
20:55:28 <ehird> nescience: i mean trivial syntactic overhead
20:55:36 <ehird> instead of + looking for a number
20:55:42 <ehird> then a repeat node
20:56:28 <AnMaster> nescience, that seems simple enough
20:56:28 <nescience> well, if you want to avoid lookahead you could always put the digit *before* the code to be repeated
20:57:34 <ehird> nescience: we just need a metalanguage ;0
20:57:51 <nescience> AnMaster: it is, it's just a little confusing to sit down and think about it and realize how simple it is :P
20:58:25 <AnMaster> yeah, having to do that is confusingly retarded ;P
21:09:09 <AnMaster> <nescience> ([)*4a(])*2b(])*2c <-- it is useful probably
21:11:50 <AnMaster> bsmntbombdood, optimisation is the root of all evil
21:12:06 <AnMaster> don't optimise until you profiled and found it was needed
21:12:08 <ehird> AnMaster: stupidest thing I've ever heard.
21:12:17 <ehird> 21:11 AnMaster: bsmntbombdood, optimisation is the root of all evil
21:12:24 <ehird> i give you the prize of Most Distorting Misquotation of Knuth
21:12:28 <ehird> AnMaster: hahahahaha
21:12:31 <nescience> AnMaster: not so useful that you can't just write it like
21:12:35 <AnMaster> ehird, and yes I know it is a misquote
21:12:53 <AnMaster> ehird, I dropped the premature intentionally
21:13:02 <ehird> AnMaster: you're very stupid. :)
21:13:41 <AnMaster> ehird, like... knowing that "or real part less than zero" doesn't mean a number is imaginary?
21:13:50 <nescience> but it's confusing as hell to do so :P
21:14:18 <ehird> AnMaster: wow, you really are grasping at straws. for one, my position was historically supported; I didn't realize the definition had changed. for two, you couldn't fucking figure out how the extended euclid algorithm works
21:14:41 <AnMaster> ehird, nor could you figure out ({}) yourself?
21:14:46 <ehird> I know how ({}) works.
21:14:56 <ehird> nescience was in a rush when he explained his method to me yesterday.
21:15:01 <ehird> Therefore it came out garbled
21:15:08 <AnMaster> ehird, it was indeed what I thought it was
21:15:16 <nescience> or really anyone else, so? it's just a matter of how much work you wanted to put in
21:15:18 -!- kar8nga has joined.
21:15:33 <AnMaster> nescience, sure do. About jumping to matching ] can be done across {} (assuming no unbalanced [] in {}
21:16:15 <EgoBot> Score for AnMaster_test: 14.9
21:16:24 <AnMaster> !bfjoust test ++(++{[++]}++)%2
21:16:25 <ehird> that's not what he was talking about. that was one aspect of it
21:16:35 -!- Sgeo has joined.
21:16:35 <EgoBot> Score for AnMaster_test: 10.6
21:16:45 <AnMaster> ehird, I'm going to test something in the parser
21:16:47 <AnMaster> !bfjoust test ++(+[+{[++]}+]+)%2
21:16:57 <EgoBot> Score for AnMaster_test: 12.1
21:16:59 <ehird> how can you parse that incorrectly
21:17:05 <AnMaster> !bfjoust test ++[(+[+{++[}+]+)]%2
21:17:11 <AnMaster> !bfjoust test ++[(+[+{++[}+]+)%2]
21:17:22 <EgoBot> Score for AnMaster_test: 15.6
21:17:22 <EgoBot> Score for AnMaster_test: 15.6
21:17:36 <ehird> the latter one is invalid
21:17:55 <AnMaster> ehird, yes. And I was hoping for "yet another segv bug"
21:18:06 <ehird> so now you're flinging shit at GregorR-L's implementation too?
21:18:10 <ehird> you're really on a jackass roll here
21:19:08 <AnMaster> ehird, Plus, a true malicious user could abuse bugs. Thus it is best if they are uncovered and fixed before.
21:19:12 -!- Hiato has quit (Read error: 104 (Connection reset by peer)).
21:19:24 <ehird> nescience: am I in an alternate universe where AnMaster just said that?
21:19:28 <ehird> i mean clog thinks he said it too
21:19:32 <ehird> but it could be quantum fluctuations
21:19:47 <ehird> i don't think a universe where he actually said that could exist without ending due to extreme hilarity
21:20:04 <AnMaster> if an interpreter crashes on malformed input resulting in hill messing up. That is a bug
21:20:25 <nescience> i think i maybe worked out the details about repeating with unbalanced repetitions and brackets
21:21:00 <nescience> but i think you want to keep a decrementing depth counter
21:21:08 <nescience> since the first repetitions of [ are the "outside-est" ones
21:21:18 <nescience> then you seek, and dec for every ] or repeated ]
21:21:29 <nescience> until your counter is less than one you hit
21:21:44 <nescience> seems like more work than it's worth
21:21:46 <psygnisfive> you would do well to read the whole collection of things i said before responding to individual statements
21:22:15 <ehird> ooh, i pissed off psygnisfive
21:22:19 <psygnisfive> since i quickly recognized that trivial loops are ofcourse possible in non-TMs.
21:22:19 <nescience> basically the problem you have is when skipping []s
21:22:21 <ehird> i logread this way, psygnisfive, so phooey :)
21:22:38 <psygnisfive> not pissed off, you're just responding to things that dont need response.
21:23:08 <ehird> psygnisfive: your mom
21:23:44 <nescience> then you just have to locate the proper depth
21:23:52 <psygnisfive> and the real point, ehird, was that some kinds of infinite loops are detectable and avoidable, and those happen to be the kinds that do not require TMs.
21:23:54 <nescience> it would get possibly tricky if you encounter something like
21:24:14 <ehird> psygnisfive: you can detect an infinite loop on an old 386 using a high-end server, probably
21:24:16 <ehird> for almost all applications
21:24:21 <ehird> so it is quite practical
21:24:29 <ehird> and you need a TM to really check finite machines
21:24:34 <ehird> and if you have a TM, why use finite machines?
21:25:36 <psygnisfive> im going to design a language that compiles into JS. o.o;
21:25:47 <ehird> been done 834573495 times
21:25:51 <ehird> there are scheme impls in js
21:25:54 <ehird> that compile to js
21:26:09 <AnMaster> <ehird> i logread this way, psygnisfive, so phooey :) <-- I completely understand why psygnisfive is irritated. The same way of your "respond before you read it all" have irritated me too.
21:26:43 <ehird> AnMaster: Waaah! Bitch some more :). And I hope you complain to ais523 about it, too; he does it in Agora - replies as soon as he reads a mail, despite it being answered one after.
21:26:56 <ehird> But you criticizing ais523 would probably mark the second coming of jesus.
21:27:11 <AnMaster> ehird, luckily I'm not involved in Agora
21:27:21 <psygnisfive> i think the language im going to design is going to be heavily small-talky
21:27:22 <AnMaster> I would however do it if I was affected by it.
21:27:43 <ehird> psygnisfive: there are smalltalks in JS, iirc
21:27:47 <AnMaster> ehird, and ais doesn't log read
21:27:56 <ehird> AnMaster: thankfully I don't care what you think about my logreading responses.
21:28:08 <ehird> don't read them if you don't like 'em
21:28:23 <GregorR-L> #esoteric, the opera: AnMaster comes onto stage and says something incomprehensible. <ehird> You're so stuuuuuupid! <AnMaster> You're so stuuuuuupid. <both> You're so stuuuuuuuuuupid! (harmonizing)
21:28:30 <AnMaster> ehird, and thankfully I don't care what you think about my multiple naming of the similar programs either
21:28:37 <ehird> GregorR-L: Fairly accurate.
21:28:49 <ehird> GregorR-L: One correction.
21:28:57 <ehird> <ehird> should be <Righteous warrior of truth and sanity, ehird>
21:29:11 <AnMaster> ehird, I think he wasn't aiming for a parody
21:29:19 <ehird> AnMaster: I was joking.
21:29:36 <ehird> AnMaster: Also, me responding to logreads doesn't affect anyone else. Cluttering the hill with mututally-drawing does.
21:29:39 <ehird> *mutually-drawing programs
21:29:55 <AnMaster> <ehird> AnMaster: Also, me responding to logreads doesn't affect anyone else. Cluttering the hill with mututally-drawing does. <-- yes it does, for whoever got highlighted
21:30:04 <ehird> AnMaster: /ignore.
21:30:22 <AnMaster> ehird, if I ignored you I would miss half of the discussions in here
21:30:22 <GregorR-L> Y'know what affects people the most? Arguing about stupid things for endless hours.
21:30:31 <ehird> AnMaster: Youuuuuuuuur loss.
21:30:44 <ehird> GregorR-L: Oh, it's quite fun.
21:42:32 <GregorR-L> Good lawd, there's an update every minute all night
21:44:07 <nescience> somebody enlighten me: what's a TM? :P
21:45:07 <nescience> i have no idea why that didn't snap into place immediately
21:45:20 <ehird> http://www.zalman.co.kr/ENG/product/Product_Read.asp?Idx=183 PC/space heater combination! Get yours now!
21:45:25 <nescience> oh hey, microsoft finally coughed up the $$ for my live cash back account
21:54:55 <GregorR-L> http://codu.org/eso/bfjoust/report-2009-05-29-20-17.avi
21:54:57 <ehird> nescience: are you = myndzi\? :P
21:55:21 <ehird> GregorR-L: Quicktime says it's divx.
21:55:49 <ehird> GregorR-L: i don't want to install divx shit
21:55:58 <ehird> can you convert to something more palatable
21:56:02 <GregorR-L> Quicktime requires that you install DivX to decode standard MPEG-4?
21:56:09 <ehird> GregorR-L: it doesn't
21:56:11 <ehird> which is why I asked
21:56:14 <ehird> but it told me to in this case
21:56:21 <Deewiant> GregorR-L: The sorted rankings might've been more interesting to see
21:56:27 <GregorR-L> I didn't even encode it with DivX, I encoded it with lavc, but I set the fourcc to DIVX because most players don't support LVM4
21:56:39 <ehird> GregorR-L: well, do it the LVM4 thing then
21:56:49 <ehird> GregorR-L: what is the video actually of?
21:57:00 <GregorR-L> I'm just gonna stick it in a .mp4 :P
21:57:40 <ehird> !bfjoust slowpoke_revengist (>)*9((-)*128[-[+]]>)*21
21:57:51 <EgoBot> Score for ehird_slowpoke_revengist: 29.7
21:58:35 <ehird> 23:56:13 <nooga_> with a little gap
21:58:38 <ehird> since 2004, apparently
21:58:40 <ehird> dunno when the gap was
21:58:47 <ehird> 23:56:54 <Patashu> (<leonid_> i moved from anagol) <-- same
21:58:52 <ehird> was this advertised on anagolf?
21:59:31 <ehird> !bfjoust slowpoke_revengist (>)*9((-)*128[---[+++]]>)*21
21:59:42 <EgoBot> Score for ehird_slowpoke_revengist: 31.0
21:59:51 <ehird> 23:57:15 <leonid_> me korea
21:59:55 <ehird> the one that has internet or the one that doesn't have internet :D
21:59:58 <ehird> !bfjoust slowpoke_revengist (>)*9((-)*128[---[+++]]>)*21
22:00:07 <ehird> GregorR-L: wtfslow
22:00:09 <EgoBot> Score for ehird_slowpoke_revengist: 31.0
22:00:36 <ehird> !bfjoust slowpoke_revengist (>)*9((-)*128[(+)*128]>)*21
22:00:47 <EgoBot> Score for ehird_slowpoke_revengist: 20.2
22:00:59 <ehird> !bfjoust slowpoke_revengist (>)*9((-)*128[(-)*128]>)*21
22:01:09 <EgoBot> Score for ehird_slowpoke_revengist: 19.8
22:01:12 <ehird> 00:03:47 <leonid_> anagol
22:01:12 <ehird> 00:03:49 <leonid_> more like
22:03:21 <nescience> this is my laptop at work, myndzi is my home client
22:03:52 <ehird> !bfjoust revengist (>)*9[[<+<+>>-]<[>>+<-]+<[>-<[-]]>[->]+]
22:04:02 <EgoBot> Score for ehird_revengist: 15.4
22:04:03 <ehird> hmm that's a terrible algorithm
22:05:27 <GregorR-L> ehird: http://codu.org/eso/bfjoust/report-2009-05-29-20-17.mp4
22:05:40 <ehird> *quicktime freezes*
22:06:01 <ehird> GregorR-L: oh my god the quality is awful
22:06:08 <ehird> it looks like someone soaked the paper
22:06:26 <ehird> GregorR-L: the realigning is kind of irritating, and it should probably be ordered by rank
22:06:33 <ehird> since atm it's just... a bunch of flickering :P
22:06:46 <ehird> also that text rendering looks like... WINDOWS.
22:06:47 <GregorR-L> Let me put my response as plainly as possible.
22:06:57 <ehird> GregorR-L: You forgot "QED"
22:07:55 <Deewiant> ehird: The previous one looked better
22:08:04 <ehird> Deewiant: If only I could watch it
22:08:06 <Deewiant> You have only yourself to blame :-P
22:08:19 <Deewiant> "i don't want to install divx"
22:08:20 <ehird> (I could probably stick it into VLC, but meh.)
22:08:25 <ehird> Deewiant: divx = shitware
22:08:28 <ehird> it adds a bunch of crap to your system
22:08:50 <ehird> Deewiant: i've never told it to and it always does
22:09:05 <GregorR-L> The previous one didn't look better.
22:09:06 <Deewiant> Although admittedly, I haven't installed it since something like over 5 years ago
22:09:20 <Deewiant> Well now it's gone so I can't compare
22:09:41 <Deewiant> Maybe I'm just confused, whatever
22:09:46 -!- Corun has changed nick to Corun|away.
22:10:03 <GregorR-L> Good lawd why don't people understand this.
22:10:33 <Deewiant> I could understand my player fucking something up for different container formats :-P
22:10:57 <GregorR-L> MPEG-4 is a video format. DivX is an encoder that encodes to MPEG-4. .avi has the unfortunate property that it names things by the encoder, not the format. So when I make MPEG-4 .avi's, I call them DIVX, because that's supported most everywhere and everything recognizes that it's just MPEG-4. Except of course for ShitTime.
22:11:41 <GregorR-L> So the fact that Quicktime wants to install DivX is just stupidity to the power of stupidity.
22:12:26 <GregorR-L> From now on I'm making all my videos with ffhuffv video and snow audio so nobody can play them but me :P
22:12:45 <GregorR-L> Those are both ffmpeg-specific formats.
22:13:02 <GregorR-L> Oh yeah, ffvhuff, not ffhuffv ... I was close :P
22:13:03 <Deewiant> And if snow is ffmpeg then I can play that, too :-P
22:16:33 <ehird> 00:50:45 <nooga_> it's unhealthy to drink milk, for adults
22:16:38 <ehird> Also, unfounded assertion.
22:17:49 <ehird> 00:53:06 <nooga_> Polish cursewords are quite complez
22:17:49 <ehird> 00:53:10 <nooga_> complex
22:17:51 <ehird> 00:53:28 <nooga_> you can create new oneswhen you need
22:17:53 <ehird> a metalanguage just for swearing? :D
22:18:42 <GregorR-L> <ehird> 00:50:45 <nooga_> it's unhealthy to drink milk, for adults // this isn't untrue, just outdated.
22:18:58 <ehird> GregorR-L: It's certainly an assertion provided without foundation.
22:19:13 <ehird> GregorR-L: oh, that'd explain his intelligence
22:19:17 <ehird> INSTANT RIMSHOT DOT COM
22:19:30 <GregorR-L> Cro-magnons were no less intelligent than us, but sure :P
22:19:50 <ehird> GregorR-L: Uh... That's the joke!
22:19:51 <ehird> INSTANT RIMSHOT DOT COM
22:20:30 <EgoBot> http://google.com/search?q=omg+liek+wtf
22:20:40 <ehird> [[Of modern nationalities, Finns are closest to Cro-Magnons in terms of anthropological measurements.]]
22:20:46 <EgoBot> bf +++++++++++++++[>+++++++>+++++++>++++>+<<<<-]>-.++++++++++++..----.>>--.-----------..<--.++++++++..--------.<----.>--.>-.<--.<+++.--.>>+.<<++++++.>++.----.<-.>++.+++++.>++++++++++++++++.<<-.>>--.,[>[-]>[-]<<[>+>+<<-]>>>[-]++++++++[<---->-]<[[-]>+<]>-[<<[-]>+++++++[<++++++>-]<+>>[-]]<<.[-]<,]
22:21:09 <Deewiant> !bfjoust google +++++++++++++++[>+++++++>+++++++>++++>+<<<<-]>-.++++++++++++..----.>>--.-----------..<--.++++++++..--------.<----.>--.>-.<--.<+++.--.>>+.<<++++++.>++.----.<-.>++.+++++.>++++++++++++++++.<<-.>>--.,[>[-]>[-]<<[>+>+<<-]>>>[-]++++++++[<---->-]<[[-]>+<]>-[<<[-]>+++++++[<++++++>-]<+>>[-]]<<.[-]<,]
22:21:20 <EgoBot> Score for Deewiant_google: 6.2
22:21:51 <ehird> !bf_txtgen I am killing you with the power of my mind.
22:21:57 <EgoBot> 444 +++++++++++++++[>++>+++++>+++++++>+++++++<<<<-]>>--.<++.>++++++++++++++++++++++++.>>++++.<<<.>++++++++++.>.>-..<.>++.<--.<<.>>>+++++++++++.<<++++.++++++.<.>>>--.<++.<-.>-.<<.>.>.---.---------------------------------------------------------------------.>-------.-.++++++++.<<<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>--.>.<---.<+.>>.<--.>>++.<.<.----.+++++.<--.>>++++++++++++++.------------------------------------. [902]
22:22:10 <ehird> !bfjoust telepath_homicider +++++++++++++++[>++>+++++>+++++++>+++++++<<<<-]>>--.<++.>++++++++++++++++++++++++.>>++++.<<<.>++++++++++.>.>-..<.>++.<--.<<.>>>+++++++++++.<<++++.++++++.<.>>>--.<++.<-.>-.<<.>.>.---.---------------------------------------------------------------------.>-------.-.++++++++.<<<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>--.>.<---.<+.>>.<--.>>++.<.<.----.+++++.<--.>>++++++++++++++.-----------------------
22:22:21 <EgoBot> Score for ehird_telepath_homicider: 3.8
22:22:32 <GregorR-L> !bfjoust i_am_kiling_you_with_the_power_of_my_mind +++++++++++++++[>++>+++++>+++++++>+++++++<<<<-]>>--.<++.>++++++++++++++++++++++++.>>++++.<<<.>++++++++++.>.>-..<.>++.<--.<<.>>>+++++++++++.<<++++.++++++.<.>>>--.<++.<-.>-.<<.>.>.---.---------------------------------------------------------------------.>-------.-.++++++++.<<<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>--.>.<---.<+.>>.<--.>>++.<.<.----.+
22:22:32 <GregorR-L> ++++.<--.>>++++++++++++++.------------------------------------.
22:22:46 <EgoBot> Score for GregorR-L_i_am_kiling_you_with_the_power_of_my_mind: 3.8
22:22:56 <GregorR-L> !bf_txtgen oh shit nooooooooooooooooooo
22:23:00 <EgoBot> 119 +++++++++++++++[>+++++++>+++++++>++>+<<<<-]>++++++.>-.>++.<<++++.>.+.<+.>>.<+++++.+......<-----..>..<...>......>>-----. [998]
22:23:01 <pikhq> !bftextgen I kill you with the power of my mind!
22:23:24 <GregorR-L> !bfjoust oh_shit_nooooooooooooooooooo +++++++++++++++[>+++++++>+++++++>++>+<<<<-]>++++++.>-.>++.<<++++.>.+.<+.>>.<+++++.+......<-----..>..<...>......>>-----.
22:23:28 <ehird> !bf_txtgen You are dead. Is this awesome? [Y/N]
22:23:30 <EgoBot> 334 +++++++++++[>+++>++++++++>++++++++++>++++<<<<-]>>+.>+.++++++.<<-.>++++++++.>---.<++++.<.>>--------------.+.----.+++.>++.<<<.>>>+++++++++++++++++++++++++++.<<++++++++++++++.<.>+.>++++.+.<-.<.>>--------.<++++.>++++.<----.----.--.>.>----------.<<<.>>----------.--.>----------------.<-----------.<----------------.<----------------------. [497]
22:23:37 <EgoBot> Score for GregorR-L_oh_shit_nooooooooooooooooooo: 8.5
22:23:39 <ehird> !bfjoust f +++++++++++[>+++>++++++++>++++++++++>++++<<<<-]>>+.>+.++++++.<<-.>++++++++.>---.<++++.<.>>--------------.+.----.+++.>++.<<<.>>>+++++++++++++++++++++++++++.<<++++++++++++++.<.>+.>++++.+.<-.<.>>--------.<++++.>++++.<----.----.--.>.>----------.<<<.>>----------.--.>----------------.<-----------.<----------------.<----------------------.
22:23:50 <EgoBot> Score for ehird_f: 3.8
22:23:57 <pikhq> !bf_txtgen I kill you with the power of my mind!
22:23:59 <EgoBot> 269 +++++++++++++++[>+++++++>+++++>+++++++>++++++++<<<<-]>>--.-----------------------------------------.<++.>>.+++..<.>>+.<<<++++.++++++.>.>>--.<---.>---.<-.<.<-.>>.---.<.<----.-.++++++++.>>.>--.<<.>>---.<+.<.>+++++++.<<++.>.>.>------.<+.>-----.<<+.-----------------------. [802]
22:24:07 <ehird> !bfjoust pikhq +++++++++++++++[>+++++++>+++++>+++++++>++++++++<<<<-]>>--.-----------------------------------------.<++.>>.+++..<.>>+.<<<++++.++++++.>.>>--.<---.>---.<-.<.<-.>>.---.<.<----.-.++++++++.>>.>--.<<.>>---.<+.<.>+++++++.<<++.>.>.>------.<+.>-----.<<+.-----------------------.
22:24:17 <EgoBot> Score for ehird_pikhq: 3.8
22:24:36 <EgoBot> Use: !bfjoust <program name> <program>
22:24:53 <EgoBot> Score for pikhq__: 9.9
22:25:11 <pikhq> MI ESTAS VEJNANTO!
22:26:59 <EgoBot> Score for GregorR-L_pooper_scooper: 0.0
22:27:26 <ehird> that lost against everything
22:27:29 <ehird> how did you do that GregorR-L
22:28:25 <GregorR-L> I prevented anything from running off the tape I guess.
22:29:13 <pikhq> !bfjoust vejni [>+<-]
22:29:17 <pikhq> Might work better.
22:29:24 <EgoBot> Score for pikhq_vejni: 1.8
22:30:06 <pikhq> I think it lost against pooper_scooper
22:30:44 <ehird> 01:14:29 <nooga_> my IQ went from 137 to 50
22:31:06 -!- Corun|away has changed nick to Corun.
22:31:13 <pikhq> ehird: I can do that. No sleep for two or three days.
22:31:24 <ehird> to 50? are you sure
22:31:26 <pikhq> Erm. Actually, no.
22:31:37 <pikhq> That just cuts my IQ in third, getting me to dead average.
22:34:03 <GregorR-L> I believe pikhq just claimed his IQ is 300.
22:34:11 <ehird> GregorR-L: Yeah, I thought that for a second :P
22:34:11 <GregorR-L> Making him the smartest human being who ever lived.
22:34:14 <ehird> I think he means 133.
22:34:34 <ehird> Yeah, he just said his IQ is 300 :P
22:36:03 <ehird> pikhq: so what did you mean :P
22:36:29 <pikhq> I'm not exactly demonstrating that right now. :p
22:37:10 <ehird> 150 is very unusually high; is the source here an internet IQ test? :P
22:37:11 <pikhq> So, chop off a third and it goes down to 100.
22:37:21 <pikhq> ehird: Nope. School-administered.
22:37:45 <pikhq> (some teacher thought I was retarded because I was bored in class and not paying any attention.)
22:37:55 <ehird> pikhq: I'm not sure I believe you. Heck, http://upload.wikimedia.org/wikipedia/commons/f/f7/IQ_curve.svg ends at 140 with a tiny, tiny percentage :P
22:38:50 <pikhq> ehird: And then realise that we're all on that end of the bell curve.
22:39:02 <ehird> I don't think that is true.
22:39:12 <ehird> Well, yes, that end.
22:39:46 <pikhq> We find Brainfuck a simple and easy language.
22:40:05 <pikhq> We create and use difficult programming languages because it's entertaining.
22:40:23 <ehird> pikhq: Finding brainfuck simple and easy != intelligence. IQ = pattern matching ability.
22:40:45 <pikhq> There's at least some correlation with IQ there.
22:41:27 <pikhq> Obviously an imperfect one, since the IQ tests are rather flawed, but still.
22:42:35 <ehird> I just find it unlikely that the reading of 150 was unbiased and accurate.
22:43:55 <ehird> GregorR-L: From that line, I deduce that your IQ is 72.94.
22:44:04 <pikhq> I'd say there's about a 1 in a few thousand chance of it being accurate.
22:44:50 <ehird> pikhq: Hey, more likely than winning the lottery.
22:45:15 <pikhq> Significantly more-so, in fact.
22:45:40 <GregorR-L> ehird: Frankly, your discourse occurs to me as malignant and POOPY-HEADED.
22:46:16 <pikhq> GregorR-L: Thy discourse is shameful to us all.
22:46:32 <pikhq> ehird: This is true of thine, as well.
22:47:30 <pikhq> ehird: Wallow in thy shame.
22:47:52 <pikhq> GregorR-L: Thou should consider it, but 'twould require more shame from thee.
22:48:06 <ehird> You're anti-meaningful.
22:48:33 <pikhq> Sweet! I wrapped arround!
22:48:46 <pikhq> GregorR-L: doþ, þou mean'st.
22:49:20 <pikhq> GregorR-L: If you use an int for it.
22:49:30 <pikhq> I wonder what sort of society would need an int for IQ.
22:49:56 <ehird> pikhq: By the way, if your IQ _is_ 150, then you're in the 99.997th percentile.
22:50:13 <GregorR-L> That's more common than my chrome allergy.
22:50:23 <ehird> pikhq: a bit over the top 0.1%
22:50:27 <ehird> (=99.9th percentile)
22:50:33 <ehird> * Top 0.00003% (99.99997th percentile; IQ 175 sd15, IQ 180 sd16): OLYMPIQ Society, PARS Society
22:50:37 <ehird> Also known as the "liar society"
22:51:08 <ehird> http://olymp.iqsociety.org/
22:51:12 <ehird> http://www.ELLHNAS.com/
22:51:15 <ehird> Damn, talk about egotistical
22:51:19 <Deewiant> 0.1%? All of Finland and a million elsewhere, then
22:51:33 <pikhq> I tend to regularly be in about the 99.9th percentile on standardised tests given in school. Man, those things were easy.
22:52:03 <ehird> pikhq: [[The ceiling of most standardized (validated and normed) intelligence tests is at around 99.9th percentile. Measurements above this level need — for a credible result — a calculation, extrapolation and interpretation (including observations during the tests and sub-tests) by psychometricians experienced in high IQ testing, and at least two differently designed standardized tests (among these at least one supervised) should be performed.]]
22:52:23 * ehird crushing hopes and dreams since 1995
22:52:30 <pikhq> ehird: Well aware that they stop meaning much in the 140-150 mark. ;)
22:52:34 <GregorR-L> "a Greek medical doctor known also as GrIQ"
22:52:52 <ehird> GregorR-L: His site's opening page is so creepy
22:52:53 <pikhq> "You're really, really fucking smart. Um, yeah. I got nothing."
22:53:03 <ehird> A MILLION GRIQS ALL STARING AT EACH OTHER AND YOU
22:53:59 <ehird> "Sigma VI 99.9999999% QI>196 +6s "
22:54:03 <nescience> i was just trying to explain to someone why a 32 bit prng is insufficient for properly doing card games
22:54:05 <ehird> Membership: 0 people
22:54:20 <nescience> and he tells me "random is random" (referring to mirc's built in PRNG, which is probably just the c library, which is ass)
22:54:39 <ehird> GregorR-L: [[Membership of The Giga Society is ideally open to anyone outscoring .999999999 of the adult population on at least one of the accepted tests.]]
22:54:39 <nescience> i explain why, and then he responds "random is random"
22:54:55 <nescience> he wants me to prove to him that you can make a shuffle algorithm that'll generate teh same deck twice
22:54:56 <GregorR-L> nescience: It uses measurement of the americium particles in your computer.
22:54:58 <ehird> I don't even know what that percentile is
22:55:11 <nescience> it so happens that i have like 5 prngs ported to mirc though so that was easy to do :P
22:55:22 <nescience> lol americium? is that a diss on americans?
22:55:51 -!- psygnisfive has quit (Read error: 104 (Connection reset by peer)).
22:55:55 <GregorR-L> ........... americium is a common alpha radiator used most popularly in smoke detectors but also in "true" random number generators.
22:56:02 -!- psygnisfive has joined.
22:56:20 <ehird> GregorR-L: [[Many think the Giga Society can only have six or seven members as a result of its admission level and the size of the world population. This is false. The top six or seven are not the same individuals at each moment but are being replaced constantly. And as existing members are not expelled when they are no longer among the top six or seven, a multiple of that number of members is possible over time.]]
22:56:42 <ehird> "Not just six or seven. If more intelligent people grow up and the previous ones stay alive, we could have up to TWENTY members!"
22:57:09 <ehird> [[As an aside, the member list is not public]]
22:57:14 <ehird> INTELLIGENCE=SECRECY
22:57:26 <ehird> the owner calls himself the Psychometitor
22:57:40 <nescience> i guess i need to l2periodic table
22:57:40 <ehird> [[one must be careful with information found on do-it-yourself online encyclopaedias, as there is a tendency for megalomaniacs to write themselves into the member list. ]]
22:57:46 <ehird> Your fucking society is based around being megalomaniacal.
22:57:48 <nescience> well anyway, i have no such hardware card
22:57:53 <nescience> and the discussion was about software PRNGS anyway
22:58:20 <pikhq> ehird: I suspect that those eligible include Hawking and some other freak out there.
22:58:36 <pikhq> (Hawking is not likely to be a member; I recall him saying that such societies were just stupid)
22:58:51 <ehird> pikhq: What is it with people thinking that good physicist = overflowing IQ?
22:59:29 <pikhq> ehird: Arg. I heard somewhere that he actually had an absurdly high IQ. Now that I think of it, I was able to find no evidence of such.
22:59:55 <pikhq> DAMMIT, RUMORS. STOP PERMEATING MY BRAIN.
23:02:16 -!- olsner has quit (anthony.freenode.net irc.freenode.net).
23:02:29 * GregorR-L tries to think of a meaning of per-meat-ing.
23:02:54 <GregorR-L> "I'd like to sell you this meat. How much?" "2 dollars permeating."
23:03:21 <ehird> GregorR-L: "Hey gal, what's the rate?" "50 dollars per meating."
23:03:26 -!- olsner has joined.
23:07:59 <GregorR-L> Maybe '' dropped out of English because it looks so effing similar to 'p' :P
23:08:30 <pikhq> Worked a bit better with þ written like it was in runes.
23:08:48 <pikhq> The little round bit looked more... ›-like.
23:10:07 <GregorR-L> Yeah, but p's were written that way too, then :P
23:11:15 * pikhq pulls up the futhark, hoping to say 'no'.
23:11:38 -!- psygnisfive has quit (Read error: 104 (Connection reset by peer)).
23:11:50 -!- psygnisfive has joined.
23:11:58 <pikhq> Yeah, perþ looks completely different.
23:12:14 <pikhq> http://en.wikipedia.org/wiki/%E1%9B%88
23:12:38 -!- kar8nga has quit (Remote closed the connection).
23:13:37 <pikhq> Wynn looks similar, though.
23:13:38 <pikhq> http://en.wikipedia.org/wiki/%E1%9A%B9
23:16:00 <FireFly> Didn't know there's a Unicode block for runes
23:16:13 <pikhq> FireFly: There's a Unicode block for almost everything.
23:16:19 <GregorR-L> There's a unicode block for fekking ogham.
23:16:59 <pikhq> There's even a proposal for Voynich.
23:19:45 <myndzi\> nobody even knows what it says
23:19:46 <pikhq> Yes, Unicode will probably soon support a script that has been used for exactly one known document.
23:19:51 <pikhq> That nobody understands.
23:20:01 <myndzi\> can't wait to go trollin' forums with that
23:20:22 <Deewiant> That a proposal exists doesn't mean it'll be accepted
23:20:51 <pikhq> Deewiant: It's likely to be included in the next Unicode version, though.
23:21:05 <Deewiant> Whence do you get this "likely"
23:21:42 <myndzi\> if you have that many symbols available and nothing better to do with them..?
23:21:55 <Deewiant> There have been rejected proposals in the past, more sensible ones than Voynich :-P
23:22:05 <myndzi\> they even have unicode butterflies! Ƹ̵̡Ӝ̵̨̄Ʒ
23:22:18 <Deewiant> For instance, Klingon wasn't accepted
23:22:41 <Deewiant> "2001-May-21, rejected by the UTC as inappropriate for encoding, for multiple reasons stated in L2/01-212. (Lack of evidence of usage in published literature, lack of organized community interest in its standardization, no resolution of potential trademark and copyright issues, question about its status as a cipher rather than a script, and so on.)"
23:22:41 <myndzi\> klingon should totally be accepted
23:22:49 <GregorR-L> And yet, ey do have frikkin Ogham.
23:22:55 <pikhq> Deewiant: It is being reconsidered.
23:23:16 <Deewiant> Yes, I imagine that interest would certainly have increased since 2001
23:24:15 <myndzi\> so yeah. unicode quenya anyone? :(
23:24:21 <pikhq> The Klingon community has since published literature, has a standards organization, and has more importantly started using Klingon script.
23:24:26 <pikhq> myndzi\: It's being considered.
23:25:11 <FireFly> One should make a programming language based on Klingon
23:25:18 <FireFly> But it's probably been done
23:25:37 <Deewiant> http://esolangs.org/wiki/Var%27aq
23:25:56 <FireFly> But then again I know nothing 'bout Star Trek :P
23:26:14 <GregorR-L> Damn, it seems an xchat plugin can't catch input before it's sent.
23:33:26 -!- Judofyr has quit (Remote closed the connection).
23:39:23 -!- GregorR-L has quit (Remote closed the connection).
23:39:46 -!- GregorR-L has joined.
23:44:21 -!- inurinternet has quit (No route to host).
23:50:01 -!- nooga has joined.