←2009-05-28 2009-05-29 2009-05-30→ ↑2009 ↑all
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:30 <KingOfKarlsruhe> !bfjoust king (([-])>)*20[<-]
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:49 <ehird> lol wut?
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:09 <ehird> right
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:14 <ais523> or something
00:01:15 <ehird> haha
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:30 <ehird> SCREAM A LOT.
00:01:33 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*7(>[+][+][+])*20
00:01:36 <EgoBot> Score for leonid__lols: 30.7
00:01:39 <leonid_> ....
00:01:41 <AnMaster> ehird, control reaches end:
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:58 <ehird> typedef struct {
00:01:58 <ehird> ins_t *prog;
00:01:59 <AnMaster> int foo(void) { /* noreturn here */ }
00:02:00 <ehird> int pointer;
00:02:01 <AnMaster> that
00:02:02 <ehird> } warrior_t;
00:02:03 <ehird> *wonders if a warrior consists of anything else*
00:02:06 <ehird> AnMaster: I know.
00:02:07 <leonid_> !bfjoust lols ((-)*64>(+)*64>)*8(>([+])*10)*20
00:02:08 <ehird> I was talking about the rest.
00:02:08 <AnMaster> right
00:02:10 <EgoBot> Score for leonid__lols: 30.7
00:02:13 <AnMaster> ehird, the inline bit?
00:02:14 <ais523> haha, I just figured out what's wrong with isthata128
00:02:15 <AnMaster> yeah
00:02:16 <AnMaster> no idea
00:02:19 <ais523> !bfjoust isthata128 (>)*9((+)*128.>)*21
00:02:22 <EgoBot> Score for ais523_isthata128: 27.5
00:02:27 <ais523> that's better
00:02:59 <AnMaster> ais523, idea: make a program that won't draw against itself
00:03:04 <AnMaster> is it possible?
00:03:04 <ais523> also, that beats defend6, although it wouldn't beat the parody version
00:03:05 <ais523> AnMaster: you can't
00:03:12 <ais523> there's no way to break symmetry
00:03:13 <AnMaster> ais523, has it been proven?
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:32 <AnMaster> what about
00:03:34 <AnMaster> [-]
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 <AnMaster> ah bugger
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:31 <AnMaster> in "kettle" mode
00:04:32 <EgoBot> Score for leonid__lols: 23.5
00:04:34 <KingOfKarlsruhe> !bfjoust king >[(++>++<<)*256>(+)*128<-]
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:13 <KingOfKarlsruhe> !bfjoust king [>[(++>++<<)*256>(+)*128<-]+]
00:05:16 <EgoBot> Score for KingOfKarlsruhe_king: 4.2
00:05:48 <ais523> ehird: ?
00:05:49 <AnMaster> hm
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:09 <AnMaster> what about a massive battle?
00:06:11 <ais523> ehird: hmm, I'm not sure
00:06:17 <AnMaster> hm
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:42 <AnMaster> ehird, befunge joust?
00:06:43 <nescience> v move poitner down
00:06:45 <ehird> which, though it would be fun, sounds very scary
00:06:45 <nescience> ^ move pointer up
00:06:46 <nescience> :D
00:06:49 <ehird> nescience: that's just 2D
00:06:52 <Deewiant> 4 would work, at least
00:06:53 <ehird> you'd need number-of-warriors-D
00:06:58 <AnMaster> befunge joust
00:07:00 <AnMaster> clearly
00:07:01 <AnMaster> ehird, ^
00:07:01 <Deewiant> 4 programs in 2D
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:07 <ehird> in ~2007
00:07:10 <AnMaster> ehird, link?
00:07:12 <ehird> BeYorFunge.
00:07:13 <Deewiant> They run simultaneously in both directions
00:07:17 <ehird> AnMaster: /old_hd/
00:07:18 <AnMaster> kay
00:07:22 <AnMaster> ehird, on wiki?
00:07:25 <ehird> Nope.
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:44 <AnMaster> or is it dead?
00:07:46 <ehird> AnMaster: The interp had a bug of some sort that I didn't find
00:07:50 <AnMaster> ah
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:16 <ehird> Very simple.
00:08:18 <AnMaster> um ok
00:08:22 <AnMaster> that is not what I mean
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:31 <AnMaster> shared boeard
00:08:32 * pikhq discovered ~/pebble2 today. Good idea.
00:08:35 <AnMaster> board*
00:08:40 <AnMaster> like shared tape in joust
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:19 <AnMaster> ehird, but mirror the boards
00:09:21 <AnMaster> like in joust
00:09:32 <AnMaster> so
00:09:34 <ehird> hmm.
00:09:35 <ehird> could work
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:09:58 <ehird> no movement cost
00:10:00 <AnMaster> so the program sees itself in the top corner
00:10:09 <AnMaster> ehird, local and far pointers
00:10:14 <ehird> ew.
00:10:18 <AnMaster> ehird, same idea!
00:10:34 <AnMaster> you can access the closest 4x4 or something
00:10:40 <AnMaster> fast
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:09 <AnMaster> ah
00:11:10 <ais523> *above 15
00:11:13 <ehird> AnMaster: it needs to have linear increases as distance increases
00:11:14 <ehird> or exponential
00:11:16 <AnMaster> ais523, that is true
00:11:18 <ehird> but not 0
00:11:20 <ehird> as in yours
00:11:23 <ehird> (it only increases once)
00:11:31 <AnMaster> ehird, true
00:11:51 <AnMaster> ais523, what about making the VALUE relative then?
00:12:16 <AnMaster> so P added/substracted a valuue
00:12:18 <AnMaster> value*
00:12:33 <AnMaster> or g or p rather
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:19 <ehird> ais523: ah
00:14:28 <ehird> ais523: got a just-as-simple other warrior to pit it against as a test?
00:14:30 <ehird> really trivial
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:15:58 <ais523> >+++>---[>[-]+]
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:26 <ehird> sure
00:17:31 <ehird> or rather
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:07 <ais523> hmm...
00:18:11 <ais523> what about this:
00:18:14 <ais523> >[]<[-]
00:18:19 <ais523> that's pretty simple
00:18:23 <ais523> and I think it beats /something/
00:18:30 <ehird> ais523: >[]? that terminates immediately, for certain
00:18:35 <ais523> oops
00:18:37 <ehird> the opponent can't reach there soon enough to do anything to it
00:18:38 <ais523> >+[]<[-]
00:18:48 <ais523> it was meant to be a simple tripwire program
00:18:48 <ehird> that's clever
00:18:51 <ehird> you should submit it
00:18:56 <ais523> with an awful-but-might-work defence after the tripwire
00:19:03 <nescience> it's too slow though
00:19:06 <nescience> -] is every 2 cycles
00:19:09 * nescience shrugs
00:19:09 <ais523> !bfjoust stupid_tripwire >+[]<[-]
00:19:10 <leonid_> !bfjoust lols ([]+)*1000
00:19:14 <EgoBot> Score for ais523_stupid_tripwire: 20.4
00:19:14 <EgoBot> Score for leonid__lols: 18.1
00:19:16 <nescience> every other, i mean
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:48 <ehird> oh
00:19:58 <ehird> ais523: unfortunately, won't work
00:20:01 <ehird> <[ takes too long
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:03 <ehird> I think
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:28 <ehird> heh
00:20:32 <ehird> ins_t *a = parse("[>[-]+]", "attack");
00:20:32 <ehird> ins_t *b = parse(">+[]<[-]", "tripwire");
00:20:33 <nescience> that's why i did [.-]
00:20:35 <nescience> prime number
00:20:43 <ehird> !bfjoust primewire >+[]<[.-]
00:20:45 <EgoBot> Score for ehird_primewire: 17.6
00:20:49 <ehird> hurr
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:09 <ehird> haha
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:20 <ehird> that on
00:21:21 <ehird> e
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:38 <ehird> ais523: why?
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:46 <leonid_> !bfjoust lols ([+-]+)*100
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:51 <ais523> but I don't know why
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:37 <ais523> oops
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:46 <ais523> ah, yes
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:09 <ehird> I did not know.
00:25:15 <ais523> thanks impomatic for the [---] counter-defence trick!
00:25:16 <ehird> defense sounds nicer, and fits with "defensive"
00:25:24 <ehird> wow
00:25:26 <ais523> also, 129 is divisible by 3
00:25:26 <ehird> you're at #2
00:25:28 <leonid_> !bfjoust lols ([---]-)*10000
00:25:30 <EgoBot> Score for leonid__lols: 4.7
00:25:36 <leonid_> lack of originality
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:50 <ais523> ehird: 6 isn't prime
00:25:53 <ehird> ah
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:41 <leonid_> sorry
00:26:42 <AnMaster> ais523, ^
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:14 <AnMaster> hm
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 <AnMaster> THE ORIGINAL ONE
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:02 <ehird> oh
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:13 <ais523> and yes, 129 mod 3
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:45 <AnMaster> ehird, ?
00:28:49 <ehird> 3 and 43 are the only two primes in the first 1,000,000 primes that satisfy that :-)
00:28:51 <ehird> err
00:28:51 <ehird> ais523:
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:28:59 <ehird> Out[11]= {3, 43}
00:29:23 <nescience> i like it, i might steal that
00:29:24 <nescience> :P
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:29 <ehird> ais523: yep
00:29:41 <ehird> Meh.
00:29:44 <ehird> It doesn't do terribly, at leat.
00:29:46 <ehird> *least
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:03 <ehird> oops
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:25 <ehird> right
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 <nescience> but hadn't gotten around to it
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:46 <nescience> ha
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:01 <pikhq> HOORAY, SUICIDE
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:19 <nescience> at least it gets wins
00:31:19 <nescience> :P
00:31:35 <ehird> nescience: stop being a malcontent, it's only three versions
00:31:41 <leonid_> !bfjoust lols .
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:55 <leonid_> whoa
00:31:57 <nescience> (i was including ehird's)
00:31:58 <ais523> I'll delete tripwire_fool if you like
00:32:00 <ais523> as it's a failed strategy
00:32:00 <nescience> nah
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:21 <nescience> oshi
00:32:23 <nescience> look at the map now
00:32:24 <AnMaster> myndzi_slowrush still leads... hm
00:32:36 <nescience> ais is gaining on me!
00:32:48 <MizardX> !bfjoust mzx_fool >-[>-]
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:07 <ais523> just not overall
00:33:08 <ehird> hey not bad.
00:33:21 <nescience> quite
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:57 <ehird> hmph
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:34:59 <ais523> MizardX: 128 >s?
00:35:04 <ehird> ais523: where good program = high score
00:35:10 <ehird> ?
00:35:10 <ais523> the opponent would have to suicide very quickly to lose to that
00:35:12 <lament> !bfjoust what [-]
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:21 <lament> 7.3?
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:31 <leonid_> !bfjoust lols .
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:39 <ehird> for the full list
00:35:51 <ehird> lament: note that [-] goes [-]-]-]-]
00:35:51 <nescience> the scoring is like
00:35:55 <ais523> ehird: i_keelst_thou beat vibration_fool_faster...
00:35:55 <ehird> so (-)*128 is more effective
00:36:01 <ehird> ais523: :-D
00:36:05 <ais523> I wonder how?
00:36:05 <nescience> you get points equal to the wins(+ties?) of programs you beat
00:36:09 <lament> !bfjoust what (-)*128
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:40 <ais523> ehird: ah, aha
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:01 <lament> !bfjoust hello [+]
00:38:04 <EgoBot> Score for lament_hello: 7.8
00:38:23 <AnMaster> GregorR, "FYB"?
00:38:28 <AnMaster> isn't it JOUST ones
00:38:30 <ehird> FukYorBrane.
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:37 <AnMaster> ah
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:35 <ehird> AWESOME!
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:02 <leonid_> !bfjoust lols (->[+])*20
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:15 <ais523> yes
00:40:19 * ehird gets idea
00:40:23 <ehird> well, an old one
00:40:24 <ais523> just interesting that yours does very well, and mine did terribly
00:40:24 <ehird> but it might work
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:35 <ehird> for reference
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:06 <ehird> WOW
00:41:07 <ehird> 17.1?
00:41:09 <ehird> That's low.
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 <ais523> I think
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:50 <ehird> YAY
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:05 <ais523> decoys > no decoys
00:42:06 <EgoBot> Score for lament_what: 20.7
00:42:11 <ais523> even though everything has anti-decoy tricks nowadays
00:42:14 <leonid_> !bfjoust lols (-->[+])*20
00:42:17 <EgoBot> Score for leonid__lols: 10.8
00:42:23 <lament> decoys are slow to set up
00:42:26 <leonid_> !bfjoust lols (+>[+])*20
00:42:29 <EgoBot> Score for leonid__lols: 22.9
00:42:43 <ehird> lament: one cycle
00:42:45 <ehird> for me
00:42:45 <leonid_> !bfjoust lols (+>[+].)*20
00:42:47 <ehird> alternate + and -
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 <lament> oh
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:32 <ehird> heh
00:43:35 <lament> !bfjoust what >+[>[(-)*128]>+]
00:43:36 <ehird> I do badly w/ impomatics' programs
00:43:37 <ehird> I wonder why?
00:43:38 <EgoBot> Score for lament_what: 20.4
00:43:41 * lament confused
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:21 <lament> oh
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:48 <psygnisf_> guys, i made some butter. o.o
00:44:49 <ais523> ehird: well done
00:44:50 <leonid_> !bfjoust lols (+>[-])*20
00:44:51 <psygnisf_> from scratch.
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:23 <AnMaster> good enough for me
00:45:24 <AnMaster> now*
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:36 <leonid_> !bfjoust lols (+>[-])*30
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:43 <leonid_> !bfjoust lols (+>[+])*30
00:45:46 <EgoBot> Score for leonid__lols: 12.5
00:45:49 <leonid_> !bfjoust lols (->[+])*30
00:45:49 <ehird> ouch
00:45:50 * ehird reverts
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:04 <AnMaster> lament, it doesn't
00:46:07 <ais523> lament: tricking them off the end of the tape
00:46:11 <AnMaster> lament, it is a pure defender
00:46:18 <leonid_> !bfjoust lols (>)*9(->[+])*19
00:46:19 <lament> ohh
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:35 <ehird> which is nice
00:46:38 <AnMaster> !bfjoust no_decoy -
00:46:39 <leonid_> !bfjoust lols (>)*9(->[-])*19
00:46:41 <EgoBot> Score for AnMaster_no_decoy: 20.4
00:46:41 <ehird> aaaaaaaaaaaa
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:47 <AnMaster> nice
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 <AnMaster> !bfjoust no_decoy +
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:04 <AnMaster> !bfjoust no_decoy .
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:08 <AnMaster> !bfjoust no_decoy >
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:12 <leonid_> whoa
00:47:12 <AnMaster> !bfjoust no_decoy -
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:49 <ehird> ais523: yeah
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:52 <psygnisfive> :|
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:47:58 <ehird> mail it to uk
00:48:03 <psygnisfive> right on it!
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:13 <ehird> whoa
00:49:14 <ehird> >60!
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:28 <ais523> lament: no
00:49:29 <ehird> !bfjoust i_keelst_thou (>+>-)*4>((-)*128[---]+>(-)*128[+++]->)*21
00:49:29 <leonid_> 50 o_O
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:49:53 <ehird> No draws.
00:49:54 <ehird> WTF?
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:26 <ehird> 8 losses, 11 wins
00:50:27 <ais523> but that made decoys an overwhelmingly good strategy
00:50:28 <ehird> i'm doing okay
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:09 <leonid_> no draws
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:24 <ehird> :)
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:45 <ais523> *does
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:40 <ais523> the traditional way
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:01 <ehird> OH
00:54:02 <ehird> I have an idea!
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:17 <ehird> WTF
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:47 <AnMaster> ais523, famers?
00:54:49 <lament> !bfjoust dangle (-)*127[[+]+]
00:54:50 <ehird> ais523: ah
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:58 <ais523> like vff
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 <ais523> yes
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:32 <leonid_> whoa
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:23 <ehird> wtfff
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:38 <ehird> WTF
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:03 <ehird> ais523: yep
00:57:06 <EgoBot> Score for ehird_i_keelst_thou: 54.3
00:57:06 <EgoBot> Score for leonid__lols: 58.1
00:57:09 <leonid_> whoa
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 <ehird> this one got ~60
00:57:27 <EgoBot> Score for ehird_i_keelst_thou: 55.0
00:57:28 <EgoBot> Score for leonid__lols: 36.5
00:57:31 <ehird> meh
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 <lament> !bfjoust dangle <
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:12 <ehird> ais523: eh?
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:01 <ehird> ais523: whatttt
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:45 <ehird> darn
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:52 <leonid_> i went back
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:09 <ehird> decoys
01:00:10 <leonid_> i have no idea how my own code works
01:00:12 <leonid_> dumb
01:00:15 <leonid_> :(
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:06 <leonid_> 60
01:01:07 <ehird> !bfjoust i_keelst_thou (>+>->>)*2>((-)*128[-]+>(-)*128[+]->)*21
01:01:08 <leonid_> lol
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 <leonid_> ;(
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:50 <ehird> ais523: haha
01:01:51 <EgoBot> Score for leonid__lols: 43.4
01:01:56 <AnMaster> ais523, um why
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 <AnMaster> ah
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:19 <ehird> LOL
01:02:26 <ehird> ais523: going one over the tape length sometimes improves me score.
01:02:28 <ehird> *my 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:41 <ehird> ais523: i know
01:03:42 <ais523> because you have two >s in the repeated bit
01:03:43 <ehird> what the _fuck_
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:57 <ehird> ais523: o rly?
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:00 <AnMaster> night
01:05:02 <EgoBot> Score for leonid__lols: 60.0
01:05:10 <leonid_> duh
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:29 <leonid_> how about making #bfjoust
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:05:55 <ehird> so why not joust?
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:25 <AnMaster> ais523, I'm in there!
01:06:26 <EgoBot> Score for leonid__lols: 39.0
01:06:27 <EgoBot> Score for ais523_anti_counterdefence_glue: 9.8
01:06:29 <AnMaster> ais523, waiting for you
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:44 <ehird> Pleases me.
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:03 <leonid_> nah
01:08:07 <leonid_> ?_?
01:08:26 <pikhq> !bfjoust defense! [[.]+]
01:08:29 <EgoBot> Score for pikhq_defense_: 13.1
01:08:47 <pikhq> !bfjoust defense! [+[.]+]
01:08:48 <pikhq> ?
01:08:50 <EgoBot> Score for pikhq_defense_: 12.8
01:08:55 <pikhq> Definitely not.
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:40 <leonid_> random tape lol
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:27 <ais523> heh
01:10:29 <ais523> I'll pastebin it
01:10:31 <pikhq> ais523: FAIL
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:39 <leonid_> :(
01:12:40 <EgoBot> Score for leonid__lols: 59.5
01:12:52 <lament> whoa
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:30 <leonid_> ....
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:15 <leonid_> okay
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:26 <leonid_> it sucks now
01:14:31 <leonid_> !bfjoust lols -(>)*9(+++>[-[+-+]])*20
01:14:32 <leonid_> oh yeah
01:14:34 <EgoBot> Score for leonid__lols: 59.5
01:14:36 <leonid_> kk
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:24 <leonid_> they tie
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:16:32 <GregorR-L> You're doin' well :P
01:16:48 <leonid_> not really :/
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:36 <leonid_> nah
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:18:47 <GregorR-L> No one can defeat slowrush.
01:18:50 <GregorR-L> Muahahaha etc.
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:22:38 <leonid_> yeah that'd be fun
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:23:56 <ais523> yes, I know
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:05 <nescience> ya
01:24:05 <GregorR-L> Actually, just report.c
01:24:12 <ais523> hi coppro
01:24:13 <GregorR-L> Err, and egojoust.c
01:24:19 <GregorR-L> The point is, not the bot itself, just stuff it runs.
01:24:24 <nescience> oh?
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:39 <coppro> hi
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:24:51 <ais523> it doesn't seem to be
01:24:53 <GregorR-L> ais523: Yes.
01:25:01 <GregorR-L> ais523: It's there.
01:25:18 <nescience> ais523: what commanad are you typing? i just get an error :\
01:25:32 <ais523> nescience: "hg update"
01:25:43 <GregorR-L> hg pull && hg up
01:25:44 <nescience> lol
01:25:46 <nescience> guess that doesn't help me
01:25:53 <ais523> ooh, I forgot to pull...
01:25:59 <nescience> what's the correct url
01:26:08 <ais523> !info
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:23 <nescience> https
01:26:35 <nescience> i wonder if that makes a difference?
01:26:36 <GregorR-L> ... yes. And?
01:26:38 <GregorR-L> Oh
01:26:39 <nescience> i was using http
01:26:42 <GregorR-L> You can do either.
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:01 <leonid_> :3
01:27:13 <nescience> nope
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:25 <leonid_> lmfao lols is rank 2 now
01:27:26 <nescience> ah
01:27:40 <GregorR-L> http://codu.org/eso/bfjoust/in_egobot/ you mean?
01:27:42 <GregorR-L> That should work.
01:27:47 <GregorR-L> That E_WORKSFORME
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 <myndzi> :\
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:28:57 <leonid_> what the fuck am i doing
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:21 <GregorR-L> Anyway, I've gtg.
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:26 <myndzi> ok, thanks
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:30:42 <leonid_> ?_?
01:31:09 <leonid_> !bfjoust lols2 +(><><<>><>)*8(+++>[-[+-+]])*20
01:31:12 <EgoBot> Score for leonid__lols2: 0.0
01:31:17 <leonid_> now what
01:31:33 <leonid_> !bfjoust lols2 +(><><<>>)*8(+++>[-[+-+]])*20
01:31:35 <EgoBot> Score for leonid__lols2: 0.0
01:31:44 <leonid_> oh nvm
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:39 <coppro> it's going well
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:33:45 <leonid_> interesting
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:20 <leonid_> whoa
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:57 <leonid_> oh
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:41 <leonid_> lol i'm lost
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:47 <leonid_> ah yeah
01:37:48 <nescience> just so, y'know, people can see what they are saying in here
01:37:50 <nescience> :)
01:37:59 <leonid_> i'll do that
01:38:23 <leonid_> sorry for spamming
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:45 <nescience> damn
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:13 <myndzi> lol
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:50:32 <myndzi> er, ubuntu, whatever
01:51:17 -!- inurinternet has joined.
01:54:52 <leonid_> lmfao lols2 got rank 2
01:55:39 <leonid_> whoa
01:55:42 <leonid_> it beats slowrush
01:55:52 <leonid_> *dances*
02:00:17 <myndzi> o_O
02:00:42 <nescience> BUT I AM INVINCIBLE
02:01:08 <leonid_> mmmm
02:01:22 <ais523> hmm... I reckon attack1 would beat lols2
02:01:22 <leonid_> nope
02:01:24 <ais523> let's find out
02:01:31 <leonid_> i beat yours too nescience
02:01:40 * myndzi = nescience
02:01:44 <leonid_> oh
02:01:46 <leonid_> nvm
02:01:50 <ais523> !bfjoust attack1 [>[-]+]
02:01:53 <EgoBot> Score for ais523_attack1: 18.9
02:02:06 <leonid_> damn
02:02:10 <ais523> yep, it might be last
02:02:14 <ais523> but it beats lols2
02:02:18 <leonid_> yes
02:02:22 <leonid_> >_>
02:02:27 <ais523> and lols, and maglev
02:02:30 <ais523> but nothing else
02:03:01 <leonid_> making several attack1 clone will pull lols down
02:03:07 <leonid_> don't do it
02:03:15 <ais523> I'm not going to
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:39 <myndzi> hg
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:18:30 <nescience> finally figured it out
02:18:33 <nescience> ha, doesn't do so hot anymore
02:18:36 <nescience> that's what i was curious about
02:21:33 <ais523> wow, ehird_i_keelst_thou.bfjoust is down to halfway already
02:21:52 <pikhq> !bfjoust lawlz .
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:31 <ais523> ah, yes
02:22:38 <ais523> nescience_shade assumes the opponent sets up at least one decoy
02:22:42 <ais523> whereas lawlz doesn't
02:22:51 <leonid_> lawlz
02:26:20 <leonid_> yawn
02:31:36 <leonid_> lawlz3 gets rank 2
02:31:43 <leonid_> hahaha
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:36:33 <ais523> that's more like it
02:36:42 <leonid_> ****
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:38:52 <ais523> I was just curious
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:20 <ais523> ah, of course
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:35 <ais523> that's better
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:39 <myndzi> take that vibration
02:56:44 <myndzi> it's such a good vibration
02:56:52 <myndzi> but now i lose to speedy, must be timing
02:56:54 * myndzi speeds it up a little
02:57:02 <ais523> myndzi: you boosted slowrush?
02:57:08 <myndzi> ya
02:57:10 <myndzi> still tweaking though
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:57:45 <myndzi> :)
02:57:57 <leonid_> :o
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:39 <myndzi> bingo
02:58:42 <leonid_> my lawlz still beats slowrush
02:58:47 <myndzi> 2 ties
02:58:48 <myndzi> all wins
02:58:54 <ais523> beh, slowrush still somehow beats it anyway
02:59:00 <leonid_> nevermind
02:59:01 <myndzi> wonder why it ties to viper
02:59:14 <leonid_> aarrrgrgh
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:54 <myndzi> specifically,
02:59:58 <myndzi> if i execute "-" and you don't die
03:00:01 <myndzi> i know your timing
03:00:07 <myndzi> and then i wait a beat and counteract it so you do
03:00:21 <myndzi> -.+
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:22 <ais523> gah, why is 109 prime
03:01:23 <myndzi> oh, nevermind
03:01:36 <ais523> your use of 19 for the decoys in slowrush is really clever
03:01:39 <ais523> maybe I'll steal it
03:01:54 <ais523> although, idea
03:01:56 <myndzi> :P
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:08 <myndzi> it was 20
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:24 <myndzi> :)
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:02:52 <myndzi> 93 points!
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:38 <myndzi> less good
03:03:44 <ais523> !bfjoust speedy2 >>>>>>>>>([-[++[---]]]>)*21
03:03:47 <EgoBot> Score for ais523_speedy2: 38.4
03:04:13 <myndzi> damn
03:04:17 <myndzi> that resubmission cost me a win
03:04:54 <leonid_> woot
03:05:07 <leonid_> ;o
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:28 <ais523> !bfjoust speedy2 <
03:06:31 <EgoBot> Score for ais523_speedy2: 0.0
03:06:54 <leonid_> $!@$!# !@$@#$
03:08:44 <ais523> !bfjoust monovibration (+)*5000(-[+[+[---]]]>)*21
03:08:47 <EgoBot> Score for ais523_monovibration: 5.5
03:08:54 <ais523> heh, that did badly
03:08:58 <ais523> oops
03:09:01 <ais523> !bfjoust monovibration (+)*5000>(-[+[+[---]]]>)*21
03:09:06 <EgoBot> Score for ais523_monovibration: 28.3
03:09:28 <leonid_> whoa 74.1
03:09:30 <leonid_> *dances*
03:10:20 <coppro> what's the timeout
03:10:34 <ais523> 100000
03:10:37 <coppro> hmm
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:27 <myndzi> sweet
03:11:33 <myndzi> !bfjoust test <
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:11:59 <myndzi> son of a
03:12:01 <ais523> myndzi: wow
03:12:05 <ais523> you even beat slowrush
03:12:05 <myndzi> lol it beats slowrush
03:12:20 <coppro> question
03:12:24 <myndzi> i guess i'm just good? ;p
03:12:27 <myndzi> lucky 19s
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:12:57 <coppro> how?
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:13:52 <coppro> ah
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:23 <ais523> ah, that's better
03:16:31 <ais523> 2 decoys seems to be the standard amount
03:16:51 <ais523> and it beats both slowrush and 3pass
03:16:56 <myndzi> owat
03:17:08 <myndzi> that's mean :(
03:17:13 <myndzi> hehe
03:17:25 <ais523> I can't remember whose idea guessing that the first value is a decoy was
03:17:30 <myndzi> <-
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:17:46 <myndzi> ha
03:18:07 <myndzi> problem is you can go back and forth all day tweaking and countertweaking that
03:18:13 <ais523> yes
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:18:27 <myndzi> not necessarily
03:18:33 <myndzi> let's try something
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:02 <myndzi> crap
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:16 <myndzi> o_O
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:27 <leonid_> omg how the fuck
03:21:40 <leonid_> i will have to really think from now on
03:21:48 <myndzi> oh
03:21:50 <myndzi> ugh
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:15 <ais523> yes
03:28:20 <ais523> well, maybe not
03:28:23 <myndzi> where's ehird with his exhaustive search interpreter
03:28:26 <myndzi> well i mean
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:37 <myndzi> dunno
03:28:43 <myndzi> that's just the reason for the point boost is all
03:28:48 <ais523> yes, I know
03:29:51 <leonid_> lawlz beat slowrush and 3pass
03:29:56 <leonid_> *dances*
03:30:06 <myndzi> !bfjoust keke2 ->>>>>>>>>(-.+(+)*128(-)*128(+.)*256(-.)*256(++.)*256(--.)*256>)*20
03:30:09 <EgoBot> Score for myndzi_keke2: 34.3
03:30:15 <myndzi> hehe
03:30:30 <leonid_> mmmm
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:31:39 <myndzi> huh
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:45 <leonid_> noooo
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 <leonid_> 79.71 vs 79.50
03:33:01 <myndzi> sorry for including vibration killers in everything
03:33:02 <leonid_> x_x
03:33:02 <myndzi> :P
03:33:15 <leonid_> lawlz
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:34:18 <leonid_> ugh
03:34:19 <leonid_> nooooo
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:50 <ais523> yes if in raw format
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:02 <coppro> ok
03:38:39 <coppro> how do I get to it?
03:38:47 <ais523> click on the raw link over the left
03:38:51 <ais523> after you've pasted your program
03:39:04 <coppro> there we go
03:39:08 <coppro> !bfjoust awful http://pastebin.ca/raw/1438923
03:39:11 <EgoBot> Score for coppro_awful: 0.0
03:39:14 <coppro> rofl
03:39:18 <ais523> coppro: there's probably a syntax error
03:39:26 <myndzi> oshi
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:52 <ais523> >(+)%128
03:39:55 <ais523> it's on the first line...
03:40:00 <ais523> that should be (+)*128
03:40:07 <coppro> oh yeah
03:40:10 <leonid_> what the
03:40:11 <leonid_> fock
03:40:12 <coppro> why use both symbols?
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:03 <coppro> yarg stupid c/p
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:34 <ais523> we've been found out
03:41:35 <coppro> hmm
03:41:35 <ais523> <(+)%128
03:41:38 <coppro> the parens balance, I know that
03:41:54 <coppro> oh darn
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:37 <coppro> there we go
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:43:33 <myndzi> :>
03:44:12 <leonid_> aaargh can't beat this
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:37 <myndzi> ack
03:51:40 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(-)*128(-.)*256(--.)*256>)*20])*20
03:51:43 <EgoBot> Score for myndzi_keke2: 34.6
03:51:46 <myndzi> huh
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:56:43 <Gracenotes> CRITICAL SUCCESS
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
03:59:55 <coppro> ok
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:20 <leonid_> i know
04:07:27 <leonid_> i'm trying to get some luck
04:07:28 <myndzi> just checkin ;p
04:08:01 <leonid_> luck-based code FTW
04:19:59 <leonid_> ....
04:21:37 -!- oerjan has joined.
04:47:09 -!- oerjan has quit ("leaving").
04:55:36 <leonid_> ugh
04:57:10 <myndzi> wtfwtf
04:57:11 <myndzi> lol
04:57:24 <myndzi> i accidentally pasted slowrush on the end of 3pass and it improved its score
04:57:25 <leonid_> no 100%
04:57:33 <leonid_> :(
04:57:40 <myndzi> even though it should have gone off the end
04:58:28 <myndzi> ah
04:58:32 <myndzi> i had my number wrong
05:01:40 <leonid_> :(
05:03:27 <myndzi> laffo
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:06 <myndzi> do tell
05:09:08 <ais523> it seems that the random-number generator is seeded with hashes of the programs
05:09:15 <leonid_> yes
05:09:16 <myndzi> LOL
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:33 <myndzi> :\
05:09:37 <myndzi> what happened to randomize timer
05:09:42 <leonid_> :/
05:09:49 <leonid_> i'm not idiot
05:09:50 <myndzi> (lol basic)
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:15 <myndzi> heh
05:14:17 <leonid_> prevent me from*
05:14:21 <myndzi> he can't fix it, it's GregorR-L's bot
05:14:27 <leonid_> hmmm
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:14:45 <leonid_> i know
05:14:47 <leonid_> :p
05:14:52 <leonid_> i win some i lose some
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:18 <leonid_> this junk gets me rank 2
05:15:19 <leonid_> .....,,,,,(>(-)*18)*9([(-)*22[+]]>)*18
05:15:24 <myndzi> heh
05:15:32 <leonid_> :)
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:16:06 <myndzi> ;)
05:16:39 <leonid_> yeah
05:16:47 <leonid_> well
05:16:52 <leonid_> i'm bfjoust n00b
05:16:54 <leonid_> need to study more
05:16:56 <leonid_> dam
05:26:10 <leonid_> damn what am I doing
05:26:28 -!- leonid_ has quit ("Leaving").
05:26:51 -!- leonid_ has joined.
05:28:46 -!- Patashu has joined.
05:29:11 <leonid_> hey
05:29:23 <Patashu> yo
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:29:56 <Patashu> cycling :)
05:31:26 <myndzi> which does you no good as we have learned :P
05:31:37 <Patashu> who is this 'we'
05:31:41 <myndzi> oh
05:31:43 <myndzi> you just joined
05:31:48 <Patashu> yup
05:31:53 <myndzi> apparently the RNG is based on hashed program contents
05:32:00 <Patashu> I know that
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:39 <Patashu> basically
05:32:43 <myndzi> pft :P
05:32:53 <myndzi> how about the cycle of write a program that doesn't get pushed off as easy ;)
05:32:59 <Patashu> that's step 2
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:11 <Patashu> yeah? do tell
05:33:15 <leonid_> patashu
05:33:18 <Patashu> yo
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:35 <Patashu> aa
05:33:40 <leonid_> lead to a serious problem
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:14 <leonid_> no fun
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:34:37 <myndzi> pretty much
05:34:50 <leonid_> yes
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:03 <leonid_> blinding adds ','s
05:35:14 <leonid_> blindly adding ','s*
05:35:15 <leonid_> omg
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:51 <Patashu> nope
05:38:52 <Patashu> hmm
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:52 <Patashu> gonna choke a bitch
05:39:56 <Patashu> !bfjoust lolscounter (>++)*8(>(+)*17[+[-]])*21(+)*1024(-)*1024(+-)*1024(-+)*1024
05:39:59 <EgoBot> Score for Patashu_lolscounter: 42.1
05:40:55 <Patashu> it beats lols anyway
05:41:06 <Patashu> and lols3
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:24 <Patashu> oh I see
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:35 <Patashu> hmm
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:32 <Patashu> :o
05:47:34 <Patashu> jackpot
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:52 <myndzi> heh
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:04 <Patashu> uh oh
05:48:04 <Patashu> lol
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:13 <Patashu> it's calculating it still
05:48:19 <Patashu> so I wanted to ask
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:48:37 <leonid_> look
05:48:40 <leonid_> it has no point
05:48:54 <psygnisfive> christ wtf are you guys doing
05:49:05 <leonid_> fucking with hashvalues
05:49:14 <Patashu> leonid is anyway
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:24 <leonid_> rule out mine
05:49:26 <leonid_> mine is a cheat
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:45 <leonid_> not
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:49:58 <psygnisfive> patashu: *retardedness
05:50:01 <leonid_> you spelled comprehend wrong
05:50:03 <Patashu> :B
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:27 <myndzi> heh
05:50:29 <psygnisfive> thought experiments are fun
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:49 <Patashu> woa
05:50:51 <psygnisfive> or THOUGHT LASERS
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:44 <myndzi> :P
05:51:49 <Patashu> that would be even worse
05:51:50 <Patashu> lol
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:16 <Patashu> uh no
05:52:17 <myndzi> fixed tape size has a fixed solution
05:52:19 <Patashu> yes
05:52:19 <Patashu> thart
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:14 <leonid_> ...
05:54:22 <myndzi> it won't*
05:54:24 <myndzi> meh
05:54:28 <myndzi> you know what i mean, right!?
05:54:32 <Patashu> yup
05:54:33 <leonid_> yea
05:54:37 <myndzi> good!
05:54:44 <ais523> Patashu: what are you doing to beat defend9 so much?
05:54:53 <Patashu> defend9 sucks? :)
05:54:54 <Patashu> I dunno
05:54:58 <Patashu> look at my programs
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:55:52 <myndzi> ;)
05:56:11 <leonid_> okay i'm going to rewrite my code from scratch without relying on hash values
05:56:21 <leonid_> DUN
05:56:22 <ais523> haha
05:56:22 <leonid_> fail
05:56:29 <ais523> patashu_lazy never hits my tripwire
05:56:44 <ais523> that's easily fixable
05:56:45 <Patashu> (-.)*128
05:56:54 <Patashu> oh wait
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:23 <Patashu> nope rushpolarity loops
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:50 <myndzi> etc.
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> just to check
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:52 <Patashu> hmm
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 <myndzi> forensics!
05:59:12 <EgoBot> Score for Patashu_juggernaut: 28.6
05:59:21 <Patashu> huh hang on, so...
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:27 <Patashu> there
05:59:29 <Patashu> ok
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 :)
05:59:51 <Patashu> heh
05:59:54 <myndzi> that's pretty neat
06:00:03 <Patashu> haha
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:15 <Patashu> :)
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:01:57 <bsmntbombdood> wtf is this bf shorthand i'm seeing
06:02:02 <bsmntbombdood> unaseptable
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:15 <Patashu> or w/e
06:02:17 <ais523> defend9 is autogenerated from a perl script, btw
06:02:21 <Patashu> aah
06:02:24 <myndzi> i'm not surprised
06:02:29 <Patashu> no I'm not either
06:02:29 <myndzi> i'd have done the same
06:02:29 <Patashu> lol
06:02:38 <Patashu> I don't know any perl :(
06:02:42 <Patashu> only know visual basic and jav
06:02:43 <Patashu> +a
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:32 <Patashu> psygnis: ORK?
06:08:33 <myndzi> your tripwire sits on the +20 right?
06:08:36 <Patashu> oh wait
06:08:44 <Patashu> languages...
06:12:21 <leonid_> !bfjoust lols <
06:12:23 <leonid_> !bfjoust lols2 <
06:12:23 <EgoBot> Score for leonid__lols: 0.0
06:12:25 <leonid_> !bfjoust lols3 <
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:38 <leonid_> maybe later
06:12:59 <leonid_> i lost interest at all after realizing all my work was a cheat
06:13:06 <myndzi> admirable
06:13:12 <Patashu> should be fixed soon
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:43 <myndzi> (now i know why)
06:13:45 <Patashu> and...
06:13:45 <Patashu> !bfjoust electrictrain (>(+)*10)*4(>(-)*10)*5([-][-][+][+]>)*20
06:13:48 <myndzi> lol
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:13:59 <myndzi> ;)
06:14:22 <leonid_> !bfjoust lols t(-_-t)....(>'-')>....\(+_+)/(>_>)
06:14:25 <EgoBot> Score for leonid__lols: 0.0
06:14:41 <Patashu> haha
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:02 <Patashu> so < beats opfdkgpofkhf
06:15:08 <leonid_> !bfjoust lols t[-_-t]-....[>'-']>....\[+_+]/[>_>]
06:15:10 <EgoBot> Score for leonid__lols: 11.2
06:15:13 <leonid_> good
06:15:14 <myndzi> that sounds backwards
06:15:19 <myndzi> < parses
06:15:28 <myndzi> so that'd suicide on the 1st turn?
06:15:32 <myndzi> oh wait.. "beats"
06:15:37 <myndzi> ....heh :(
06:15:40 <Patashu> oh waiyt
06:15:41 * myndzi switches polarity
06:15:43 <myndzi> I GET IT
06:15:43 <Patashu> so random symbols are fine
06:15:47 <leonid_> yeah
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:16:20 <leonid_> oh
06:18:46 <psygnisfive> what the hell is this game?
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:20 <Patashu> busy beaver problem?
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:44 <psygnisfive> by a turing machine.
06:19:44 <psygnisfive> yes.
06:19:45 <Patashu> it's not in the general sense
06:20:06 <leonid_> oh well nvm
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:31 <Patashu> simple, definitely
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:20:58 <pikhq> whoppix: ,[,.]
06:21:00 <pikhq> whoppix: Good luck.
06:21:39 <whoppix> pikhq, yeah, I know, input/output blows the whole thing up :)
06:21:54 <Patashu> nah
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:20 <psygnisfive> basically.
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:01 <pikhq> ;)
06:23:03 <EgoBot> Score for ais523_defend9: 58.9
06:23:26 <ais523> I decided to improve the detection
06:23:30 * leonid_ opens the link
06:23:32 <leonid_> WTH
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:48 <Patashu> it's generated in perl
06:23:54 <Patashu> patashu_lazy is the laziest program
06:23:55 <Patashu> :)
06:24:01 <psygnisfive> pikhq: thats because all non-TMs halt :P
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:15 <Patashu> hah
06:24:18 <psygnisfive> you dont need recurring state at all
06:24:24 <Patashu> a change too small
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:44 <Patashu> I did
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:24:57 <psygnisfive> pikhq: i didnt say TC, i said TM. :P
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:26:49 <whoppix> made me lol.
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:11 <Patashu> oops lol
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:32 * Patashu lols at the link
06:28:54 <leonid_> !bfjoust lols http://pastebin.ca/raw/1439069
06:28:56 <EgoBot> Score for leonid__lols: 0.0
06:28:59 <leonid_> :/
06:29:03 <Patashu> haha
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:36 <Patashu> hey question
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:11 <psygnisfive> pikhq: doesnt matter
06:30:22 <psygnisfive> actually, yes it does matter
06:30:22 <psygnisfive> sorry
06:30:35 <psygnisfive> anything that doesnt halt /is/ a turing machine, just not a UNIVERSAL turing machine.
06:30:48 <pikhq> Ah.
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:07 <Patashu> ooh
06:31:10 <Patashu> aha :)
06:31:11 <Patashu> it has a purpose
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:36 <leonid_> i quit :/
06:31:38 <EgoBot> Score for leonid__lol: 18.4
06:31:50 <Patashu> lol
06:31:54 <Patashu> just wait until tomorrow
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 <ais523> ah, aha
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:32:26 <psygnisfive> or can.
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:11 <psygnisfive> so i guess you dont need a TM at all.
06:33:12 <ais523> like defend6
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:48 <ais523> yes
06:33:49 <leonid_> is vibration a good strategy?
06:33:55 <ais523> leonid_: I'm not sure
06:34:03 <leonid_> if so, where's dossar when we need him
06:34:04 <leonid_> nvm
06:34:06 <ais523> I think it might be
06:34:09 <Patashu> wrong community
06:34:09 <Patashu> lol
06:34:26 <leonid_> dam
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:34:58 * leonid_ is bf n00b
06:35:09 <ais523> leonid_ alternately increases and tests for zero
06:35:15 <ais523> well, no
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:38 <ais523> it's a neat strategy
06:36:41 <leonid_> will there be a bf code that wins every code?
06:36:48 <Patashu> nope lol
06:36:51 <leonid_> except itself
06:37:07 <ais523> leonid_: I suspect any program could be beaten by another program specifically designed to beat it
06:37:27 <leonid_> hmm
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:06 <leonid_> beatrank1_1
06:38:07 <ais523> each of the spam programs would be eliminated
06:38:07 <leonid_> beatrank1_2
06:38:09 <leonid_> beatrank1_3
06:38:09 <leonid_> etc
06:38:15 <ais523> unless they were good enough to beat some of the other programs already there
06:38:16 <Patashu> everything else beats it
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:38:43 <leonid_> so that he would go up
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:45 <Patashu> but not a cincher
06:39:47 <ais523> hi oerjan
06:39:52 <Patashu> the program has to be legitimately good for the most part
06:39:52 <oerjan> hi ais523
06:40:00 <ais523> I've been jousting all night
06:40:02 <oerjan> seen my Eodermdrome program?
06:40:05 <ais523> and no, I haven't
06:40:11 <ais523> interp, or program written in Eodermdrome?
06:40:16 <ais523> the world is sadly lacking in either
06:40:17 <oerjan> written in
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:40:55 <oerjan> yes
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:31 <oerjan> heh :D
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:10 <Patashu> woah O_O
06:43:11 <Patashu> !bfjoust rushpolarity >((+)*20>(-)*20>(-)*20>(+)*20)*2>((+)*10[+[-]](+)*20>(-)*10[-[+]](-)*20>)*11
06:43:14 <Patashu> check this out
06:43:15 <EgoBot> Score for Patashu_rushpolarity: 68.4
06:43:18 <Patashu> woo
06:43:23 <Patashu> OORAH GO SWANS
06:43:44 <ais523> oerjan: I like the way you tried to make your words pronouncable
06:44:32 <oerjan> yeah :D
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:49 <oerjan> )
06:45:57 <ais523> A much bigger challenge would be to write an eodermdrome BCT interp which was also valid English
06:46:04 <oerjan> indeed
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:46:13 <oerjan> ic
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:13 <Patashu> that's p. good
06:47:14 <Patashu> second place
06:47:20 <ais523> oerjan: 23 /different/ characters?
06:47:22 <oerjan> yep
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:33 <Patashu> might be an interp bug
06:52:39 <Patashu> what about [.[-]] ?
06:52:43 <myndzi> i was thinking possibly so
06:52:45 <myndzi> i don't know
06:52:45 <Patashu> or [X[-]]
06:52:47 <Patashu> try :)
06:53:28 <Patashu> where X is a literal X
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:11 <myndzi> it'd be hand to tell
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:21 <Patashu> here's a question
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:44 <Patashu> oh yeah
06:57:46 <Patashu> I see
06:57:54 <Patashu> you get 1 turn reaction
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:58:53 <Patashu> one of those was in fyb
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:05 * myndzi shrugs
07:00:27 <Patashu> technically bfjoust is turing complete...err, bounded state machine :)
07:00:27 <leonid_> hmmmmm
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:20 <Patashu> leonid
07:01:25 <Patashu> have you ever looked at the brainfuck algorithms page?
07:01:26 <leonid_> what
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:49 <leonid_> bf algo page?
07:01:52 <Patashu> so simple and unwieldly-looking but turing complete
07:01:53 <Patashu> yeah sec
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:30 <leonid_> cool
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:23 <myndzi> :P
07:03:35 <myndzi> let's also add LT and GT!
07:03:42 <Patashu> augh...literals
07:03:43 <myndzi> and SUB!
07:03:44 <Patashu> in my brainfuck
07:03:46 <myndzi> wait, how about DIV
07:03:47 <myndzi> :D
07:03:51 <myndzi> sit on their flag and div by 2
07:03:59 <Patashu> yeah was going to say
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:22 <Patashu> oh phew
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:30 <Patashu> well later on
07:05:33 <Patashu> we could experiment
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:31 <myndzi> or how you can lose
07:06:34 <myndzi> that sort of thing
07:06:36 <Patashu> how you can lose maybe
07:06:41 <Patashu> I think it would be interesting to make suicide NOT a loss
07:06:43 <Patashu> but just noping forever
07:06:48 <myndzi> for example, making it wrap around..
07:06:52 <Patashu> haha
07:06:53 <myndzi> would affect things weirdly
07:06:53 <Patashu> :o
07:06:58 <Patashu> yes that too
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:09 <Patashu> that's three alternatives
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:34 <myndzi> ;)
07:07:40 <myndzi> sorta
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:15 <Patashu> y'know?
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:29 <Patashu> ya
07:08:34 <myndzi> not in place of the existing bot
07:08:39 <myndzi> sorta like some of the corewars events
07:08:44 <Patashu> yea
07:08:45 <Patashu> ?
07:08:49 <Patashu> what do they do
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:10:15 <Patashu> yeah :)
07:10:16 <Patashu> haha
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:25 <Patashu> hmm
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:35 <leonid_> hmmm
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:25:58 <leonid_> uh a little better ?_?
07:26:09 <leonid_> !bfjoust ugh (+-)*900000(>[-[+]])*30
07:26:12 <Patashu> lol
07:26:12 <EgoBot> Score for leonid__ugh: 18.6
07:26:18 -!- nooga_ has joined.
07:26:22 <Patashu> try *40000
07:26:26 <leonid_> bfjoust ugh (+-)*9999999999999999999999999999999999999(>[-[+]])*30
07:26:44 <Patashu> lol
07:26:48 <leonid_> i think i'm addicted
07:27:05 <Patashu> gj it overflows a long long
07:27:16 * leonid_ didn't run it
07:27:21 <Patashu> oh
07:27:22 <Patashu> lol
07:27:23 <Patashu> :D
07:27:39 <Patashu> it ALMOST overflows a long long long
07:27:41 <Patashu> go for the trifecta
07:27:49 <leonid_> '?_?
07:27:59 <Patashu> 2^128
07:28:52 <leonid_> bfjoust ugh (+-)*`ruby -e'p 2**128'`(>[-[+]])*30
07:28:54 <leonid_> oh wait
07:29:01 <Patashu> would that work haha
07:29:02 <Patashu> I think it's in c
07:29:08 <leonid_> i know
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:20 <leonid_> oh nice
07:30:20 <Patashu> interesting
07:30:30 <leonid_> !bfjoust ugh ((>[-[+]])*25(<)*25)*10
07:30:34 <EgoBot> Score for leonid__ugh: 32.5
07:30:40 <leonid_> aah i'm using hash again
07:30:43 <Patashu> no
07:30:45 <Patashu> it's not the hash lol
07:30:50 <Patashu> that's an actual mechanical change
07:30:52 <Patashu> cheer up bro
07:30:53 <leonid_> no i mean
07:30:55 <leonid_> uh
07:31:04 <leonid_> um
07:31:05 <leonid_> nvm
07:31:08 <Patashu> :D
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:31:28 <leonid_> nah
07:31:50 <Patashu> why not just
07:31:58 <Patashu> (>[-[+]])*29
07:31:59 <Patashu> lol
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:40 <leonid_> !@#!$(@&$(
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:09 <leonid_> ;p
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:36:48 <leonid_> nice
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:12 <leonid_> cool
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:10 <leonid_> hmmm
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:39:51 <leonid_> hmmm
07:40:01 <Patashu> second place lol
07:40:02 <leonid_> k rank 2 again lol
07:40:09 <leonid_> argh
07:40:43 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*6(>[-[+]])*15(<[-[+]])*27)*10
07:40:44 <leonid_> ?_?
07:40:45 <EgoBot> Score for leonid__ugh: 39.6
07:40:51 <leonid_> nah constants
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:49:43 <Patashu> ode to bfjoust
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:23 <nooga_> fuck
07:54:35 <nooga_> Patashu: i've never seen you here?
07:54:41 <nooga_> i mean
07:54:53 <nooga_> excemp this day an yesterday
07:54:58 <nooga_> except*
07:55:06 <nooga_> and*
07:55:26 <Patashu> yup I recently migrated here
07:55:30 <nooga_> oh
07:55:48 <nooga_> i've been here (probably) from the begining
07:56:08 <leonid_> i moved from anagol
07:56:13 <nooga_> with a little gap
07:56:14 <Patashu> same
07:56:26 <nooga_> (2 years?)
07:56:46 <nooga_> where are you from? btw
07:56:50 <leonid_> !bfjoust ugh ((>(+)*19>(-)*19)*7(>[-[+]])*15(<)*29)*37
07:56:51 <Patashu> no
07:56:52 <EgoBot> Score for leonid__ugh: 72.3
07:56:54 <Patashu> (<leonid_> i moved from anagol) <-- same
07:56:55 <leonid_> i know that 37 is bs
07:57:06 <leonid_> omg i'm using hash again
07:57:08 <leonid_> aargarghargh
07:57:10 <nooga_> i mean the country :P
07:57:14 <Patashu> country
07:57:15 <leonid_> me korea
07:57:15 <Patashu> Australia
07:57:26 <Patashu> you know he's korean because he's good at rhythm games
07:57:27 <Patashu> but...wait...
07:57:30 <Patashu> I'm good at rhythm games too O_O
07:57:32 <leonid_> wrong community
07:57:37 <Patashu> it's still true
07:57:37 <leonid_> ;p
07:57:47 <leonid_> haha i'm rank 1
07:58:01 <leonid_> *dances*
07:58:16 <nooga_> hanguk :D
07:58:31 <leonid_> hancock
07:58:51 <nooga_> i've tried to learn that script
07:58:58 <leonid_> which script
07:59:12 <nooga_> hangul (hanguk?)
07:59:15 <leonid_> oh
07:59:20 <leonid_> learn it it's easy
07:59:31 <nooga_> quite strict
07:59:33 <leonid_> ./sarcasm
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:31 <nooga_> i'd rather use <sarcasm>.*</sarcasm>
08:00:46 <leonid_> ;p
08:00:48 <Patashu> xml
08:00:49 <Patashu> feisty
08:00:56 <nooga_> OS X
08:00:57 <nooga_> :D
08:00:58 <Patashu> def sarcasm()
08:01:02 <leonid_> exit
08:01:04 <leonid_> end
08:02:20 <nooga_> doh
08:02:26 <nooga_> amphetamine
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:02:52 <Patashu> that would be good
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:03:31 <myndzi> no
08:03:35 <myndzi> on this network?
08:03:47 <leonid_> anagol
08:03:49 <leonid_> more like
08:03:50 <leonid_> embedgol
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:06:22 <nooga_> uh'
08:06:26 <nooga_> new ppl :D
08:06:53 <nooga_> myndzi: deutsch?
08:22:28 <leonid_> brb nap
08:22:40 * leonid_ jumps into the bed
08:23:57 -!- oerjan has joined.
08:30:31 <nooga_> amphetamine
08:36:23 -!- lereah_ has joined.
08:41:54 <nooga_> ...
08:42:07 <oerjan> :::
08:42:29 <nooga_> oh, oerjan
08:43:19 <oerjan> ssh, i'm here incognito
08:43:52 <nooga_> did you sleep this night? ;p
08:44:11 <oerjan> yes, badly
08:44:23 <nooga_> congrats
08:44:31 <nooga_> i didn't
08:44:46 <oerjan> condolences
08:44:59 <oerjan> (condols?)
08:45:19 <nooga_> that's appropriate
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:46:53 * oerjan ducks
08:46:59 <nooga_> really?
08:47:26 <nooga_> l in Polish is like l in lame
08:47:42 <nooga_> we have ł
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:07 <nooga_> ? :O
08:49:26 <oerjan> olsner: shh, you
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:25 <ais523> how is milk involved?
08:50:34 <nooga_> i hate milk
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:41 <oerjan> well that.
08:50:45 <nooga_> it's unhealthy to drink milk, for adults
08:50:45 * myndzi sighs
08:50:46 <ais523> not quite the same as being allergic, but it's still unwise for me to drink too much
08:50:48 <oerjan> aayyyeeh!
08:50:54 <myndzi> leonid_: i thought you decided better than to f* around with the rng
08:50:54 <myndzi> :P
08:51:05 <oerjan> ais523: i started reacting to it a few years ago
08:51:14 <nooga_> kurwa mać
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:40 <nooga_> olsner: and you're?
08:51:44 <ais523> what does kurwa mean?
08:51:49 <nooga_> ummm
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:51:57 <nooga_> somethink like bitch
08:52:07 <nooga_> but it's used like fuck in english
08:52:12 <nooga_> hard to translate
08:52:18 <nooga_> *g
08:52:24 <myndzi> you mean fuck as in fornication? :P
08:52:30 <Patashu> force?
08:52:35 <myndzi> or fuck as an exclamation
08:52:41 <nooga_> hehehe
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:10 <nooga_> complex
08:53:28 <nooga_> you can create new oneswhen you need
08:53:35 <myndzi> sweet
08:53:37 <myndzi> every language needs that
08:53:38 <myndzi> :)
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:50 <myndzi> oh yes
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:29 <oerjan> i think
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:55:48 <nooga_> przyjebać, also
08:55:50 <myndzi> wyjebać jebać!
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:41 <nooga_> etc.
08:56:44 <myndzi> how do you even pronounce "prze"?
08:56:49 <nooga_> hmmm
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:54 <nooga_> gimme a sec
08:56:55 <myndzi> well, that's a silly question
08:57:01 <olsner> (meaning prostitute)
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:17 <oerjan> curvus <- PIE (s)ker
08:57:26 <myndzi> hm
08:57:31 <nooga_> words mutate in Polish
08:57:41 <myndzi> interesting at least
08:57:55 <oerjan> nooga_: words mutate everywhere
08:57:57 <nooga_> ptcheyebane
08:58:01 <oerjan> just not in the same way
08:58:05 <nooga_> oh
08:58:07 <nooga_> no
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:37 <nooga_> ewll
08:58:43 <nooga_> well*
08:58:54 <myndzi> since 'p' and 't' are both plosives(?), you can't do them at the same time
08:59:03 <myndzi> heck, 'ch' is too
08:59:04 <myndzi> :\
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:24 <myndzi> hehe
08:59:32 <myndzi> yeah, i bet
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:01 <oerjan> \o/ \o|
09:00:02 <myndzi> | |
09:00:02 <myndzi> |\ /<
09:00:15 <oerjan> myndzi: it wasn't silent in greek
09:00:33 <myndzi> \o_,- _,-o/ en garde!
09:00:33 <myndzi> | |
09:00:33 <myndzi> /´\ /<
09:00:43 <olsner> woot, irc-fencing
09:00:48 <myndzi> :D
09:01:03 <olsner> almost as exciting as irc-pong
09:01:20 <lereah_> Or that IRC interactive adventure we did :D
09:01:41 <ais523> heh, I remember that
09:01:47 <oerjan> *the original greek
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:02:59 <myndzi> haha oh my
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:03:49 <oerjan> iirc
09:03:57 <nooga_> and regional variants
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:55 <nooga_> it's fucked up
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:16 <nooga_> russian*
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:06:55 <nooga_> script*
09:07:18 <lereah_> How does LaTex work?
09:07:25 <nooga_> like LISP
09:07:29 <nooga_> ;D
09:07:36 <lereah_> It won't accept any extra space or newlines
09:07:43 <nooga_> with shitloads ofg macros
09:07:52 <nooga_> of*
09:07:53 <nooga_> damn
09:07:54 <lereah_> What are the macros for that shit?
09:07:57 <oerjan> lereah_: there are lots of spacing commands
09:08:01 <nooga_> ~~
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:08:15 <nooga_> ~
09:08:36 <lereah_> Lessee
09:08:54 * nooga_ amphetamine :C
09:09:13 <lereah_> Hm.
09:09:18 <lereah_> It doesn't do shit
09:09:32 <nooga_> idk ;p
09:09:41 <oerjan> lereah_: \hspace{...} and \vspace{...} at least
09:09:58 <lereah_> thx
09:10:03 <oerjan> but the contents are special length units
09:10:08 <oerjan> em and such
09:10:12 <nooga_> my read beard is awful
09:10:21 <nooga_> red*
09:10:25 <nooga_> FFFFFFUUUUU
09:10:30 <lereah_> Reading beards.
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 <nooga_> and i don't know why
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:15:39 <oerjan> englis iss so had
09:16:13 <nooga_> yesss i cannot spik
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:24:38 <lereah_> heh
09:25:03 <ais523> if you've ever tried to program in Java, you'll know how badly it needs lambda
09:25:11 <Patashu> *by having them
09:25:11 <Patashu> ?
09:25:31 <ais523> Java doesn't have lambdas
09:25:37 <ais523> at least, didn't when I last looked
09:25:42 <Patashu> I mean
09:25:50 <Patashu> lambdas are obscure right
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:04 <Patashu> o
09:26:14 <ais523> they're all over the place, even in some of Microsoft's langs
09:26:17 <ais523> even Python has them
09:28:45 <nooga_> OBSCURE?!
09:28:48 <nooga_> gimme a break
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:39 <Patashu> oops
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:14 <ais523> s/\/$/?/
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:27 <Patashu> what would it do?
09:31:43 <nooga_> Jaca does not have closures?
09:31:47 <nooga_> Java*
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:01 <Gracenotes> sorta.
09:33:07 <ais523> yes
09:33:13 <ais523> that's a really complex workaround, though
09:33:17 <ais523> for what /should/ be a simple operation
09:33:23 <Gracenotes> right. the canonical workaround
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:34:54 <ais523> ah, ok
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:37 <Gracenotes> which is rather pointless.
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:37 <Gracenotes> dunno. it was their solution.
09:37:39 <ais523> so you have bytecode compatibility + sanity
09:39:27 <Gracenotes> don't argue with the Java gods, now!
09:39:44 <ais523> but they were bought out by Oracle!
09:39:47 <Gracenotes> it's like tron, except it's the JVM
09:40:23 <Gracenotes> they will find you
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:28 <nooga_> OWN
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:01 <myndzi> :>
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:38 <myndzi> ya
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:07 <ais523> ok
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:30 <myndzi> moving*
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:46:51 <myndzi> what sort of thing?
09:47:00 <Patashu> he made defense9
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 <Patashu> like rushpolarity
09:47:10 <ais523> which confuses defence9
09:47:11 <myndzi> oh
09:47:15 <myndzi> right
09:47:16 <ais523> *defend9
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:26 <Patashu> pick what up from what?
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:44 <Patashu> if that's what you mean
09:48:46 <myndzi> no, i guess not
09:48:54 <myndzi> it's not the same thing when i look at it
09:48:58 <myndzi> you still have loops
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:42 <myndzi> i know you didn't
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:07 <Patashu> so how defense works is
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:25 <ais523> Patashu: not quite
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:44 <Patashu> you also have to win
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:55 <Patashu> yea
09:52:56 <myndzi> unless the opponent isn't looping
09:52:57 <ais523> well, (+)*96
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:12 <ais523> Patashu: that's it
09:53:17 <myndzi> i'm gonna run at you with a -.-..-... loop
09:53:17 <myndzi> ;)
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:38 <ais523> myndzi: correct
09:53:43 <myndzi> better: (-.)*256>(-..)*256
09:53:46 * myndzi grins
09:54:06 <ais523> myndzi: then I'll just beat you with speedy1
09:54:25 <myndzi> (-) (--.)(---.)
09:54:27 * myndzi shrugs
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:21 <myndzi> probably
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:19 <myndzi> :)
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:39 <Patashu> atm
09:56:50 <myndzi> not really
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:16 <myndzi> creep did pretty well
09:57:21 <Patashu> oh wait
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:41 <Patashu> lol
09:57:49 <Patashu> uuuugh
09:57:59 <myndzi> ugh is just another pointless wtfscript
09:58:06 <ais523> Patashu: htf does that beat speedy1?
09:58:08 <Patashu> wtfscript?
09:58:09 <myndzi> he advances to the right 30 times then goes back to the left(??)
09:58:16 <Patashu> oops, sorry...
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:35 <lereah_> God I hate LaTeX so much
09:58:39 <lereah_> The tutorial sounds so smug
09:58:48 <lereah_> I just want to punch my screen.
09:58:48 <myndzi> oh scuse me
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:27 <myndzi> pretty much
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:30 <Patashu> :D
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:49 <ais523> haha
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:37 <myndzi> you know though
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:15 <myndzi> eh, nevermind
10:03:17 <Patashu> but?
10:03:21 <myndzi> i worked out what i was thinking about and it's probably not a big deal
10:03:22 <myndzi> :)
10:03:25 <Patashu> ah
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:46 <myndzi> yeah
10:03:50 <myndzi> i did that early on
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:02 <ais523> agreed
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:09 <ais523> yep
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:52 <ais523> whoops
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:13:16 <Patashu> beats jump2 ugh shade
10:15:24 <ais523> !bfjoust another_kind_of_timing >>>>>[>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>[[+[-]>+]+[[-]>+]]>[[>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]][[+[-]>+]+[[-]>+]
10:15:27 <EgoBot> Score for ais523_another_kind_of_timing: 13.2
10:15:30 <Patashu> lol
10:15:32 <Patashu> O_O
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:08 <ais523> oh, duh
10:16:14 <ais523> !bfjoust another_kind_of_timing >>>>>[>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>[[+[-]>+]+[[-]>+]]>[[>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]>[>>>>>>>>>>>>>>[[+[-]>+]+[[-]>+]]+[[+[-]>+]+[[-]>+]
10:16:17 <EgoBot> Score for ais523_another_kind_of_timing: 13.2
10:16:24 <Patashu> no change
10:16:28 <ais523> ye[
10:16:32 <ais523> I wonder what I've messed up this time?
10:16:35 <ais523> *yep
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:48 <Deewiant> Beats ugh, keke2, shade
10:17:49 <EgoBot> Score for ais523_brackettest: 9.7
10:18:07 <Deewiant> That one beats jump2 :-P
10:18:20 <ais523> yep, jump2 suicides against an opponent that doesn't set up decoys
10:18:36 <Patashu> haha
10:18:39 <Patashu> interesting
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:20:59 <Deewiant> Beats shade
10:21:00 <Deewiant> :-P
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:02 <Deewiant> Ties the defends and waiter
10:22:07 <ais523> it should be losing
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:24:10 <ais523> hi amca
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:30:26 <GregorR-L> Aaaaand you're gone :P
10:30:38 <amca> ais523: Hi
10:30:47 <amca> oops
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:21 <jix> ah
10:37:24 <jix> right
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:38:58 <jix> i know
10:39:02 <Patashu> k
10:39:39 <jix> so basically i can never test whether my flag is zero....
10:40:58 <Patashu> no
10:41:00 <Patashu> but
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:17 <nooga_> oh, jix
10:43:21 <jix> !bfjoust try [>[-]+]
10:43:22 <nooga_> long time no see
10:43:24 <EgoBot> Score for jix_try: 19.6
10:44:32 <jix> indeed
10:45:34 <jix> in a loop is a cycle taken for [ and ] of the loop during iterations?
10:45:47 <Patashu> for ] yes
10:45:49 <jix> ah no isn't
10:45:50 <Patashu> for [ I think so
10:45:56 <jix> the spec sais isn't
10:46:06 <jix> ] jump to just after the matching [
10:46:17 <Patashu> hang on a sec
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:46:51 <Deewiant> Just checking :-)
10:47:04 <Patashu> [-] is executed like -]-]-]-]...
10:47:09 <Patashu> because ] is its own turn
10:47:10 <Deewiant> So if you have [-] then the execution is not [-][-][-], it's [-]-]-]
10:47:18 <jix> yeah
10:48:40 <jix> !bfjoust try <
10:48:43 <EgoBot> Score for jix_try: 0.0
10:48:48 <jix> haha
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:49:50 <Patashu> so either jump2 or shade
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:47 <jix> nope
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:31 <jix> ah
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:12 <Patashu> haha
10:57:19 <Patashu> actually
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:43 <jix> huh?
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:03 <jix> indeed
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:18 <Patashu> then you can give it a go
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:16 <Patashu> oh yeah
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:18 <Patashu> oh that's true
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:18 <Patashu> alright
11:03:27 <Patashu> also
11:03:40 <Patashu> randomly flipping or not flipping the second program's polarity
11:03:43 <Patashu> (all + to -, all - to +)
11:03:44 <Patashu> might be good
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:03 <Patashu> aah
11:06:10 <Patashu> I see
11:06:25 <jix> so they get ranked against the #estoric hill and my own GA hill
11:06:33 <Patashu> interesting
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:08:43 <Patashu> forget
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:35 <Patashu> hmm
11:10:35 <Patashu> yeah
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:54 <Patashu> that would
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:07 <Patashu> because
11:47:18 <jix> --
11:47:21 <Patashu> you take the cell value from the start of the round
11:47:23 -!- Corun has joined.
11:47:24 <Patashu> and turns are synchronous
11:47:28 <Patashu> so if a turn ends on 0
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:47:58 <ais523> tripwire
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:05 * leonid_ wakes up
11:50:22 <jix> !bfjoust idiot (-)*384000
11:50:26 <EgoBot> Score for jix_idiot: 24.2
11:50:27 <leonid_> uh oh
11:50:33 <Patashu> btw
11:50:38 <Patashu> max cycle count is current 100k
11:50:41 <Patashu> not 384k
11:50:49 <jix> oh
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:37 <leonid_> don't worry didn't run it
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:51:55 <leonid_> yeah
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:05 <leonid_> oh snap
12:03:21 <leonid_> you guys were talking badthing about me
12:03:22 <leonid_> :(
12:03:26 <jix> !bfjoust keep >>(+[])*300
12:03:27 <leonid_> bad things*
12:03:30 <EgoBot> Score for jix_keep: 5.2
12:03:50 <jix> !bfjoust keep >>(+[])*100000
12:03:51 <leonid_> :( :( :(
12:03:54 <EgoBot> Score for jix_keep: 15.0
12:04:36 <Patashu> jix
12:04:37 <leonid_> oh
12:04:39 <Patashu> by the time you exit the [] loop
12:04:40 <leonid_> i'm still at rank 6
12:04:41 <leonid_> haha
12:04:42 <Patashu> they'll have skipped past
12:04:50 <leonid_> ugh
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:04:59 <leonid_> dam people heate me
12:05:02 <leonid_> hate*
12:05:06 <jix> leonid_: huh?
12:05:10 <leonid_> nothing
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:40 <leonid_> read the code again
12:06:41 <jix> Patashu: i'm just experimenting
12:06:46 <leonid_> oh nvm
12:06:50 <Patashu> this is trivial optimization though
12:06:52 <Patashu> ;)
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:07:31 <leonid_> x(
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:37 <leonid_> durrrrr i'm dumbbbb
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:20 <leonid_> xp
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:12 <jix> ^^
12:10:15 <Patashu> oh lol
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 <Deewiant> Thought so
12:11:53 <jix> or they'll all sucide
12:12:06 <ais523> most BF programs don't start [-], though
12:12:08 <ais523> and none start <
12:12:15 <Deewiant> !bfjoust rot13 >[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>++++++++++++++<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>>+++++[<----->-]<<-[>+<-[>+<-[>+<-[>
12:12:18 <EgoBot> Score for Deewiant_rot13: 10.7
12:12:21 <Deewiant> +<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>++++++++++++++<-[>+<-[>+<-[>+<-[>+<-[>+<-[>++++++++++++++<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>>+++++[<----->-]<<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>++++++++++++++<-[>+<-]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]>.[-]<,]
12:12:23 <Patashu> lol
12:12:28 <Deewiant> Darn
12:12:30 <Deewiant> Too long
12:12:33 <Deewiant> :-D
12:12:33 <jix> !bfjoust err [
12:12:35 <Deewiant> Half of rot13 beats fibonacci
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:12:49 <leonid_> whoa
12:13:03 <jix> !bfjoust err ]+]
12:13:06 <EgoBot> Score for jix_err: 16.4
12:13:08 <leonid_> my dragon beats that
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:14:57 <AnMaster> morning
12:15:03 <jix> hmm i should write a debugger for this at some time
12:15:03 <AnMaster> or noon rather
12:15:23 <leonid_> evening here
12:15:24 <leonid_> ;p
12:15:57 <Deewiant> !bfjoust factorial >(+)*10>>>+>+[>>>+[-[<<<<<[+<<<<<]>>[[-]>[<<+>+>-]<[>+<-]<([>+<-)*9[>[-]>>>>+>+<<<<<<-[>+<-(])*11>[<+>-]+>>>>>]<<<<<[<<<<<](>)*7[>>>>>]++[-<<<<<]>>>>>>-]+>>>>>]<[>++<-]<<<<[<[>+<-]<<<<]>>[->[-]++++++[<(+)*8>-]>>>>]<<<<<[<[>+>+<<-]>.<<<<<]>.>>>>]
12:16:00 <EgoBot> Score for Deewiant_factorial: 8.8
12:16:03 <leonid_> whoa
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 <AnMaster> yeah
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:18:41 <Patashu> hmm nope
12:19:26 <leonid_> beat my random shit
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:20:44 <leonid_> :(
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:10 <Deewiant> Bunch of ties from that one
12:22:24 <Patashu> haha
12:22:33 <Patashu> imagine making one that looks like this but still gets lots of wins
12:22:40 <Patashu> obfuscated bfjoust :)
12:22:48 <leonid_> D:
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:23:00 <Patashu> lol
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:25:37 <Patashu> ?
12:25:40 <Patashu> oh right
12:25:47 <leonid_> whoa
12:26:48 <jix> huh something is wrong with the report?
12:26:55 <Patashu> is it just tabs?
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:28:54 <Patashu> yes
12:28:55 <Patashu> 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:20 <leonid_> dam
12:29:23 <Patashu> uh oh
12:29:33 <ais523> why the uh oh?
12:29:42 <Patashu> defend9 teh best program!!
12:29:43 <leonid_> mmmmm
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:47 <ais523> yay, not bad at all
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:34 <leonid_> !bfjoust ugh <
12:32:43 <EgoBot> Score for leonid__ugh: 0.0
12:32:47 <leonid_> nice
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 <Deewiant> Or is it just the RNG
12:33:50 <EgoBot> Score for jix_try2: 0.1
12:33:58 <jix> haha
12:34:01 <leonid_> beats mine
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 <leonid_> FIX IT NOW
12:34:25 <ais523> so any particular matchup should be deterministic
12:34:28 <leonid_> AARGHRGARG
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:39 <leonid_> not bad
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:48 <leonid_> ;p
12:35:55 <Patashu> !bfjoust the_greatest_program_ever!!! +[>[-[+]]-]
12:36:05 <EgoBot> Score for Patashu_the_greatest_program_ever___: 40.0
12:36:10 <leonid_> cool
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:33 <Patashu> oh
12:37:34 <Patashu> !bfjoust the_greatest_program_ever!!! +[>[-[+]]---]
12:37:36 <Patashu> there leaving it on that
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:08 <ais523> what happened to it?
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:46 <Patashu> I guess that
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:42 <Patashu> farmer?
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:34 <ais523> and I copied the name
12:40:36 <jix> !bfjoust whoops (>)*14(-.)*512
12:40:40 <leonid_> !bfjoust idiot <^.^>
12:40:40 <ais523> I might be wrong, though
12:40:44 <ais523> I've was up all night
12:40:44 <EgoBot> Score for jix_whoops: 8.5
12:40:44 <Deewiant> Yes, I did :-P
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:03 <Deewiant> Yay
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:50 <Patashu> what lol
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:48 <Patashu> why?
12:42:50 <leonid_> !bfjoust idiot :3
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:25 <Patashu> HASH VALUES
12:43:28 <EgoBot> Score for jix_whoops: 29.7
12:43:31 <Patashu> wait what was that text macro I had
12:44:13 <leonid_> !bfjoust idiot [>-[+]]
12:44:16 <leonid_> nvm
12:44:18 <Patashu> ~~~:'(HASH BASED RANDOMNESS:'(~~
12:44:23 <EgoBot> Score for leonid__idiot: 11.0
12:44:24 <leonid_> !bfjoust idiot [>-[+]-]
12:44:37 <EgoBot> Score for leonid__idiot: 30.8
12:44:40 <jix> we need a faster implementation for the hil
12:44:42 <leonid_> !bfjoust idiot [>-[+-+]-]
12:44:43 <jix> *hill
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:45:54 <Patashu> aha
12:45:56 <Patashu> there you go
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:16 <Patashu> the weaker speedy1 gets
12:53:19 <Patashu> the less it matters if you don't beat it
12:53:30 <ais523> yep
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:20 <Patashu> power through obfuscation
12:55:23 <Patashu> i.e. ages :)
12:55:31 <ais523> it's not meant to be obfuscated
12:55:40 <Patashu> it's brainfuck
12:55:43 <Patashu> i.e. obfuscated by definition
12:55:47 <ais523> ah
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:06:09 <leonid_> @_@
13:06:16 <Patashu> ^_^
13:06:38 <ais523> \o/
13:06:38 <myndzi> |
13:06:39 <myndzi> /<
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:08:53 <Patashu> im the juggernaut
13:11:22 <leonid_> L(-_- )7
13:11:24 <leonid_> / \
13:11:53 <lereah_> IS THAT YOU NAITO HORIZON
13:12:11 <leonid_> what
13:13:05 <lereah_> http://naitohorizon.blogspot.com/
13:13:51 <leonid_> lol
13:14:17 <leonid_> --( ^w^)-
13:14:27 <leonid_> /|
13:14:30 <leonid_> arrhhg ****
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:15:19 <lereah_> ⊂二二二( ^ω^)二⊃
13:15:21 <lereah_> Bu-n
13:15:50 <leonid_>          /⌒ヽ
13:15:50 <leonid_>   ⊂二二二( ^ω^)二⊃
13:15:50 <leonid_>         |    /       ブーン
13:15:50 <leonid_>          ( ヽノ
13:15:50 <leonid_>          ノ>ノ 
13:15:51 <leonid_>      三  レレ
13:15:57 <leonid_> nope
13:22:44 <leonid_> .....
13:28:16 <Gracenotes> it fails in monospace
13:28:32 <lereah_> Mona font isn't monospaced
13:28:34 <Gracenotes> sorry. your home is 2ch, cute creature
13:28:34 <lereah_> So yeah
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:30:01 <Gracenotes> ( ゚ -゚) you don't say
13:30:14 <lereah_> Gracenotes.
13:30:20 <lereah_> Do you like mittens.
13:30:20 <leonid_> ∂_∂
13:30:33 <leonid_> π_π
13:30:45 <leonid_> ≈_≈
13:30:56 <leonid_> º∑º
13:31:03 <Gracenotes> yes, I do like kittens so much
13:31:37 <Gracenotes> (づの‿の)づ
13:31:46 <leonid_> ugh
13:31:52 <leonid_> too lazy to bring up japanese keyboard
13:32:05 <Gracenotes> I just happen to keep my favorites :3
13:32:14 <lereah_> *mittens
13:32:26 <leonid_> ·‚·
13:32:27 <lereah_> http://tanasinn.info/wiki/%28_%EF%BE%9F_%E3%83%AE%EF%BE%9F%29
13:32:29 <leonid_> ·_·
13:32:43 <leonid_> ≥A≤
13:33:05 <leonid_> ◊_◊
13:33:07 <lereah_> ( ・ิω・ิ)
13:33:11 <Gracenotes> kittens
13:33:13 <lereah_> Why hello there
13:34:03 <lereah_> Mittens for kittens
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:02 <lereah_> heh
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:41 <ais523> possibly
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:12 <Gracenotes> oh, yes, that one
13:36:33 <lereah_> "Meeow, meeow, meeow, now we shall have no pie."
13:36:35 <lereah_> Awwww
13:36:38 <lereah_> Poor kittens
13:36:44 <Gracenotes> ais523: actually, it may be the same one :)
13:36:50 <ais523> yes, I think so
13:37:09 <ais523> ah, they lost them
13:37:15 <ais523> and then got them dirty eating the pie
13:37:17 <ais523> so we were both right
13:37:18 <Gracenotes> Part Une and Part Deux
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:38:58 <leonid_> ............... ?_?
13:45:16 <Gracenotes> (づの‿の)づ
13:45:25 <leonid_> (>'-')>
13:47:11 <lereah_>      | \
13:47:11 <lereah_>      |Д`) ...
13:47:11 <lereah_>      |⊂
13:47:11 <lereah_>      |
13:47:31 <Gracenotes> (>^.^)>
13:47:32 <Gracenotes> <(^.^<)
13:47:48 <Gracenotes> oh man, reminds me of when I had the kirby rolling game on my gameboy color
13:47:54 <Gracenotes> where you tilted the gameboy
13:47:59 <Gracenotes> good old days
13:48:35 <leonid_> >_>
13:51:01 <lereah_>     ∧ ∧___  
13:51:01 <lereah_>    /(*゚ー゚) /\
13:51:01 <lereah_>  /| ̄∪∪ ̄|\/
13:51:01 <lereah_>    |        |/
13:51:01 <lereah_>      ̄ ̄ ̄ ̄
13:55:12 <Gracenotes> they see me boxin
13:55:13 <Gracenotes> they hatin
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.
13:59:57 <leonid_> lmfao
14:00:40 <lereah_> A nutella cake
14:00:41 <Gracenotes> lereah_: I don't exactly get the foodstuffs.
14:00:46 <lereah_> A tomato in a muffin cup
14:00:55 <lereah_> Yes, it is quite maddening
14:01:02 <lereah_> What madman did this?
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:03:03 <leonid_> xD
14:05:31 <lereah_> I did that photo :(
14:09:02 <jix> is nesting of ( and ) allowed?
14:09:18 <ais523> jix: yes
14:09:25 <jix> :(
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:10:58 <Gracenotes> lereah_: >_>
14:11:23 <Gracenotes> nice pennies
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:48 <jix> *but
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:13 <leonid_>     ∧_∧∩        ∧_∧ )/
14:16:13 <leonid_>    ( ゚ ヮ゚)/        (゚ ヮ゚ ) ´
14:16:13 <leonid_>  _ / /   /       _と と ヽ
14:16:13 <leonid_> \⊂ノ ̄ ̄ ̄ ̄\   \  ̄ ̄ ̄ ̄ ̄\
14:16:13 <leonid_>  ||\        \  .||\.        \
14:16:14 <leonid_>  ||\|| ̄ ̄ ̄ ̄ ̄||   ||\|| ̄ ̄ ̄ ̄ ̄||
14:16:16 <leonid_>  ||  || ̄ ̄ ̄ ̄ ̄||   ||  || ̄ ̄ ̄ ̄ ̄||
14:16:18 <leonid_>     .||          ||      .||          ||
14:16:19 <jix> what interpreter does egobot use?
14:16:20 <leonid_> no
14:16:27 <ais523> jix: egojoust
14:16:32 <ais523> it's in the egobot distribution
14:16:33 <leonid_> o_O
14:18:33 <jix> ais523: which can be found where?
14:18:45 <ais523> !info
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:30 <Gracenotes> never have I ever
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:26:50 <Gracenotes> lereah_: O^_^O
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:31:20 <Gracenotes> [¬º-°]¬
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:35:32 <Gracenotes> well. half of /prog/ possibly. :/
14:35:43 <lereah_> Heh.
14:35:45 <lereah_> Iunno
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:30 <whtspc> hello
16:57:38 <oerjan> hello
16:57:46 <whtspc> hello oerkan
16:57:49 <whtspc> oerjan
16:57:58 <whtspc> I'm a big time lurker here
16:58:11 <whtspc> but I have a question
16:58:29 <oerjan> ?
16:58:31 <whtspc> so I speak out loud for once
16:58:50 <whtspc> Is there a standalone version of egobot
16:58:52 <whtspc> ?
16:59:06 <oerjan> !info
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:17 <oerjan> i don't know
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:00:45 <whtspc> ah ok, private
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:09 <whtspc> compile ?
17:03:18 <whtspc> to standalone?
17:03:29 <oerjan> if you _were_ a big computer nerd, you could probably change the code to make it standalone
17:03:38 <whtspc> exactly
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:14:31 <ehird> RIP i_keelst_thou
19:14:33 <ehird> 2009-2009
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:19:14 <ehird> teaser :)
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:14 <ehird> yes
19:28:16 <ehird> works
19:28:18 <ehird> patashu is wrong
19:28:20 <ehird> the problem is
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:49 <ehird> *very
19:28:56 <ehird> 22:21:59 <pikhq> And that method would fail with +[>+]
19:28:58 <ehird> finite tape
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:39 <ehird> ...
19:29:46 <ehird> Absolutely incorrect, psygnisfive.
19:29:50 <pikhq> Erm.
19:29:51 <ehird> Please don't say such stupid things.
19:29:54 <ehird> pikhq: yar
19:29:57 <pikhq> *For* a finite state machine.
19:30:01 <ehird> rite
19:30:21 <ehird> 22:27:23 <pikhq> ((lambda (x x)) (lambda (x x))) ;!
19:30:24 <ehird> repeats state :-P
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:30:48 <pikhq> ehird: Shaddup.
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:24 <ehird> yes
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:47 <pikhq> Fine.
19:31:48 <ehird> ..................
19:31:55 <ehird> psygnisfive: where do your definitions come from?
19:31:56 <ehird> they're bullshit
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:32:27 <pikhq> That too.
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:16 <ehird> no
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:46:54 <AnMaster> ehird, sure :)
19:47:06 <ehird> while(0){0-2, 1+1}
19:47:13 <AnMaster> correct
19:47:14 <ehird> (where x+y is ptr+x = y)
19:47:15 <ehird> eer
19:47:16 <ehird> +=y
19:47:17 <AnMaster> yep
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:39 <ehird> times(0/2){1+1}
19:47:46 <ehird> 0=0
19:47:51 <AnMaster> yes
19:47:52 <ehird> AnMaster: this is general, for example:
19:47:56 <ehird> [->+<]
19:47:57 <AnMaster> um
19:47:58 <ehird> would become
19:48:03 <ehird> AnMaster: wait
19:48:05 <ehird> [x] = value of cell x
19:48:08 <ehird> x = literal 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:34 <AnMaster> where is that notation from
19:48:38 <ehird> AnMaster: since x/1 = x, it works
19:48:40 <ehird> and I made it up
19:48:43 <ehird> AnMaster: but do you see?
19:48:45 <AnMaster> ok sure
19:48:56 <AnMaster> but how do you avoid iterations in that times?
19:49:01 <ehird> AnMaster: eh?
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:54 <AnMaster> ehird, we are
19:49:56 <ehird> which is p[1] = p[0]/2;
19:49:57 <AnMaster> so what about it then
19:49:59 <ehird> p[0]=0;
19:50:07 <ehird> AnMaster: but, we need to handle odd numbers
19:50:10 <ehird> let's say p[0]=3
19:50:14 <AnMaster> ehird, yes that is the issue
19:50:18 <ehird> [-->+<] p[1]+=1, p[0]=1
19:50:27 <ehird> [-->+<] p[1]+=1, p[0]=255
19:50:42 <ehird> then
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:00 <AnMaster> and so on
19:51:01 <AnMaster> yes
19:51:02 <ehird> AnMaster: etc
19:51:03 <ehird> up to
19:51:09 <ehird> [-->+<] p[1]+=1, p[0]=1
19:51:09 <AnMaster> down to ;P
19:51:11 <ehird> (I believe)
19:51:18 <ehird> AnMaster: so we can conclude that
19:51:20 <ehird> if the number is odd
19:51:21 <ehird> it loops forever
19:51:23 <ehird> and eva
19:51:23 <AnMaster> sure
19:51:25 <ehird> and eva
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:56 <ehird> tada
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:16 <ehird> *!=0
19:52:42 <AnMaster> ehird, with 256-wrapping cells it is always finite
19:52:55 <ehird> AnMaster: hmm
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:16 <ehird> 2 secs
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:20 <ehird> wait, wait, sec
19:54:26 <AnMaster> I think
19:54:43 <AnMaster> yep
19:54:45 <ehird> prog written
19:54:48 <ehird> AnMaster: end values are
19:54:51 <ehird> [0]=0, [1]=127
19:54:55 <ehird> for [0]=4, [1]=0
19:54:59 <ehird> and [--->+<]
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:26 <AnMaster> sure
19:55:38 <ehird> oh wait
19:55:40 <ehird> [1]!=127
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:56:58 <ehird> (and thus [1]=86)
19:57:01 <ehird> well, maybe 87
19:57:06 <ehird> 0-based indexing throwing me off
19:57:06 <ehird> whatever
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:06 <ehird> which is 0.6r
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> >> _0=9;_1=0 => 0
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:20 <ehird> => nil
19:59:22 <ehird> >> 9/3
19:59:24 <ehird> => 3
19:59:26 <ehird> AnMaster:
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:21 <AnMaster> :(
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:00:56 <AnMaster> expands them and so on
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:41 <ehird> err
20:01:43 <ehird> perhaps [0]=(N/2)+1 → [1]=(result_of_N)-1
20:01:45 <ehird> mixed that up
20:01:55 <AnMaster> err... for which code?
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:22 <ehird> (4/2) = 2
20:02:24 <ehird> 2 - 1 = 1
20:02:28 <ehird> result_of_4 = 172
20:02:30 <ehird> result_of_1 = 171
20:02:36 <ehird> (8/2) = 4
20:02:42 <ehird> 4 + 1 = 5
20:02:47 <ehird> result_of_8 = 88
20:02:52 <ehird> result_of_4 = 87
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:01 <ehird> how queer this is
20:03:18 <AnMaster> hm
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:12 <AnMaster> where N was?
20:04:18 * AnMaster lost track
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:47 <ehird> in [-*N>+<]
20:04:48 <ehird> and yes, I know
20:04:50 <AnMaster> s/if/is/
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:06 <AnMaster> ah
20:05:08 <ehird> (to divide)
20:05:10 <AnMaster> anyway
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:34 <ehird> i know
20:05:35 <AnMaster> since I could just do:
20:05:45 <ehird> yes
20:05:45 <ehird> I know
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:16 <AnMaster> "duplicate"
20:06:25 <AnMaster> not "duplication"
20:06:29 <AnMaster> typoed there
20:06:36 <AnMaster> ehird, what is 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:06:50 <GregorR-L> SO I HERD U LIEK MUDJOUST
20:06:59 <ehird> cookies are tasty
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:12 <GregorR-L> Oooh, slowrush is down.
20:07:15 <GregorR-L> And a defender is on top again.
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:07:52 <GregorR-L> I was gonna say it :P
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:15 <AnMaster> ehird, just an idea
20:09:20 <ehird> AnMaster: You should warn me before saying such amazing things.
20:09:27 <AnMaster> ehird, why
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:09:48 <AnMaster> since I'm always amazing
20:09:50 <AnMaster> ;P
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:23 <AnMaster> ;P
20:10:34 <ehird> true enough
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:41 <AnMaster> bacon joust
20:11:52 <AnMaster> not a programming language
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:00 <AnMaster> but
20:12:03 <AnMaster> with bacon instead
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:56 <ehird> sorry, I said pig
20:12:58 <ehird> I meant prebacon, of course
20:13:01 <AnMaster> haha
20:13:06 <AnMaster> ehird, what about garlic joust
20:13:09 <AnMaster> how would it work
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:28 <AnMaster> hm
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:01 <ehird> thrilling
20:14:10 <AnMaster> ehird, yes, or a gunniea pig (sp?)
20:14:16 <ehird> guinea pig
20:14:19 <AnMaster> ah
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:41 <AnMaster> ehird, why is that?
20:14:46 <ehird> impossible to catch and escape all the time
20:14:46 <AnMaster> would it eat the garlic?
20:14:52 <AnMaster> oh I see
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:15:47 <GregorR-L> Nom nom nom.
20:16:03 <AnMaster> ehird, still going for the polarity thing?
20:16:07 <ehird> AnMaster: of course
20:16:12 <AnMaster> mhm
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:15 <ehird> or
20:17:19 <ehird> the program that would do + does [
20:17:21 <ehird> ie
20:17:22 <AnMaster> ah
20:17:22 <ehird> swapped
20:17:25 <ehird> then it changes
20:17:28 <AnMaster> isn't it checked at start of loop?
20:17:29 <AnMaster> iirc
20:17:31 <ehird> ...........
20:17:36 <ehird> AnMaster: the two programs run simultaneously
20:17:40 <ehird> (a,b) matchup = (b,a) matchup
20:17:42 <AnMaster> err
20:17:44 <AnMaster> start of turn
20:17:44 <AnMaster> duh
20:17:48 <AnMaster> is what I meant
20:17:51 <ehird> AnMaster: yes
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:14 <ehird> or 2 cycles
20:18:15 <ehird> or whatever
20:18:29 <AnMaster> only overhead if there actually is a loop then
20:19:07 <ehird> AnMaster:
20:19:07 <ehird> % time ./lance
20:19:08 <ehird> 2
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:14 <ehird> *milliseconds
20:19:34 <GregorR-L> That was for it to do ... what?
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:02 <GregorR-L> Ah
20:20:11 <ehird> but [>[-]+] and >+[]<[-]
20:20:15 <AnMaster> interpreter with built in programs!
20:20:15 <AnMaster> :D
20:20:20 <ehird> AnMaster: currently a total 42 match would take 0.168 seconds
20:20:41 <ehird> AnMaster: and remember
20:20:43 <ehird> this is a timeout
20:20:45 <ehird> there isn't any win logic
20:20:48 <ehird> so it runs forever
20:20:51 <AnMaster> indeed
20:20:52 <ehird> admittedly, they probably just nop forever
20:20:58 <ehird> after a bit
20:20:59 <ehird> but meh
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:19 <AnMaster> or on the fly
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:21:49 <AnMaster> ehird, what is this menthod
20:21:51 <AnMaster> method*
20:22:01 <ehird> AnMaster: hard to understand is what it is
20:22:11 <AnMaster> try it
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:31 <ehird> :)
20:22:34 <ehird> AnMaster: pretty much
20:22:36 <AnMaster> seems fairly straightforward
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:37 <AnMaster> until there wasn't
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:10 <AnMaster> due to the additional logic
20:24:34 <AnMaster> ehird, is that what you meant?
20:26:21 <ehird> dunno
20:26:42 <AnMaster> ehird, do you understand what I mean though?
20:26:55 <ehird> yes
20:26:57 <ehird> ask nescience
20:27:34 <AnMaster> nescience, there?
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:05 <bsmntbombdood> hmmmm
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:28:55 <ehird> I agree.
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:48 <nescience> !bfjoust whoops (-)*127>+[]<-+
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:03 <nescience> ha, oh well
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:19 <AnMaster> ..
20:31:44 <ehird> !bfjoust spoohw (-)*127>+[]<[[-+]+]
20:31:55 <EgoBot> Score for ehird_spoohw: 15.1
20:32:02 <ehird> ah, randomness.
20:32:04 <ehird> how i hate thou
20:32:11 <nescience> !bfjoust whoops (-)*127>+[]<-+.
20:32:22 <EgoBot> Score for nescience_whoops: 13.6
20:32:39 <nescience> err
20:32:42 <nescience> !bfjoust whoops (-)*127>+[]<.-+
20:32:52 <nescience> delay a beat because of double brackets
20:32:53 <EgoBot> Score for nescience_whoops: 14.4
20:32:57 <nescience> still no good, o well
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:33:55 <nescience> sure, in a sec
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:36:42 <ehird> same as {?
20:36:46 <nescience> ignore it
20:36:49 <nescience> it's the label, not the jump
20:36:52 <ehird> ah
20:36:57 <nescience> ( and } both behave that way
20:37:09 <nescience> { and ) are the "if/goto"
20:37:20 <ehird> nescience: how does egojoust handle (a{b}c)*N, I wonder?
20:37:21 <ehird> parse error?
20:37:23 <ehird> ignore the { and }?
20:37:27 <ehird> break randomly?
20:37:29 <ehird> GregorR-L: ?
20:37:30 <GregorR-L> 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:37:50 <nescience> no
20:37:53 <nescience> they do not take a cycle
20:37:55 <GregorR-L> They're treated like comments.
20:37:57 <nescience> do not ignore {
20:38:25 <ehird> ah, true
20:38:35 <ehird> it just seems a pain, since you have to delay parsing until )
20:38:47 <nescience> well
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:14 <ehird> etc
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:36 <nescience> oh
20:39:37 <nescience> right
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:18 <nescience> ([{})%N]
20:40:21 <nescience> but fuck that shit :>
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:40:58 <ehird> nescience: idea
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:06 <nescience> yes
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:02 <ehird> so
20:43:07 <ehird> (a[)*3b)]c)*3
20:43:08 <ehird>
20:43:10 <ehird> err
20:43:11 <ehird> (a[)*3b)]c)*2
20:43:12 <ehird>
20:43:19 <ehird> fix that syntax
20:43:20 <ehird> but w/e:
20:43:20 <ehird> a[a[a[b]c]c
20:43:25 <ehird> nescience: which is, of course, an unmatched [
20:43:28 <ehird> vs unmatched ]
20:43:31 <ehird> you could just report it as that
20:49:25 <nescience> i guess
20:49:34 <nescience> to be honest i don't like the ({}) syntax much
20:49:38 <nescience> but i like the alternative less
20:49:58 <nescience> but what i meant is
20:50:03 <nescience> if you allow ([)*N
20:50:08 <nescience> people will be tempted to do something like
20:50:18 <nescience> ([)*4a(])*2b(])*2c
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:31 <nescience> no
20:51:36 <nescience> i'm not sure it's useful
20:51:39 <nescience> but someone'll probably try it
20:51:47 <nescience> you know what might make things more pleasant to look at btw
20:51:50 <nescience> go all regex style
20:51:53 <nescience> don't require () for *
20:51:58 <nescience> but if no () only apply it to the last char
20:52:18 <nescience> then you'd only have a[*3b]*3c
20:52:21 <nescience> which looks slightly better
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:34 <ehird> nescience: yeah
20:53:36 <ehird> that's LR(something)
20:53:38 <nescience> you can't just jump directly to the same bracket
20:53:45 <nescience> like you can with ({})
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:10 <ehird> +3 -> +, repeat 3
20:54:12 <nescience> hell, allow 0 just for kicks :P
20:54:16 <ehird> ewll
20:54:16 <ehird> repeat 2
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:16 <nescience> lookahead is the wrong term
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:31 <nescience> unless, again, you expand
20:55:36 <ehird> instead of + looking for a number
20:55:39 <ehird> you just do +
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:56:34 <AnMaster> (sorry was away before
20:56:36 <AnMaster> )
20:56:37 <nescience> 3+
20:56:39 <nescience> = 3 +'s
20:56:42 <nescience> 3(+-)
20:56:45 <nescience> = 3 +-'s
20:57:34 <ehird> nescience: we just need a metalanguage ;0
20:57:35 <ehird> ;)
20:57:38 <ehird> *;)
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:10:53 <ehird> wut
21:11:17 <bsmntbombdood> argh
21:11:27 <bsmntbombdood> optimization makes testing hard
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:22 <AnMaster> ehird, famous quote
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:44 <nescience> ([([a{}])*2b{})*2c or something
21:13:48 <AnMaster> That kind of stupid?
21:13:50 <nescience> but it's confusing as hell to do so :P
21:13:55 <nescience> point in favor of no squigglies
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:14:59 <AnMaster> the "don't expand" bit
21:15:00 <AnMaster> I mean
21:15:01 <ehird> Therefore it came out garbled
21:15:07 <nescience> AnMaster: you didn't either
21:15:08 <AnMaster> ehird, it was indeed what I thought it was
21:15:16 <ehird> nescience: indeed
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:31 <nescience> not "intelligence"
21:15:33 <AnMaster> nescience, sure do. About jumping to matching ] can be done across {} (assuming no unbalanced [] in {}
21:16:04 <AnMaster> !bfjoust test ++({[++]})%2
21:16:09 <AnMaster> ...
21:16:15 <EgoBot> Score for AnMaster_test: 14.9
21:16:19 <ehird> errrrrrrrrm
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:32 <ehird> haha you're funy
21:16:34 <ehird> funny, even
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:00 <ehird> that's trivial
21:17:05 <AnMaster> !bfjoust test ++[(+[+{++[}+]+)]%2
21:17:11 <AnMaster> !bfjoust test ++[(+[+{++[}+]+)%2]
21:17:13 <AnMaster> even
21:17:22 <EgoBot> Score for AnMaster_test: 15.6
21:17:22 <EgoBot> Score for AnMaster_test: 15.6
21:17:25 <AnMaster> ehird, of course you can't
21:17:28 <AnMaster> but the latter one you could
21:17:36 <ehird> the latter one is invalid
21:17:36 <AnMaster> you could segfault on it
21:17:39 <ehird> i'm pretty sure
21:17:55 <AnMaster> ehird, yes. And I was hoping for "yet another segv bug"
21:18:00 <AnMaster> seems there wasn't however
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:18:14 <AnMaster> ehird, I were before?
21:18:19 <AnMaster> I think it was his one
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:15 <ehird> HAHAHAHAHAHAHA
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:38 <AnMaster> ehird, what is wrong with it.
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:20:27 <AnMaster> simple as that
21:20:31 <nescience> haven't sat down and did it yet
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:27 <psygnisfive> ehird
21:21:29 <nescience> until your counter is less than one you hit
21:21:33 <nescience> then you behave as per ({})
21:21:33 <ehird> psygnisfive: what
21:21:35 <nescience> or some variant of that
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:10 <nescience> that's not quite right though
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 <nescience> not when repeating them
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 <nescience> well skipping [s and executing ]s
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:00 <nescience> (a]b])*N
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:22 <ehird> slow though, ofc
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:24:49 <psygnisfive> thats irrelevant to the point
21:25:04 <ehird> so's your butt
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:51 <psygnisfive> perhaps!
21:25:54 <ehird> that compile to js
21:26:03 <psygnisfive> but im going to write my own.
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:38 <psygnisfive> maybe with some ruby syntax stuff
21:27:43 <ehird> psygnisfive: there are smalltalks in JS, iirc
21:27:47 <AnMaster> ehird, and ais doesn't log read
21:27:52 <psygnisfive> thats nice, ehird
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:31 <AnMaster> :)
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:07 <GregorR-L> Somehow I disagree.
21:29:10 <GregorR-L> :P
21:29:11 <AnMaster> ehird, I think he wasn't aiming for a parody
21:29:11 <ehird> :)
21:29:19 <ehird> AnMaster: I was joking.
21:29:23 <AnMaster> ehird, so was I
21:29:28 <GregorR-L> SO WAS YOUR FACE
21:29:36 <ehird> AnMaster: Also, me responding to logreads doesn't affect anyone else. Cluttering the hill with mututally-drawing does.
21:29:37 <AnMaster> and your mom
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:10 <ehird> You're welcome
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:30 <AnMaster> GregorR, agreed
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:43:30 <ehird> GregorR-L: wut
21:44:07 <nescience> somebody enlighten me: what's a TM? :P
21:44:28 <GregorR-L> A Turing Machine I assume?
21:44:37 <ehird> yes
21:44:47 <nescience> oh, right.
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:03 <ehird> GregorR-L: .avi?
21:55:04 <ehird> what codec?
21:55:08 <GregorR-L> MPEG4
21:55:14 <ehird> mpeg 4 in .avi?
21:55:21 <ehird> GregorR-L: Quicktime says it's divx.
21:55:24 <GregorR-L> I'm using mencoder and I'm lazy.
21:55:26 <GregorR-L> DivX is MPEG-4.
21:55:32 <ehird> ... erm, it is?
21:55:35 <GregorR-L> Yes.
21:55:44 <ehird> hm
21:55:45 <ehird> so it is
21:55:49 <ehird> GregorR-L: i don't want to install divx shit
21:55:52 <ehird> :<
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:05 <GregorR-L> That's retarded.
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:33 <GregorR-L> Or whatever that fourcc is.
21:56:39 <ehird> GregorR-L: well, do it the LVM4 thing then
21:56:40 <GregorR-L> LMP4? FMP4 maybe?
21:56:49 <ehird> GregorR-L: what is the video actually of?
21:56:55 <GregorR-L> The report changing over time.
21:56:58 <ehird> ah.
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:11 <nescience> ehird: yes i am myndzi
22:03:21 <nescience> this is my laptop at work, myndzi is my home client
22:03:30 <ehird> right
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:04:06 <ehird> heh
22:04:41 <GregorR-L> Bleh upload so slow.
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:05:50 <ehird> oh, there it is
22:06:01 <ehird> GregorR-L: oh my god the quality is awful
22:06:08 <GregorR-L> That's really not the point.
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:48 <GregorR-L> FUCK
22:06:49 <GregorR-L> YOU
22:06:57 <ehird> GregorR-L: You forgot "QED"
22:07:55 <Deewiant> ehird: The previous one looked better
22:08:00 <Slereah> Quantum Electro Dynamics
22:08:04 <ehird> Deewiant: If only I could watch it
22:08:06 <Deewiant> You have only yourself to blame :-P
22:08:15 <ehird> Do I?
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:35 <ehird> so, nothx.
22:08:36 <Deewiant> Not unless you ask it to
22:08:50 <ehird> Deewiant: i've never told it to and it always does
22:09:00 <GregorR-L> Uhhhhhh
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:08 <GregorR-L> I didn't reencode.
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:00 <ehird> SKEPTOVISION
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:20 <ehird> I know.
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:32 <ehird> whut
22:12:45 <GregorR-L> Those are both ffmpeg-specific formats.
22:12:47 <ehird> :D
22:12:52 <Deewiant> I can play ffvhuff
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:13:29 <GregorR-L> And so's your FACE.
22:13:34 <ehird> YOUR FACE BITCH
22:13:39 <ehird> You're face bitch
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:57 <GregorR-L> Presumably nooga is cro-magnon.
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:29 <GregorR-L> !google omg liek wtf
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:42 <ehird> fins r dum
22:20:46 <ehird> !show google
22:20:46 <EgoBot> bf +++++++++++++++[>+++++++>+++++++>++++>+<<<<-]>-.++++++++++++..----.>>--.-----------..<--.++++++++..--------.<----.>--.>-.<--.<+++.--.>>+.<<++++++.>++.----.<-.>++.+++++.>++++++++++++++++.<<-.>>--.,[>[-]>[-]<<[>+>+<<-]>>>[-]++++++++[<---->-]<[[-]>+<]>-[<<[-]>+++++++[<++++++>-]<+>>[-]]<<.[-]<,]
22:21:09 <Deewiant> !bfjoust google +++++++++++++++[>+++++++>+++++++>++++>+<<<<-]>-.++++++++++++..----.>>--.-----------..<--.++++++++..--------.<----.>--.>-.<--.<+++.--.>>+.<<++++++.>++.----.<-.>++.+++++.>++++++++++++++++.<<-.>>--.,[>[-]>[-]<<[>+>+<<-]>>>[-]++++++++[<---->-]<[[-]>+<]>-[<<[-]>+++++++[<++++++>-]<+>>[-]]<<.[-]<,]
22:21:20 <EgoBot> Score for Deewiant_google: 6.2
22:21:26 <Deewiant> Google sux
22:21:39 <ehird> :D
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:13 <ehird> -------------.
22:22:15 <ehird> dammit
22:22:16 <ehird> oh well
22:22:19 <ehird> they miss a dot
22:22:21 <EgoBot> Score for ehird_telepath_homicider: 3.8
22:22:25 <ehird> \o/
22:22:30 <ehird> i anti won!
22:22:32 <GregorR-L> !bfjoust i_am_kiling_you_with_the_power_of_my_mind +++++++++++++++[>++>+++++>+++++++>+++++++<<<<-]>>--.<++.>++++++++++++++++++++++++.>>++++.<<<.>++++++++++.>.>-..<.>++.<--.<<.>>>+++++++++++.<<++++.++++++.<.>>>--.<++.<-.>-.<<.>.>.---.---------------------------------------------------------------------.>-------.-.++++++++.<<<+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>--.>.<---.<+.>>.<--.>>++.<.<.----.+
22:22:32 <GregorR-L> ++++.<--.>>++++++++++++++.------------------------------------.
22:22:35 <GregorR-L> Maaaaaaaaand
22:22:40 <GregorR-L> *Maaaaaan
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 <pikhq> !bfjoust .
22:24:36 <EgoBot> Use: !bfjoust <program name> <program>
22:24:42 <pikhq> !bfjoust . .
22:24:53 <EgoBot> Score for pikhq__: 9.9
22:25:11 <pikhq> MI ESTAS VEJNANTO!
22:26:48 <GregorR-L> !bfjoust pooper_scooper [[>+<-]>]
22:26:59 <EgoBot> Score for GregorR-L_pooper_scooper: 0.0
22:27:04 <GregorR-L> YES!
22:27:06 <GregorR-L> I WINS
22:27:08 <ehird> haha what
22:27:26 <ehird> that lost against everything
22:27:29 <ehird> how did you do that GregorR-L
22:28:15 <GregorR-L> Idonno :P
22:28:25 <GregorR-L> I prevented anything from running off the tape I guess.
22:28:31 <GregorR-L> While zeroing my flag.
22:28:53 <pikhq> Lawlz.
22:29:13 <pikhq> !bfjoust vejni [>+<-]
22:29:17 <pikhq> Might work better.
22:29:24 <EgoBot> Score for pikhq_vejni: 1.8
22:29:30 <pikhq> CURSES.
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:30:46 <ehird> what, really? :P
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:18 <ehird> 100/3 = 33.3r
22:34:29 <ehird> ... wait, no.
22:34:34 <ehird> Yeah, he just said his IQ is 300 :P
22:35:51 <pikhq> GregorR-L: Erm.
22:35:57 <pikhq> Thinko.
22:36:03 <ehird> pikhq: so what did you mean :P
22:36:06 <pikhq> I meant 150.
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:30 <GregorR-L> SATAN-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:13 <ehird> But not that far.
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:15 <GregorR-L> Ploopiforbleboopidoopdoop.
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:20 <GregorR-L> ehird: MARF BLEEP GORBLEN TWERL!
22:44:36 <ehird> GregorR-L: 71.7
22:44:50 <ehird> pikhq: Hey, more likely than winning the lottery.
22:45:02 <pikhq> Indeed.
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:45:53 <ehird> GregorR-L: 150
22:46:16 <pikhq> GregorR-L: Thy discourse is shameful to us all.
22:46:22 <GregorR-L> pikhq: 11
22:46:32 <pikhq> ehird: This is true of thine, as well.
22:46:42 <ehird> pikhq: vut
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:02 <ehird> pikhq: -42
22:48:06 <ehird> You're anti-meaningful.
22:48:06 <GregorR-L> y tongue is doth curse.
22:48:33 <pikhq> Sweet! I wrapped arround!
22:48:46 <pikhq> GregorR-L: doþ, þou mean'st.
22:48:54 <GregorR-L> pikhq: 4,294,967,254?
22:49:10 <GregorR-L> pikhq: Yeah, I noticed at :(
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:38 <GregorR-L> SUPERALIENS
22:49:56 <ehird> pikhq: By the way, if your IQ _is_ 150, then you're in the 99.997th percentile.
22:50:00 <ehird> That's 0.003% :P
22:50:13 <ehird> Wait, no.
22:50:13 <GregorR-L> That's more common than my chrome allergy.
22:50:15 <ehird> That's 160.
22:50:15 <pikhq> ehird: Bah.
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:05 <ehird> HAHAHAHA
22:51:08 <ehird> http://olymp.iqsociety.org/
22:51:09 <ehird> author link:
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:09 <ehird> lawl
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:36 <GregorR-L> Wow
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:44 <nescience> so like
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:15 <GregorR-L> ehird: lawl
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:35 <ehird> nescience: lol
22:54:37 <GregorR-L> Wow.
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:10 <ehird> >273648234?
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:11 <Deewiant> There's also europium
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:21 <GregorR-L> And einsteinium.
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 <Deewiant> GregorR-L: And oxygen!
22:57:26 <ehird> the owner calls himself the Psychometitor
22:57:30 <Deewiant> Don't forget oxygen
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:41 <ehird> Dude.
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:57:54 * nescience shrugs
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:00:12 <ehird> Per-meat-ing
23:02:16 -!- olsner has quit (anthony.freenode.net irc.freenode.net).
23:02:23 <GregorR-L> Hmmmm.
23:02:29 * GregorR-L tries to think of a meaning of per-meat-ing.
23:02:39 <bsmntbombdood> interesting
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:03:33 <GregorR-L> ehird: laaaaaaaawl
23:06:24 <ehird> brb
23:07:04 <GregorR-L> OMFG
23:07:11 <GregorR-L> I need orn Porn!
23:07:17 <GregorR-L> RULE 34
23:07:29 <pikhq> Þorn porn?
23:07:33 <pikhq> Tempting.
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:42 <GregorR-L> |>
23:08:48 <pikhq> The little round bit looked more... ›-like.
23:08:52 <pikhq> Yeah.
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:18 <pikhq> Erm.
23:12:21 <pikhq> Peorð, I mean.
23:12:38 -!- kar8nga has quit (Remote closed the connection).
23:12:46 <GregorR-L> Hm
23:13:37 <pikhq> Wynn looks similar, though.
23:13:38 <pikhq> http://en.wikipedia.org/wiki/%E1%9A%B9
23:15:19 <GregorR-L> So, who's gonna make orn porn?
23:15:44 <pikhq> Þou.
23:15:47 <FireFly> Hmm, interesting
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:27 <FireFly> Well, true
23:16:27 <GregorR-L> The esoteric crypto runes.
23:16:45 <FireFly> Ogham? Off to wiki ->
23:16:59 <pikhq> There's even a proposal for Voynich.
23:19:33 <myndzi\> lol
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:19:55 <myndzi\> awesome
23:20:01 <myndzi\> can't wait to go trollin' forums with that
23:20:06 <Deewiant> "Probably"?
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:32 <myndzi\> well think about it
23:21:42 <myndzi\> if you have that many symbols available and nothing better to do with them..?
23:21:44 <myndzi\> :)
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:25 <GregorR-L> ey didn't accept Klingon? :(
23:22:37 <myndzi\> WHAT
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:43 <myndzi\> also quenya
23:22:44 <myndzi\> :>
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:26 <Deewiant> I think it has
23:25:37 <Deewiant> http://esolangs.org/wiki/Var%27aq
23:25:45 <FireFly> Hm
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.
←2009-05-28 2009-05-29 2009-05-30→ ↑2009 ↑all