00:01:27 -!- Zuu has joined.
00:01:36 -!- HackEgo has quit (Ping timeout: 240 seconds).
00:02:12 -!- GregorLOL has joined.
00:02:24 <GregorLOL> Codu killed itself :P
00:02:40 -!- Gregor has quit (Ping timeout: 272 seconds).
00:03:52 <elliott> GregorLOL: wat
00:04:00 <elliott> I blame <elliott> !bfjoust dos ((([)*-1)*-1)*-1
00:04:35 <GregorLOL> Maybe :P
00:05:18 -!- Guest56466 has joined.
00:05:30 <Guest56466> why hallo thar
00:08:07 -!- Guest56466 has changed nick to Gregor.
00:09:52 -!- cheater- has joined.
00:12:23 <Sgeo> elliott, what random bugs?
00:12:27 <Sgeo> Maybe I can help?
00:12:27 -!- cheater00 has quit (Ping timeout: 240 seconds).
00:12:40 <elliott> C code ain't doin' what it should do and I have no idea why.
00:12:49 -!- GregorLOL has quit (Quit: GregorLOL).
00:12:58 <elliott> Works for small examples, doesn't for substantial ones .
00:14:44 <Sgeo> Are you going to give anyone a chance to look at the code?
00:14:56 <Sgeo> Put it on bitbucket and use Hg, or put it on github and use git!
00:14:59 <zzo38> I have read a report from some music company that they don't really have problem if you copy pirated music files. But if you like CDs, buy it directly from them. If you do not like CDs, purchase the files directly from them. You can also donate any amount of money. If you buy CDs from the store, they are nonbiodegradable. If you buy their files from iTunes, the artists won't earn any money from it at all.
00:15:25 * Sgeo hits elliott with a Perfect Solution fallacy
00:15:38 <zzo38> Sgeo: There is also repo.or.cz for git, as well..... and also sprunge in case you just want to post one file
00:15:49 -!- HackEgo has joined.
00:15:50 <Sgeo> Shhh, don't remind elliott of sprunge
00:15:50 -!- EgoBot has joined.
00:15:50 <elliott> Sgeo: What?
00:15:58 <Gregor> !bfjoust lolwut <
00:16:04 <Sgeo> elliott, your reason for not using Version Control scks
00:16:06 <Sgeo> sucks too
00:16:23 <elliott> Sgeo: I don't _like_ version control for the start of projects.
00:16:25 <elliott> I am hardly alone in this.
00:16:30 <elliott> Besides, you're one to talk, you never even code.
00:17:15 <zzo38> Sgeo: Why not sprunge? Is there anything wrong with it?
00:17:32 <Sgeo> zzo38, it would mean elliott not using version control
00:17:48 <elliott> Sgeo thinks that everyone has to use version control to code right from the start of a project despite the fact that that's nonsense.
00:19:17 <zzo38> But sprunge is not version control anyways. You don't substitute it. If you use version control you use it.
00:19:52 <Sgeo> But I wanted there to be an excuse for elliott to post on a version control site
00:23:27 <Gregor> !bfjoust lolwut <
00:25:00 <pikhq> elliott: http://www.etalabs.net/musl/ Kitten should use.
00:25:18 <elliott> pikhq: Where did you find this?
00:25:38 <pikhq> elliott: Proggit.
00:25:48 <elliott> pikhq:
00:25:48 <elliott> Linux 2.6 or later.
00:25:49 <elliott> i386 family (32-bit x86) machine (support for others coming soon).
00:25:50 <elliott> Sorry.
00:25:51 <elliott> Can't use.
00:26:01 <pikhq> elliott: Can't use *currently*.
00:26:14 <elliott> Wow, it compiles gcc 3.
00:26:22 <elliott> pikhq: Well... I could always start with x86 and move to x86-64 later.
00:26:45 <pikhq> Even as-is, it seems to at *least* be dietlibc-but-better-in-most-every-way.
00:27:13 <elliott> pikhq: Well... its goals seem a little warped:
00:27:15 <elliott> [[Then in early 2010, I got an idea for a new direction. I could make some minor changes to my types to align them with the glibc definitions, and reimplement stdio FILE so that key pointer elements which might be accessed from glibc getc/putc macros would retain their offsets in the structure and their semantics. With these changes, it wouldn't be very far-fetched to expect that I could get many binaries compiled against glibc to dynamically lin
00:27:15 <elliott> k and run against my implementation.]]
00:27:49 <elliott> pikhq: I am tempted to have a go at writing my own libc now, though.
00:27:59 <elliott> pikhq: Heh, from the same guy: "uuterm - a tiny multilingual Unicode terminal emulator for X or Linux fbcon"
00:29:36 <pikhq> elliott: Keep in mind that it's only slightly larger than dietlibc right now. Yet significantly more useful.
00:29:58 <elliott> pikhq: Sure. I don't see how it is significantly more useful, though.
00:30:02 <elliott> dietlibc has quite good compatibility.
00:30:06 <elliott> But if it has locale support that's good.
00:30:47 <elliott> "All of these figures were obtained using my libc-bench suite, in UTF-8 locales, on one particular Intel Atom N280-based machine."
00:30:49 <elliott> Atom. "Nice."
00:31:08 <pikhq> musl only supports a "C.UTF-8" locale, but has a reasonably good iconv implementation.
00:31:25 <pikhq> It has pthreads.
00:31:28 <elliott> pikhq: Hmm. I am now tempted to write my own libc /with proper locale support/.
00:31:46 <elliott> dietlibc's pthreads are listed as "broken" on the musl page which is rather vague.
00:32:16 <pikhq> "Straight-up doesn't work" from my experience.
00:32:29 <elliott> pikhq: Then there's only one solution.
00:32:47 <elliott> pikhq: cshore! Or some other hilariously-punny name for a libc.
00:33:00 <pikhq> He's intending to add a bit more locale support in the future.
00:33:09 <elliott> NOT AS MUCH LOCALE SUPPORT AS ME
00:33:20 <pikhq> No non-Unicode locales, though.
00:34:34 <EgoBot> Score for Gregor_lolwut: 0.0
00:34:35 <EgoBot> Score for Gregor_lolwut: 0.0
00:35:10 <elliott> pikhq: FIRST HURDLE: POSIX has no libc-indexed-by-headers page. Rage.
00:36:33 <pikhq> elliott: Anyways, it appears that its performance in implemented features is comparable to libc, but the code size is similar to dietlibc, while implementing more.
00:37:10 <pikhq> And, of course, it's not GPL 2, making it much less of a pain for a system libc.
00:37:29 <elliott> pikhq: It's tempting.
00:38:22 <elliott> pikhq: What I really want is an stdio that doesn't do Stupid Shit.
00:38:39 <pikhq> How so?
00:38:49 <elliott> pikhq: All the existing stdios have ridiculous overhead.
00:39:00 <elliott> It'd be nice to have one that's a simple buffered wrapper over read()/write().
00:39:30 <Sgeo> !bfjoust stolenstrategy (>)*8+<(+)*50<(+)*128<<(+)*128
00:39:50 <EgoBot> Score for Sgeo_stolenstrategy: 0.0
00:40:00 <Sgeo> aww
00:40:25 <pikhq> elliott: I'm looking at musl's libc.
00:40:37 <Sgeo> Why didn't it work against even the dumb ones?
00:40:44 <Sgeo> !bfjoust nop .
00:40:48 <pikhq> elliott: Erm, stdio.
00:40:54 <elliott> Sgeo: Because it never attacks.
00:40:58 <pikhq> elliott: Guess what its stdio is?
00:40:58 <elliott> And there are _no_ dumb ones on the hill.
00:41:07 <elliott> pikhq: Worse than seashore's?
00:41:20 <pikhq> elliott: A simple buffered wrapper over read()/write().
00:41:28 <elliott> pikhq: But hath it unicorns?
00:41:29 <EgoBot> Score for Sgeo_nop: 5.7
00:41:51 <Sgeo> elliott, then explain nop's success
00:41:59 <elliott> Sgeo: Defence programs.
00:42:05 <elliott> Other strange strategies.
00:42:11 <elliott> They're not dumb, they just don't target idiotic programs.
00:42:17 <elliott> See breakdown.txt.
00:42:27 <Sgeo> !bfjoust
00:42:30 <elliott> pikhq: Hmm, doesn't the kernel have a FILE-like structure?
00:42:30 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
00:42:43 -!- BeholdMyGlory has quit (Remote host closed the connection).
00:42:55 <pikhq> elliott: Probably?
00:43:23 <elliott> pikhq: Well, in general it's nicer to export kernel structures than for the libc to define its own, which is why I ask.
00:43:34 <Sgeo> I dn't know what > and < represent
00:43:47 <pikhq> elliott: I doubt it's quite a drop-in replacement, though.
00:44:02 <elliott> Sgeo: > goes closer to opponent, < backwards.
00:44:05 <elliott> *< further away.
00:44:11 <elliott> pikhq: I don't see why not; FILE is opaque.
00:44:18 <Sgeo> elliott, I meant in breakdown
00:44:36 <pikhq> As most of the state in FILE is the userspace buffer...
00:45:35 -!- yiyus has quit (Ping timeout: 240 seconds).
00:47:19 * pikhq kinda wonders why FILE usually has some function pointers in it... Does a stdio actually end up using more than one function in there?
00:47:48 <elliott> pikhq: Heh, pluggable FILEs.
00:48:01 <elliott> "This FILE contains all Fibonacci numbers in decimal, separated by newlines."
00:48:25 <pikhq> Really, if you're going to have that infrastructure in place you might as well expose it.
00:48:27 -!- yiyus has joined.
00:49:11 <pikhq> Aaaah, fmemopen. That at least explains it.
00:49:56 <pikhq> fmemopen, a recent POSIX addition, creates a FILE that accesses a region of memory.
00:50:09 <elliott> pikhq: That's stupid.
00:50:12 <elliott> Nobody needs to support that.
00:50:20 <pikhq> Also, glibc extension.
00:50:21 <elliott> # define TMP_MAX 238328
00:50:21 <elliott> # define FILENAME_MAX 4096
00:50:22 <elliott> glibc: pulling constants out of our ass since ???
00:50:23 <pikhq> (fucking glibc)
00:50:30 <elliott> *limits out of
00:51:52 <pikhq> elliott: I'm not entirely sure there's a reasonable value for either constant.
00:52:16 <Sgeo> !bfjoust win_some_suicide_some (>)*9([-]>)*10
00:52:25 <EgoBot> Score for Sgeo_win_some_suicide_some: 5.9
00:52:35 <elliott> Sgeo: uhh
00:52:38 <elliott> the tape goes up to length 30.
00:52:42 <pikhq> I at least suspect on Linux you could have a filesystem with a filename limit of the entire address space.
00:53:01 <elliott> pikhq: There is.
00:53:02 <Sgeo> If I do 20 attacks, I'll die 19 of them
00:53:11 <elliott> pikhq: The maximum value of a pointer, minus one.
00:53:19 <elliott> pikhq: You could allocate address 1 to the maximum address to store a filename in.
00:53:30 <Sgeo> Wait
00:53:44 <pikhq> elliott: Smart-ass. :P
00:54:39 <Sgeo> !bfjoust win_some_suicide_more (>)*9([-]>)*20
00:54:55 <EgoBot> Score for Sgeo_win_some_suicide_more: 8.0
00:55:21 <elliott> !bfjoust shit_house (>)*11([(-)*128[-]]>)*18
00:55:28 <EgoBot> Score for elliott_shit_house: 12.8
00:55:51 <Sgeo> I guess (-)*128[-] is a more efficient clear most of the time?
00:56:35 <elliott> Sgeo: (-)*128(-.)*-1 -- but only if the cell is actually a flag.
00:56:39 <elliott> Otherwise even with yours you waste 129 flags.
00:58:38 <Sgeo> !bfjoust win_some_suicide_some_elliott_is_clearheaded (>)*9((-)*128(-.)>)*10
00:58:40 <Sgeo> Crud
00:58:43 <Sgeo> That -1 is bad there
00:58:48 <EgoBot> Score for Sgeo_win_some_suicide_some_elliott_is_clearheaded: 0.0
00:58:49 <Sgeo> Realized as I was typing
01:01:50 <elliott> !bfjoust rags (-)*128[(-)*127[(-)*126[(-)*125[(-)*124[(-)*123[(-)*122[(-)*121[(-)*120[(-)*119[(-)*118[(-)*117[(-)*116[(-)*115[(-)*114[(-)*113[(-)*112[(-)*111[(-)*110[(-)*109[(-)*108[(-)*107[(-)*106[(-)*105[(-)*104[(-)*103[(-)*102[(-)*101[(-)*100[(-)*99[(-)*98[(-)*97[(-)*96[(-)*95[(-)*94[(-)*93[(-)*92[(-)*91[(-)*90[(-)*89[(-)*88[(-)*87[(-)*86[(-)*85[(-)*84[(-)*83[(-)*82[(-)*81[(-)*80[(-)*79[(-)*78[(-)*77[(-)*76[(-)*75[(-)*74[(-)*73[(-)*72[(-)*71[(
01:01:51 <elliott> -)*70[(-)*69[(-)*68[(-)*67[(-)*66[(-)*65[(-)*64[(-)*63[(-)*62[(-)*61[(-)*60[(-)*59[(-)*58[(-)*57[(-)*56[(-)*55[(-)*54[(-)*53[(-)*52[(-)*51[(-)*50[(-)*49[(-)*48[(-)*47[(-)*46[(-)*45[(-)*44[(-)*43[(-)*42[(-)*41[(-)*40[(-)*39[(-)*38[(-)*37[(-)*36[(-)*35[(-)*34[(-)*33[(-)*32[(-)*31[(-)*30[(-)*29[(-)*28[(-)*27[(-)*26[(-)*25[(-)*24[(-)*23[(-)*22[(-)*21[(-)*20[(-)*19[(-)*18[(-)*17[(-)*16[(-)*15[(-)*14[(-)*13[(-)*12[(-)*11[(-)*10[(-)*9[(-)*8[(-)*7[(-)*6[
01:01:51 <elliott> (-)*5[(-)*4[(-)*3[(-)*2[-]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
01:01:55 <elliott> Oh dear.
01:01:57 <elliott> !bfjoust rags <
01:01:57 <EgoBot> Score for elliott_rags: 0.0
01:02:12 <EgoBot> Score for elliott_rags: 0.0
01:02:20 <elliott> !bfjoust rags http://sprunge.us/dIhb
01:02:36 <copumpkin> !bfjoust [+]
01:02:37 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
01:02:38 <EgoBot> Score for elliott_rags: 0.4
01:02:42 <copumpkin> !bfjoust shit [+]
01:02:42 <elliott> copumpkin: you forgot the program name
01:02:54 <Sgeo> copumpkin, it will win
01:02:56 <EgoBot> Score for copumpkin_shit: 20.4
01:02:59 <Gregor> !bfjoust diabetic_philip http://sprunge.us/QfTT
01:03:02 <Gregor> WTFWTFWTF
01:03:04 <Sgeo> ...wasnt expecting that big
01:03:10 <EgoBot> Score for Gregor_diabetic_philip: 22.0
01:03:20 <Gregor> Oh, that's still last place for copumpkin_shit :P
01:03:27 <copumpkin> ?
01:03:34 <Gregor> 20.4 points is still last place.
01:03:48 <copumpkin> :(
01:03:53 <copumpkin> elliott: got 0.4
01:04:06 <elliott> lmao
01:04:13 <elliott> almost as good as diabetic philip
01:04:17 <elliott> Gregor: % is broken
01:04:19 <elliott> you moronizer
01:04:22 <elliott> with a z
01:04:31 <elliott> !bfjoust riches http://sprunge.us/XiKW
01:04:39 <EgoBot> Score for elliott_riches: 14.1
01:04:39 <Gregor> elliott: In egojoust it is, yes.
01:04:46 <elliott> Gregor: Which is what you submitted it to.
01:04:49 <Gregor> elliott: WHERE'S LANCE
01:05:00 <elliott> Gregor: NOT BEING DEBUGGED BY YOU
01:05:01 <Gregor> elliott: It's not that broken.
01:05:07 <Gregor> elliott: Only nested ({}) are broken.
01:05:29 <Gregor> elliott: You realize that program is lead_acetate_philip minus the decoys, right?
01:05:41 <elliott> Mr. "lead acetate gregg"
01:06:18 <Sgeo> !bfjoust survive ([]+)*-1
01:06:31 <elliott> Gregor: Gimme two ()*-but-not-{}-or-unbalanced-[]-in-()-using bots where you know one totally thrashes the other.
01:06:37 <elliott> (But not supertrivial ones plz)
01:06:59 <EgoBot> Score for Sgeo_survive: 5.6
01:07:16 <Sgeo> !bfjoust survive2 ([-]+)*-1
01:07:20 <Gregor> elliott: Off the top of my head, Idonno :P
01:07:26 <EgoBot> Score for Sgeo_survive2: 21.8
01:07:30 <elliott> Gregor: You want lance, you cooperate.
01:07:31 <Sgeo> Woohoo!
01:07:35 <elliott> Sgeo: [-]x -- x never executes
01:07:37 <elliott> due to loop semantics
01:07:47 <Sgeo> !bfjoust survive3 ([+]+)*-1
01:07:49 <Sgeo> Hmm?
01:07:57 <Sgeo> elliott, even during attack?
01:08:07 <elliott> -]-]-]-IT BECOMES ZERO]IT DIES
01:08:09 <Gregor> What the hell did mapping_turtle ever beat to get #1 X-D
01:08:31 <elliott> !bfjoust penile_wiggling (-)*127(--++)*-1
01:08:36 <EgoBot> Score for Sgeo_survive3: 19.8
01:08:39 <elliott> (I name all my terrible programs crude things.)
01:08:44 <EgoBot> Score for elliott_penile_wiggling: 9.2
01:08:44 <elliott> Gregor: wat
01:08:49 <elliott> Gregor: It was vibration until recently.
01:08:53 <Gregor> elliott: I was trying to find such a match :P
01:09:01 <Gregor> elliott: To answer your request.
01:09:20 <elliott> Gregor: Not from the current hill.
01:09:25 <elliott> Those programs are waaaay too complex to help me debug.
01:09:45 <Gregor> elliott: Oh. Well then screw youse :P
01:09:45 <Sgeo> elliott, I win supremely against willging peniles
01:09:55 <elliott> Willging peniles.
01:10:13 <Gregor> Sgeo: NOT ACCORDING TO FACEBOOK
01:10:27 <elliott> !bfjoust penile_wiggling (-)*127(--++)*-1(>)*9((-)*128[-]>)*20
01:10:33 <EgoBot> Score for elliott_penile_wiggling: 9.2
01:10:40 <elliott> !bfjoust penile_wiggling (-)*127(--++)*3000(>)*9((-)*128[-]>)*20
01:11:20 <EgoBot> Score for elliott_penile_wiggling: 19.6
01:11:23 <elliott> Impressive.
01:11:54 * Sgeo feels no desire to be impressed by willging anything, despite what Facebook says
01:12:14 <elliott> Sgeo just can't admit his secret desire to wiggle penises all day and night.
01:12:24 <elliott> !bfjoust faster_penile_wiggling (-)*127(--++)*2500(+)*127(>)*9((-)*128>)*20
01:12:30 <EgoBot> Score for elliott_faster_penile_wiggling: 19.3
01:12:33 <Sgeo> elliott is secretly Facebook
01:12:38 <Sgeo> Ok, this joke is getting boring now
01:12:42 <elliott> FASTER PENILE WIGGLING: Actually not as good as slow penile wiggling.
01:20:40 <Gregor> !bfjoust saccharine_philip http://sprunge.us/cAZS
01:20:46 <EgoBot> Score for Gregor_saccharine_philip: 21.3
01:20:58 <Gregor> >_>
01:21:12 <Gregor> Yuh oh, different results from egojsout ...
01:22:09 <Gregor> Nowait
01:22:11 <Gregor> I screwed it up :P
01:23:42 <Gregor> !bfjoust saccharine_philip http://sprunge.us/NcBC
01:23:54 <EgoBot> Score for Gregor_saccharine_philip: 28.1
01:24:38 <Gregor> !bfjoust saccharine_philip <
01:24:45 <Sgeo> What happened to FYB?
01:24:54 <Gregor> Sgeo: Apparently it's just not cool enough :P
01:25:04 <EgoBot> Score for Gregor_saccharine_philip: 0.0
01:26:29 <elliott> It's broken.
01:26:39 <elliott> In oh so many ways :P
01:26:48 <Sgeo> elliott, hmm?
01:26:57 <elliott> Exactly that.
01:29:06 <Sgeo> !fyb +[{}+]
01:29:06 <EgoBot> Use: !fyb <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/fyb/
01:29:15 <Sgeo> !fyb somewhat_dumb +[{}+!]
01:30:19 <EgoBot> Score for Sgeo_somewhat_dumb: 7.6
01:30:30 <elliott> Sgeo: It's broken in that it's too easy unintentionally.
01:30:34 <elliott> @@ puts you at your opponent's IP IIRC.
01:30:35 <lambdabot>  puts you at your opponent's IP IIRC.
01:30:37 <elliott> Basically it's abandoned.
01:30:51 <elliott> !bfjoust slow_idiot (>)*9((-)*128>)*20
01:31:03 <EgoBot> Score for elliott_slow_idiot: 0.0
01:31:22 <Sgeo> !fyb [@@[-]++++++++++++++!]
01:31:23 <EgoBot> Use: !fyb <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/fyb/
01:31:29 <Sgeo> !fyb easy_seek [@@[-]++++++++++++++!]
01:31:40 <EgoBot> Score for Sgeo_easy_seek: 5.1
01:32:05 <Sgeo> Well, that's interesting in that it's worse than somewhat_dub
01:32:06 <Sgeo> sumb
01:32:28 <Sgeo> It won against nothing
01:33:53 <elliott> Gregor: NEED WARRIORS TO TEST
01:35:50 <Sgeo> !bfjoust x_squared_plus_y_squared [[-]-]
01:36:11 <EgoBot> Score for Sgeo_x_squared_plus_y_squared: 20.4
01:36:17 <Sgeo> ooh
01:36:28 <pikhq> "Currently, CEOs of major U.S. companies average 263 times the average compensation of American workers."
01:37:21 <copumpkin> they clearly work 263 times harder
01:37:37 <Sgeo> Deewiant_monorail.bfjoust vs Sgeo_x_squared_plus_y_squared.bfjoust:
01:37:43 <Sgeo> XXXXXXXXXXXXXXXXXXXXX <X<X<X<X<X<X<X<X<X<X< <X<X<X<X<X<X<X<X<X<X< XXXXXXXXXXXXXXXXXXXXX
01:38:05 <Sgeo> What does each position represent, exactly?
01:38:09 <pikhq> copumpkin: At screwing people, perhaps.
01:38:16 <Sgeo> vPatashu_rushpolarity.bfjoust vs Sgeo_x_squared_plus_y_squared.bfjoust:
01:38:17 <Sgeo> XX<XXX<XXX<<<<<<<<<<< X<XXX<XXX<<<<<<<<<<<< X<XXX<XXX<<<<<<<<<<<< XX<XXX<XXX<<<<<<<<<<<
01:38:17 <Gregor> !bfjoust saccharin_philip http://sprunge.us/VGGO
01:38:19 <copumpkin> pikhq: OMG COMMIE
01:38:28 <EgoBot> Score for Gregor_saccharin_philip: 18.1
01:38:41 <Gregor> Wow, really?
01:38:49 <iconmaster> !fyb dumb_lightspeed %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%[>+]%%%%%%%%%%%%%%%%%%
01:38:49 <iconmaster> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
01:38:58 <Deewiant> Sgeo: Four groups, one for each polarity; and one <>X per tape length
01:39:06 <Sgeo> Ah
01:39:07 <pikhq> copumpkin: ALL HAIL MARX
01:39:13 <elliott> Deewiant: There are only two polarities :P
01:39:21 <EgoBot> Score for iconmaster_dumb_lightspeed: 5.1
01:39:24 <Gregor> lol, I have made the most specialized program EVER.
01:39:26 <Deewiant> elliott: Well what's the term for the +- pair :-P
01:39:35 <Gregor> saccharin_philip beats the top three and almost nothing else :P
01:39:39 <Deewiant> Unless you just meant egojoust's extra two modes
01:39:45 <elliott> Deewiant: Precisely
01:39:52 <elliott> Deewiant: There are two polarities, ++ (sieve) and +- (kettle).
01:39:58 <elliott> EgoBot runs them both twice for no reason :P
01:40:14 <iconmaster> !fyb working_dumb_lightspeed %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%[>+++!]%%%%%%%
01:40:14 <iconmaster> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
01:40:25 <elliott> iconmaster: Dude, you can't send a program over two lines.
01:40:29 <elliott> iconmaster: Put it on a pastebin and give it the URL.
01:40:32 <elliott> :P
01:40:41 <iconmaster> oh. I'm nooby, arn't I?
01:40:42 <Sgeo> What's % again?
01:40:45 <EgoBot> Score for iconmaster_working_dumb_lightspeed: 5.1
01:40:56 <iconmaster> This would be why my fyb progs fail.
01:42:09 <quintopia> wot happened
01:42:17 <iconmaster> !fyb lets_see http://pastebin.com/WQddVGT1
01:42:22 <EgoBot> Score for iconmaster_lets_see: 5.1
01:42:34 <iconmaster> Wow, it failed worse.
01:42:46 <Deewiant> pastebin.com is a bad idea, that's HTML
01:42:49 <Sgeo> "NOTE: You cannot set a bomb in your own program, so it doesn't have a character."
01:43:25 <Sgeo> !fyb self_bombing @[>]++++++++++++++!
01:43:29 <iconmaster> i figgured it out
01:43:29 <EgoBot> Score for Sgeo_self_bombing: 5.1
01:43:33 <Sgeo> ....
01:43:41 <iconmaster> !fyb lightspeed http://pastebin.com/raw.php?i=WQddVGT1
01:43:44 <EgoBot> Score for iconmaster_lightspeed: 5.1
01:43:52 <iconmaster> Okay, i suck at FYB.
01:43:58 <iconmaster> Im learning
01:44:00 <Sgeo> !fyb diediedie <
01:44:21 <Sgeo> What.
01:44:40 <EgoBot> Score for Sgeo_diediedie: 4.9
01:45:52 <Sgeo> !fyb better_self_bomb [@------!]
01:46:00 <Sgeo> Erm, hmm
01:46:02 <EgoBot> Score for Sgeo_better_self_bomb: 5.1
01:46:15 <elliott> iconmaster: That won't work.
01:46:21 <elliott> That page is HTML.
01:46:25 <Deewiant> iconmaster: That raw.php is also HTML, pastebin.com sucks.
01:46:25 <elliott> So your program starts with <!DOCTYPE.
01:46:27 <Sgeo> !fyb better_self_bomb_how_does_selfmod_work [@>--!]
01:46:36 <EgoBot> Score for Sgeo_better_self_bomb_how_does_selfmod_work: 6.6
01:46:37 <elliott> Try sprunge.us :P
01:46:41 <Sgeo> lolwat
01:46:47 <Sgeo> pastie.org works well
01:47:17 <Sgeo> Why can't I bomb myself?!
01:47:22 <iconmaster> !fyb total_fail http://pastie.org/1557853
01:47:29 <EgoBot> Score for iconmaster_total_fail: 0.0
01:47:43 <iconmaster> 0_0
01:47:51 <elliott> That is also HTML.
01:48:06 <elliott> And before you try it, so is http://pastie.org/pastes/1557853/text. :p
01:48:12 <Sgeo> Where's the raw link?
01:48:14 <iconmaster> Awwwwww.
01:48:23 <elliott> sprunge.us, man.
01:48:25 * Sgeo angers at pastie.org
01:48:42 * iconmaster is wondering if hell ever find a non-HTML paste
01:49:23 -!- rodgort has quit (Quit: Coyote finally caught me).
01:49:32 * iconmaster is using windows, the silly man.
01:49:42 <Sgeo> iconmaster, try ideone.com
01:49:50 <iconmaster> This is getting silly.
01:49:52 <Sgeo> Copy the download link's URI
01:49:55 -!- rodgort has joined.
01:50:10 <Sgeo> Or hmm
01:50:44 <elliott> You can use curl in Windows.
01:50:48 <elliott> *on Windows.
01:51:09 <Sgeo> If not ideone.com, try codepad.org
01:51:32 <iconmaster> ok...
01:51:42 <iconmaster> !fyb almost_rage http://ideone.com/plain/o4yiw
01:51:57 <elliott> That, finally, is not HTML.
01:52:01 <iconmaster> FINALLY!
01:52:09 <iconmaster> Took me long 'Nuff.
01:52:11 <EgoBot> Score for iconmaster_almost_rage: 5.1
01:52:19 <Sgeo> elliott, it seems to alter the URL
01:52:21 <elliott> Aaaaand it got just as good a score.
01:52:26 <elliott> Sgeo: Oh.
01:52:31 <Sgeo> I can't tell
01:52:44 <elliott> iconmaster: <form action="http://sprunge.us" method=post><textarea name=sprunge></textarea><input type=submit></form
01:52:46 <elliott> *form>
01:52:48 <elliott> save as sprunge.html
01:52:49 <elliott> open
01:52:51 <elliott> paste stuff in
01:52:52 <elliott> press submit
01:52:53 <elliott> get url
01:53:24 <Sgeo> elliott, feel like checking to see what happens?
01:53:33 <elliott> It will work.
01:53:52 <Sgeo> I meant the ideone.com
01:54:17 <elliott> Oh.
01:54:19 <elliott> No, I'm too lazy.
01:54:31 <Sgeo> And PuTTY just closed on me
01:54:55 <Gregor> It is almost unbelievable that pastebin.com "raw" mode is HTML X_X
01:54:58 <Gregor> That is so far beyond stupid.
01:55:36 <iconmaster> !fyb lightspeed_n_repair http://ideone.com/plain/Pwce4
01:55:37 <elliott> And pastie's. And ...
01:55:39 <EgoBot> Score for iconmaster_lightspeed_n_repair: 5.1
01:55:46 <elliott> iconmaster: yeah, that won't work
01:55:49 <elliott> <form action="http://sprunge.us" method=post><textarea name=sprunge></textarea><input type=submit></form>
01:55:52 <elliott> save locally as sprunge.html :P
01:56:00 <iconmaster> k
01:56:08 <Sgeo> GET /plain/Pwce4 HTTP/1.1
01:56:08 <Sgeo> Host: ideone.com
01:56:12 <Sgeo> What's wrong with that/
01:56:23 <elliott> Well they're all getting the same scores as the broken ones.
01:56:37 <elliott> The Content-Disposition might conceivably be confusing EgoBot.
01:57:34 <iconmaster> !fyb im_silly http://sprunge.us/DJAF
01:57:38 <EgoBot> Score for iconmaster_im_silly: 5.1
01:57:47 <iconmaster> ...
01:57:48 <Sgeo> Let's try with known-good programs
01:57:51 <iconmaster> ok
01:58:23 <iconmaster> !fyb well_known  http://sprunge.us/WCYC
01:58:26 <EgoBot> Score for iconmaster_well_known: 5.1
01:58:56 <iconmaster> my test was :{>}[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+]]]]]]]]]]]]]]]+++++++++++++!>%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
01:58:56 <iconmaster> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%;
01:58:56 <iconmaster> :@[>+++]!;*
01:59:15 <elliott> Gregor: Does it actually load URLs?
01:59:31 <Gregor> elliott: Probably? :P
01:59:36 <elliott> Gregor: You sure?
01:59:39 <elliott> They're all getting score 5.1.
01:59:44 <elliott> Including known-good ones.
01:59:59 <iconmaster> !fyb might_work [>+++]!
02:00:02 <EgoBot> Score for iconmaster_might_work: 5.1
02:00:06 <iconmaster> o wait
02:00:20 <iconmaster> !fyb lol [>+++!]
02:00:21 <Gregor> Yeah, I think !fyb might be borkleborked :P
02:00:22 * Gregor checks it out
02:00:23 <EgoBot> Score for iconmaster_lol: 5.1
02:00:40 <iconmaster> !fyb AAAAAA {}+!
02:01:16 <elliott> !fyb FACES >>>>>>>>>>>>>!
02:01:18 <Gregor> STOP
02:01:22 <iconmaster> !fyb orly %
02:01:24 <iconmaster> o orry
02:01:47 <elliott> !fyb STOP STOP STOP
02:02:11 <iconmaster> !fyb lol %[>]!
02:02:11 <EgoBot> STOP
02:02:17 <iconmaster> lol?
02:02:35 <iconmaster> !bfjoust >>>
02:02:35 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
02:02:43 <iconmaster> !bfhoust mine >>>
02:02:50 <iconmaster> argh spam fail
02:03:09 <iconmaster> ok ill stop now.
02:03:30 <EgoBot> Score for iconmaster_AAAAAA: 4.4
02:03:31 <EgoBot> Score for elliott_STOP: 4.4
02:03:31 <EgoBot> Score for elliott_FACES: 4.4
02:03:31 <EgoBot> Score for iconmaster_orly: 4.4
02:03:34 <iconmaster> lol
02:04:37 <iconmaster> !help ul
02:04:37 <EgoBot> Sorry, I have no help for ul!
02:04:44 <iconmaster> !help
02:04:45 <EgoBot> help: General commands: !help, !info, !bf_txtgen. See also !help languages, !help userinterps. You can get help on some commands by typing !help <command>.
02:04:57 <iconmaster> !help languages
02:04:57 <EgoBot> languages: Esoteric: 1l 2l adjust asm axo bch befunge befunge98 bf bf8 bf16 bf32 boolfuck cintercal clcintercal dimensifuck glass glypho haskell kipple lambda lazyk linguine malbolge pbrain perl qbf rail rhotor sadol sceql trigger udage01 underload unlambda whirl. Competitive: bfjoust fyb. Other: asm c cxx forth sh.
02:05:48 <iconmaster> !underload (hello)(::S^):^
02:06:00 <iconmaster> Aaah... random fun.
02:09:52 * iconmaster wonders if anyone is alive
02:09:59 <iconmaster> I know I'M not
02:10:10 <elliott> i'm not
02:10:34 <iconmaster> yay- so we can be not alive TOGETHER!
02:10:42 <iconmaster> so... is EgoBot really broken?
02:11:50 <elliott> Only FYB.
02:12:09 <iconmaster> well thats too bad...
02:12:33 <iconmaster> Anyhow, wanna hear of an (arguably) esoteric lang I made?
02:12:48 <Sgeo> Sure
02:12:58 <iconmaster> It combines DOS with RPL for some reason.
02:13:06 <iconmaster> its called RPOS
02:13:09 <iconmaster> http://codepad.org/W9NgsZvP
02:13:57 <iconmaster> Theoretically, i could remake it in asm and ship it as an os somehow later.
02:14:42 <iconmaster> It's probably Turing-complete. No proof yet.
02:15:05 <elliott> I don't see any way to loop.
02:15:17 <iconmaster> the 'while' command?
02:15:23 <elliott> Oh, that would do it.
02:15:50 <iconmaster> Prefixes really make it unique. And the way you construct strings.
02:15:56 <elliott> iconmaster: Can you do an if statement?
02:15:59 <elliott> e.g. while and then break out.
02:16:00 <iconmaster> yes
02:16:05 <elliott> Numbers have unbounded range?
02:16:09 <elliott> I don't know if Lua does bignums.
02:16:12 <iconmaster> yep
02:16:44 <elliott> Then yeah, it's TC :P
02:17:13 <iconmaster> 1 dup dup ?'1 ?"'hi_disp ?while is a condition while loop!
02:17:19 <Sgeo> Is Lua more TC than C?
02:17:38 <iconmaster> I <3 Lua. That's all I can say.
02:17:52 <elliott> I hate Lua, yay
02:17:54 <elliott> BUDDIES
02:17:56 <elliott> *BUDDIEZ
02:18:42 <iconmaster> I'm so glad I stopped doing all my Lua in ROBLOX. It's really a child's game.
02:19:06 <Sgeo> I was consdiering playing with ROBLOX
02:19:08 <elliott> THAT'S CAUSE LUA'S A CHILD'S LANGAGE hahaha okay i'll stop.
02:19:15 <iconmaster> lulz
02:19:23 <Sgeo> *consdirder
02:19:27 <Sgeo> *considering
02:19:33 <elliott> *fujnxclvdknffoksdpgm
02:19:39 <elliott> *z<zcvxbhjgu;'tyg
02:19:40 <elliott> *)A(u43e568
02:19:42 <iconmaster> I like it cuz it's a small, clean language that's (relatively) fast.
02:19:57 <elliott> Lua isn't very fast, the VM isn't exactly efficient.
02:20:08 <elliott> And the arrays are hash tables and therefore not exactly very fast, and every value is boxed.
02:20:15 <elliott> Calling it fast is a bit of a stretch :P
02:20:19 <iconmaster> Nope, but better than Ruby (my old lang) in many cases
02:20:41 <elliott> Well yah, going from Ruby everything is fast. and non-shitty. :P
02:20:50 <iconmaster> Correct.
02:21:03 <elliott> Meanwhile HASKELL, for ADULTS
02:21:06 <iconmaster> I didn't really like object-orientedness either.
02:21:08 <Sgeo> elliott, do you like or hate Ruby? You certainly use it
02:21:12 <elliott> , he says, debugging broken C code.
02:21:18 <elliott> Sgeo: It has a convenient socket API :P
02:21:30 <Sgeo> Write a convenient socket API for Haskell then
02:21:40 <iconmaster> I like Lua because object-oreintedness is light, but there when you need it, also.
02:21:51 <elliott> Haskell's socket API is fine :P
02:22:20 <iconmaster> I went to the Haskell demo earlier, and it is pretty nice, but confising in places.
02:22:44 <elliott> It's the most confising language there is.
02:23:03 <iconmaster> Other than esolangs? or > than?
02:23:09 <elliott> iconmaster: The problem is that accessible Haskell code looks like not much special, and Haskell code that showcases its strengths are completely incomprehensible to people not experienced with functional programming :P
02:23:17 <Sgeo> iconmaster, he was just making fun of your typo code
02:23:20 <elliott> Also, I was just reappropriating your typo as the best adjective.
02:23:20 <Sgeo> typo code wtf
02:23:28 <elliott> Typo code wat
02:23:28 <iconmaster> lol
02:23:40 <iconmaster> Typo code wut
02:23:49 <iconmaster> Type code ...
02:23:55 <iconmaster> AGH!
02:24:29 <Sgeo> typo/type typo code
02:24:57 <elliott> Topo code.
02:25:01 <elliott> It's code to do with topology.
02:25:01 <Gregor> !fyb borklebork :{>}[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+]]]]]]]]]]]]]]]+++++++++++++!>%%%%%%%%%%%%%%%%%
02:25:05 <EgoBot> Score for Gregor_borklebork: 0.0
02:25:10 <iconmaster> I have a 100-page notebook almost filled with commands for Onecode. Remeber Onecode? Not really? Its ok.
02:25:16 <Sgeo> Lowest score code yet!
02:25:22 <Gregor> Yessssssssssss
02:25:24 <Gregor> But it is working :P
02:25:29 <iconmaster> Lets get code with negative score!
02:25:41 <Sgeo> negative code
02:26:02 <iconmaster> @[+!>]
02:26:02 <lambdabot> Unknown command, try @list
02:26:07 <iconmaster> ?
02:26:11 <iconmaster> o lol
02:26:17 <Sgeo> !fyb code
02:26:17 <EgoBot> Use: !fyb <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/fyb/
02:26:24 <Sgeo> !fyb name code
02:26:40 <iconmaster> !fyb fail_sauce @[+!>]
02:27:32 <EgoBot> Score for Sgeo_name: 0.0
02:27:44 <EgoBot> Score for iconmaster_fail_sauce: 12.7
02:27:48 <iconmaster> OMG
02:27:59 <iconmaster> ???
02:28:04 <Sgeo> ...doesn't that edit your own code?
02:28:13 <iconmaster> yes, it does.
02:28:23 <Sgeo> So, what does that code become?
02:28:27 <iconmaster> idk
02:29:03 <elliott> Gregor: Make x86Joust.
02:29:04 <elliott> DO EET
02:29:44 <iconmaster> I wish there was a FYB program debugger.
02:30:00 <iconmaster> Id like to see what got my code a 12
02:30:06 <quintopia> so, what's happened with lance while i was away?
02:30:16 <Sgeo> quintopia, you got lanced.
02:30:33 <elliott> quintopia: still on stupid fucking bug
02:30:44 <elliott> quintopia: need simple but non-trivial warriors that use ()*, preferably nested, but no unbalanced [] in (), and no ()%
02:30:50 <elliott> preferably two that are closely matched
02:30:53 <Sgeo> Why non-trivial?
02:30:56 <elliott> to debug
02:31:44 <iconmaster> !fyb fail_2 @[[+++!>>]+]
02:32:26 <EgoBot> Score for iconmaster_fail_2: 0.0
02:32:35 <Sgeo> Where doe @ put the IP?
02:32:38 <iconmaster> !fyb fail_1 @[+!>]
02:33:07 <EgoBot> Score for iconmaster_fail_1: 12.0
02:33:15 <iconmaster> I have failed at failing.
02:34:13 <quintopia> elliott: ais523_speedy2.bfjoust
02:34:22 <elliott> quintopia: and the other?
02:34:42 <quintopia> Deewiant_maglev.bfjoust
02:34:58 <quintopia> actually
02:35:01 <iconmaster> !fyb fail_cuz_html http://esolangs.org/files/fyb/src/logicex-2.fyb
02:35:03 <quintopia> they aren't closely matched
02:35:05 <EgoBot> Score for iconmaster_fail_cuz_html: 28.5
02:35:07 <quintopia> maglev kicks ass
02:35:09 <iconmaster> !!!
02:35:19 <iconmaster> o wait... i see...
02:35:19 <elliott> that's not html
02:35:20 <elliott> obvs
02:35:30 <elliott> quintopia: well okay
02:35:31 <elliott> !bfjoust
02:35:31 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
02:35:35 <quintopia> elliott: maglev vs. monorail is decent
02:35:35 <iconmaster> i see now! the () were commants, i forgot
02:35:50 <elliott> what about monorail vs speed.y2
02:35:52 <elliott> *speedy2
02:36:08 <quintopia> speedy kills everytime
02:36:16 <iconmaster> !fyb fail_AGAIN @[+!>]
02:36:24 <elliott> quintopia: $ ./lance '(>+>-)*4(>[(-)*9[+]])*21' '>>>>>>>>(>[-[++[---]]])*21'
02:36:24 <elliott> Sieve:  >>>>>>>>>>>>>>>>>>>>>
02:36:24 <elliott> Kettle: >>>>>>>>>>>>>>>>>>>><
02:36:24 <elliott> Right wins (40)
02:36:26 <elliott> quintopia: _every_ time?
02:36:30 <EgoBot> Score for iconmaster_fail_AGAIN: 10.8
02:36:35 <iconmaster> comparin fail to logicex
02:36:46 <iconmaster> my scoar went down
02:36:51 <elliott> gah indeed, every time
02:36:51 <quintopia> elliott: none of these have nested ()* unfortunately
02:36:52 <elliott> so i have a bug
02:37:02 <elliott> it's ok, bug triggered
02:37:58 <iconmaster> !fyb orly @+[-[>?]+]
02:38:08 <EgoBot> Score for iconmaster_orly: 0.5
02:38:17 <iconmaster> woot! half a point
02:38:45 <elliott> ooh an OFF-BY-WAN
02:38:49 <elliott> off-by-obi-wan
02:39:05 <Sgeo> Off by obi-wan typo code
02:39:33 <quintopia> gah, i just came up with the awesomest defend idea ever, but i know it'll be just about the longest bfj program ever written >_>
02:39:38 <Sgeo> Sgeo, murderer of jokes.
02:39:43 * iconmaster gotsa go.
02:39:49 <Sgeo> Bye iconmaster
02:39:50 -!- iconmaster has quit (Quit: bye).
02:40:01 <Sgeo> quintopia, do it, do it, do looks like a lady
02:40:18 <quintopia> in fact
02:40:32 <quintopia> it'd be the very same hybrid elliott was early postulating the existence of
02:40:41 <elliott> quintopia: generate it with a program
02:40:48 <quintopia> the one i suggested would be impossible >_>
02:40:58 <Sgeo> What hybrid?
02:40:58 <elliott> quintopia: see, this is why i no longer call things impossible in bfj :P
02:41:17 <Sgeo> elliott, losing against <
02:41:20 <elliott> Sgeo: a program which, when it starts, looks at what its opponent is doing, and then decides whether to defend or attack
02:41:26 <quintopia> elliott: if it turns out my idea works, i'll let you say you told me so
02:41:26 <Sgeo> Ooh
02:41:28 <elliott> and also after a long time of defending goes to attack, etc.
02:42:51 <Sgeo> Why did quintopia think it impossible?
02:43:42 <elliott> Sgeo: because this stuff usually does seem impossible :)
02:43:47 <quintopia> my exact words were "elliott: but figuring out what an opponent is going to do while it is still building its own decoys is impossible"
02:43:51 <elliott> Sgeo: when bf joust was young i didn't believe a defender was possible
02:43:55 <Sgeo> I think I should make a BFJoust decompiler, make BFJoust code into something readable
02:43:57 <quintopia> which i still hold is impossible
02:44:06 <elliott> That would be impossible... it's readable enough anyway
02:44:08 <elliott> quintopia: of course, i agree
02:44:16 <elliott> quintopia: but you could always keep checking to see if it's finished decoy-building
02:44:34 <quintopia> elliott: well
02:44:38 <quintopia> what i can do
02:44:48 <quintopia> is determine *whether it builds decoys at all*
02:44:52 <quintopia> and react accordingly :P
02:45:30 <quintopia> i'll rush the ones that build large decoys, and defend the ones that rush without decoying
02:53:19 <Sgeo> !bfjoust alt_decoy >-<+>-<+>-<+>-<+>-
02:53:29 <zzo38> TeXnicard can now make PBM files correctly. Is this good?
02:55:28 <Sgeo> Is EgoBot alive?
02:56:06 <elliott> check the fucking breakdown before asking that :P
02:56:38 <Sgeo> o.O at Julius Freezer
02:57:55 <EgoBot> Score for Sgeo_alt_decoy: 7.8
02:58:37 <Sgeo> If I get mostly Xs but one <, do I win against that program?
02:58:38 -!- kwertii has joined.
02:58:46 <Sgeo> Well, 4 <, one in each polarity
02:59:08 <quintopia> Gregor: i have a small request for egojsout.
02:59:10 <elliott> Uhh, I do believe > is you winning.
02:59:15 <Gregor> quintopia: ?
02:59:15 <Sgeo> !bfjoust alt_decoy_w_tiebreaker >-<+>-<+>-<+>-<+>(-)*128
02:59:16 <elliott> At best you'll get a tie.
02:59:21 <elliott> But no, one loss = lose.
02:59:26 <EgoBot> Score for Sgeo_alt_decoy_w_tiebreaker: 7.8
02:59:56 <Sgeo> !bfjoust alt_decoy_w_tiebreaker2 >-<+>-<+>-<+>-<+>>(-)*128
03:00:24 <Sgeo> elliott, you got it backwards
03:00:47 <Sgeo> Aww my tiebreaker breaks no ties
03:00:54 <EgoBot> Score for Sgeo_alt_decoy_w_tiebreaker2: 5.8
03:01:08 <Sgeo> !bfjoust die_sometimes (>)*15
03:01:17 <quintopia> Gregor: can you make it take the search parameters from the location/address to automatically select a) the first opponent b) the second opponent c) a particular match by tape length and polarity (go ahead and run it if specified) and d) a range of cycles (only display that range of cycles if selected)?
03:01:18 <EgoBot> Score for Sgeo_die_sometimes: 2.4
03:02:05 <Sgeo> Thanks quintopia, for lettimg me time sometimes
03:02:09 <Sgeo> tie typeo code
03:02:34 <elliott> quintopia: what
03:02:42 <quintopia> Sgeo: you're...welcome?
03:03:51 <Sgeo> Check out breakdown.txt
03:03:53 <quintopia> Gregor: the first and second opponent should be specifiable either as program names from the hill, external files, or bf code directly
03:04:10 <Sgeo> quintopia, BFJoust code is not BF code
03:04:11 <Sgeo> >.>
03:04:14 <Gregor> External files = big no go
03:04:22 <elliott> what is Gregor talking about
03:04:24 <elliott> make _what_ take what
03:04:32 <Gregor> <quintopia> Gregor: can you make it take the search parameters from the location/address to automatically select a) the first opponent b) the second opponent c) a particular match by tape length and polarity (go ahead and run it if specified) and d) a range of cycles (only display that range of cycles if selected)? // I have no idea what you mean by this
03:04:37 <quintopia> Gregor: well then just the hill and the bf code then
03:04:38 <elliott> i think he means modifying egojoust
03:04:41 <quintopia> no
03:04:44 <quintopia> egojsout
03:04:47 <elliott> which is uhh the stupidest thing at this point considering lance is like only blocked on ten horrible bugs
03:04:54 <quintopia> hence encoding the params in the address
03:04:58 <Gregor> quintopia: That's what it already does :P
03:05:09 <quintopia> Gregor: then what's the param names?
03:05:19 <elliott> ( -- push 3
03:05:21 <quintopia> Sgeo: you mean shudder?
03:05:23 <elliott> RUN (run 1ce)
03:05:25 <Sgeo> Yesh
03:05:27 <elliott> ) -- make it 2
03:05:28 <quintopia> lul
03:05:30 <elliott> RUN (run 2ce)
03:05:32 <Gregor> quintopia: OH, you mean you want to be able to do it via query parameters?
03:05:34 <elliott> ) -- make it 1
03:05:36 <elliott> RUN (run 1ce)
03:05:39 <elliott> ) -- whoops it's zero stop
03:05:42 <elliott> okay so that runs thricery
03:05:43 <quintopia> Gregor: yes .html?param=etc
03:05:51 <Gregor> quintopia: Doesn't seem all that useful :P
03:06:01 <elliott> I think quintopia is trying to automate his program generation
03:06:06 <elliott> Whereas, you know, man up and write some code, jeez.
03:06:15 <quintopia> Gregor: it is very useful for linking people to certain parts of certain games to look at them
03:06:24 <quintopia> rather than pasting 10 lines into the channel
03:06:28 <elliott> oh please :P
03:06:31 <elliott> just tell us what line to scroll down to
03:06:34 <elliott> they're numbered!
03:06:43 <Gregor> quintopia: Except if anything changes on the hill, that link goes stale quick ...
03:06:50 <quintopia> exactly
03:06:52 <quintopia> so what?
03:07:01 <quintopia> it's for people to look at *right now*
03:07:14 <quintopia> also, bf code directly in the address...
03:08:00 <quintopia> (i know how lazy people are, elliott. telling them to run a certain match, pick a certain game, and scroll down to a certain line is bound to make them roll their eyes and go somewhere else)
03:08:13 <elliott> quintopia: People in here would do it
03:08:21 <elliott> People not in here who want to play BF Joust should get in here
03:08:21 <quintopia> iunno
03:08:33 <elliott> People without the patience to click a few times... have ADHD and will suck at BF Joust :P
03:08:39 <elliott> Or at least care sufficiently little that they'll suck.
03:08:45 <quintopia> perhaps
03:09:08 <quintopia> is it so wrong to ask for small conveniences?
03:09:29 <elliott> Welllll, it's a non-trivial amount of coding work for very little aid :P
03:09:46 <elliott> This channel, like all channels, is based on not wanting to do work, and that's what we do.
03:10:30 <quintopia> well, Gregor can of course say "no"...i asked whether it was okay to ask, and i think it is
03:10:40 <elliott> No, we'll punch you if you ask that.
03:11:45 <quintopia> you mean you'll serve me punch and some biscotti
03:11:54 <Gregor> quintopia: If the code is directly in the address, then the link will be super-long :P
03:12:30 <quintopia> Gregor: well i did ask for external files too :/
03:12:35 <elliott> integrate it with an ajax 2.0 url reduckter
03:12:49 <Gregor> quintopia: That simply cannot be done, SOP makes it impossible.
03:13:00 <Gregor> Well yeah, I could redirect, but yukk.
03:13:10 <elliott> I think he means like
03:13:11 <elliott> upload a file
03:13:13 <elliott> which is just
03:13:13 <elliott> :no:
03:13:18 <quintopia> Gregor: compressed BF programs! automatically generated for you by bfjsout!
03:13:19 <quintopia> :P
03:13:30 <elliott> man we're like
03:13:32 <elliott> staring at you
03:13:35 <elliott> with the talking
03:13:43 <quintopia> oops
03:13:43 <quintopia> sorry
03:13:47 <quintopia> egojsout
03:13:53 <quintopia> MY BRAIN FAILS AGAIN
03:13:54 <elliott> no no no that is not the problem
03:14:20 <elliott> your words they're just
03:14:24 <elliott> STOP IT
03:14:36 <quintopia> stopping using words?
03:14:45 <elliott> yes.
03:14:46 <elliott> for now.
03:14:50 <quintopia> jung gur shpx fubhyq v hfr vafgrnq?
03:15:05 <elliott> Gregor: tell him about the words that he stops
03:15:33 <quintopia> Tertbe pbhyq whfg fnl ab...
03:15:49 <Gregor> I'm just waiting for you two to stop arguing :P
03:16:00 <elliott> Gregor: i'm not the hostilearguing
03:16:03 <elliott> i'm just of the talking.
03:16:09 <elliott> people should stop talking.
03:16:13 <elliott> it's immoral
03:16:26 <quintopia> V'z qbar nethvat Tertbe! lbh pna tb nurnq naq fnl "ab" be "lrf" abj! be lbh pna whfg qb vg naq fnl "v qvq vg!"
03:20:06 <Gregor> http://pdf.buildasign.com/Proof.ashx?tcid=6F53517063557A6B4C5135386C69455679474D7874413D3D&width=700&height=450&watermark=false&r=1297568559945
03:21:27 <quintopia> what does that tcid encode?
03:23:31 <Gregor> How the hell should I know.
03:24:52 <elliott> CAUTION
03:24:57 <elliott> I AM SOMEWHAT SPARTA
03:26:01 <Sgeo> What is rushpolarity?
03:26:32 <elliott> Sgeo: One of myndzi's rushes with swapped + and - I think :P
03:26:38 <elliott> Is it still there?
03:26:49 <Sgeo> Its still fought against in breakdown
03:27:19 <elliott> *It's
03:27:21 <elliott> So yes then
03:29:37 <Sgeo> When were the polarity rules added?
03:32:50 <Sgeo> ais523_defend12.bfjoust vs quintopia_poke.bfjoust:
03:32:50 <Sgeo> <<<<<<<<<<<<>>>>>>>>> <>>>>>>>>>>>>>>>>>>>> <>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<>>>>>>>>>
03:33:03 <Sgeo> What was your name for ++ polarity?
03:33:12 <elliott> sieve
03:33:22 <Sgeo> So it's Sieve Kettle Kettle Sieve
03:33:27 <elliott> polarity was added ages ago
03:33:49 <Sgeo> I'm going to guess internally ++ +- -+ --
03:34:04 <Sgeo> Source Antisource is easier to remember, realy
03:34:05 <Sgeo> really
03:34:09 <quintopia> no
03:34:15 <quintopia> sieve and kettle
03:34:16 <quintopia> ftw
03:34:32 -!- poiuy_qwert has joined.
03:36:24 <Sgeo> Iea: BF Joust program that knows one particular opponent, and against that opponent, can determine whether it's Sieve or Kettle polarity
03:42:08 <quintopia> sounds REALLY EASY
03:42:52 <quintopia> defend12 can actually determine the polarity of several different opponents
03:43:16 <quintopia> pretty much any rusher that uses offset clears
03:46:26 <elliott> yeah, sieve and kettle
03:46:31 <elliott> they've always been called that
03:47:07 <quintopia> Sgeo: ALWAYS
03:50:02 <copumpkin> pikhq: http://www.9to5mac.com/51776/geohot-raps-a-message-to-sony?utm_source=feedburner&utm_medium=twitter&utm_campaign=Feed:+9To5Mac-MacAllDay+(9+to+5+Mac+-+Apple+Intelligence)
03:52:09 <elliott> copumpkin: lolwat
03:52:42 <elliott> copumpkin: i have two simultaneous thoughts
03:52:50 <elliott> copumpkin: (1) oh my god he is an obnoxious douchebag (2) I LOVE HIM
03:54:06 <Sgeo> offset clears?
03:56:09 <elliott> Sgeo: the mostest important strategem in all capert
04:00:11 <quintopia> that is awesome
04:00:13 <quintopia> also
04:00:22 <quintopia> his room is way to clean to be a hacker's room
04:00:26 <quintopia> *too
04:05:22 <pikhq> copumpkin: ... Wow.
04:05:51 <copumpkin> I thought you might like it
04:12:08 <Sgeo> When do the MPEG-LA patents expire?
04:22:13 <pikhq> Sgeo: Anywhere from next year to 20 years from now, depending.
04:22:38 <Sgeo> pikhq, as in, you don't know, or the world doesn't know?
04:23:11 <pikhq> Sgeo: As in "Seriously, that's the full range for patents in MPEG-LA's current patent pools. There's hundreds of the suckers."
04:23:21 <Sgeo> Ah
04:29:04 -!- elliott has quit (Quit: Leaving).
05:04:17 -!- zzo38 has quit (Remote host closed the connection).
05:50:48 <Sgeo> *sigh*
05:51:02 <Sgeo> I am not an iOS Developer, http://twitter.com/#!/GplSource_/ios-developers to the contrary
06:02:02 <Gregor> !bfjoust saccharin_philip http://sprunge.us/UfDT
06:03:35 <Gregor> wtf, the system's responsive, but EgoBot isn't ...
06:04:49 <Gregor> saccharin_philip: Blatantly ripping off quintopia's brilliant poke concept for fun and profit.
06:05:16 <EgoBot> Score for Gregor_saccharin_philip: 47.7
06:05:33 <Gregor> D'aww :(
06:05:37 <quintopia> Gregor: no worries mate. i'm working on something that will take me forever, but will be fucking brilliant if it works
06:05:47 <Gregor> I beat almost everyone, but not by a wide enough margin.
06:06:40 <quintopia> you also failed to beat most of the defends
06:06:50 <Gregor> Ohyeah, that's true.
06:07:15 <Gregor> Only 13 and 14 are worth beating.
06:07:20 <quintopia> actually
06:07:25 <quintopia> i may be misreading the chart
06:07:54 <quintopia> nope
06:07:56 <quintopia> they all beat you :P
06:08:04 <Gregor> I beat defend9
06:08:18 <quintopia> i'd recommend beating more of them
06:08:45 <Gregor> I still can't do shit against shudderers >_>
06:09:03 <quintopia> also, i don't see how you beat poke, but not maglev
06:09:19 <Gregor> Uh, I did beat maglev
06:09:27 <quintopia> oh
06:09:28 <Sgeo> I don't know any of this terminology
06:09:29 <quintopia> damn chart
06:09:47 <Gregor> Sgeo: I started a BF Joust strategies page to detail them, but nobody's taken up filling in any of their favorites :P
06:10:07 <Sgeo> Aww
06:10:10 <quintopia> gregor: how hard would it be to put the numbers on the right side in the table? is it something you can do in a second? because it would be SO MUCH EASIER TO READ
06:10:13 <Gregor> quintopia: So what anti-shudderer algorithms do people use?
06:10:22 <Gregor> quintopia: It's something I can do in a second :P
06:10:30 <Gregor> quintopia: Can't you ... select lines in your web browser?
06:10:32 <Sgeo> What's a shudderer?
06:10:37 <Sgeo> (+-)*-1?
06:10:44 <quintopia> yes Sgeo
06:10:47 <Gregor> Sgeo: More or less, but usually by slightly more random intervals.
06:10:48 <quintopia> except
06:10:57 <quintopia> (++-) sort of usually
06:11:03 <quintopia> so that it hits zero at some point
06:11:14 <Sgeo> Why is hitting zero good?
06:11:36 <Gregor> Sgeo: Cause opponents ]'s to detect that and wander off the tape.
06:11:43 <quintopia> gregor: to beat shudder, put .[.++-------] after your main [-] loop. or if you use [+] change the polarities
06:11:57 <Gregor> quintopia: I use a careless turtle approach >_>
06:12:30 <quintopia> then your best bet is to only try to beat it on the longest tape length
06:12:57 <quintopia> just sit there and do (.+)*-1
06:13:05 <quintopia> eventually you'll get it
06:14:23 <Gregor> I can't "sit there" with the careless turtle approach, the whole idea is I just try a range of values, and if they don't work, I move on.
06:14:36 <Gregor> That's why it beats decoys so well.
06:14:56 <Gregor> But shudderers make it just jump ship.
06:15:16 <quintopia> uh yeah
06:15:27 <quintopia> except on the longest tape length
06:15:37 <quintopia> where you know in advance moving on is suicide
06:15:46 <quintopia> so after you finish doing your careless turtle thing
06:15:55 <quintopia> do that thing
06:16:05 <Gregor> Because of how philip works, I don't really know where I am in the tape, it'd be super difficult to keep track and involve expanding it enormously :P
06:16:17 <quintopia> meh let me look at it
06:16:26 <Gregor> Then lemme paste it unexpanded.
06:17:06 <Gregor> quintopia: http://sprunge.us/DVcD
06:19:04 <Gregor> !bfjoust new_report <
06:19:07 <EgoBot> Score for Gregor_new_report: 0.0
06:19:27 <quintopia> gah
06:19:39 <quintopia> the unexpanded stuff is so hard to read :/
06:20:14 <quintopia> by which i mean
06:20:25 <quintopia> anything using ({})% is hard to read
06:20:32 <Gregor> :P
06:21:00 <quintopia> so first you do a binary search to kill small decoys
06:21:49 <Gregor> If that doesn't work, I carelessly (-)*100(-.)*32
06:21:57 <Gregor> If the program's not over by then, I just keep going.
06:22:02 <Gregor> Actually looping would be too expensive.
06:22:15 <quintopia> yeah
06:22:18 <Gregor> However, that means I can keep going either deep within the loop (in which case I'm pure turtle) or outside the loop.
06:22:48 -!- asiekierka has joined.
06:22:52 <Sgeo> Gregor, but that's only occasionally
06:22:54 <quintopia> so what happens if you hit shudder? does it print steamroller?
06:23:06 <Gregor> No, it's usually only in the turtle phase at that point.
06:23:18 <Gregor> Sgeo: No, it's extremely common.
06:23:28 <Sgeo> Huh?
06:23:35 <Sgeo> How, most of the time it wont be 0
06:24:02 <quintopia> Gregor: the way you structured your program sucks. rewrite it so you can tell where on the tape you are and then you can beat shudder. otherwise, you're SOL
06:24:48 <Gregor> If I can tell where on the tape I am, my whole strategy doesn't work. No amount of restructuring will magically make the strategy be compatible with knowing where I am. Also, knowing where you are on the tape seems like a fundamentally broken strategy to me, it'll only gain me one win when I lose in every length.
06:24:49 <quintopia> it'll be big and ugly, but once you do it, you can reap a ton of benefits
06:25:19 <quintopia> well, you're right i think
06:25:39 <quintopia> without checking and making sure the cell you're on is CLEARED, you can never beat shudder
06:25:42 <quintopia> sorry
06:25:48 <Gregor> Yes, I know and acknowledge that :P
06:26:43 <quintopia> (at least not without making it lose to everything else :P)
06:27:03 <Gregor> Yeah, I've futzed with it enough to make it win to the defends, and then it failed horribly elsewhere :P
06:29:23 <quintopia> it's a neat idea, but very limited
06:29:33 <quintopia> however
06:30:41 <Gregor> It did quite well for me 'til you adjusted all your programs :P
06:30:55 <quintopia> you CAN rewrite it so that you can tell when you've cleared a cell. basically, instead of doing (+.)*32, you'd do (+[)*32, but keep going with your strategy INSIDE the loop, and stick all the ] at the end
06:31:35 <quintopia> you'd end up having A BAJILLION nested parens and TWENTY SEVEN BAJILLION repeats of the same code
06:31:41 <Gregor> I was just thinking about that.
06:31:42 <quintopia> but it could be done
06:33:07 <Sgeo> How difficult could it be for me to evolve a neural net?
06:33:52 <quintopia> lul
06:33:54 * Sgeo likes this idea a lot
06:33:56 <quintopia> it's not evolution
06:34:02 <quintopia> it's backpropagation
06:34:09 <quintopia> and it's really easy for small nets
06:34:55 <Sgeo> I don't know how large a net would be needed to take a BFJoust hill and make a program victorious against most of the programs on it
06:35:21 <Gregor> quintopia: All the ]]]]]]'s would probably be expensive.
06:35:40 <quintopia> just make sure you never have to execute them
06:35:47 <pikhq> *pffft*
06:35:48 <quintopia> but copying code before them
06:35:58 <pikhq> Microsoft is disabling Autorun.
06:36:05 <pikhq> In Windows XP and up.
06:36:10 <Sgeo> pikhq, took long enough
06:36:11 <quintopia> did i not say TWENTY SEVEN BAJILLION REPEATS?
06:36:25 <Sgeo> But then people will complain about stuff not working
06:37:14 <pikhq> ... Aaaaw.
06:37:26 <pikhq> They're disabling it for *most* media.
06:37:37 <pikhq> Still enabled on 12cm discs.
06:49:35 <Gregor> Damn it, I don't want to be a person who writes BFJ programs as long as defend13 X-P
06:57:42 <Gregor> !bfjoust saccharin_philip http://sprunge.us/iQEi
06:57:52 <EgoBot> Score for Gregor_saccharin_philip: 47.1
06:58:06 <Gregor> lawl, that change was even more minor than I thought :P
07:06:29 <quintopia> Gregor: the one i'm working on is longer than defend13 by a mile
07:06:50 <Gregor> quintopia: I didn't say I don't want anybody else to be one of those people :P
07:06:54 <Gregor> I just don't want to be one.
07:06:56 <quintopia> i'm about to write a program to help me write it because damn is this a lot of easy arithmetic i have to do to do it
07:08:23 <Gregor> Feel free to publish said program to help others :P
07:18:38 -!- Mathnerd314 has quit (Ping timeout: 240 seconds).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:37 -!- kwertii has quit (Quit: bye).
08:05:03 <quintopia> Gregor: sure. you have matlab, right?
08:05:56 <quintopia> Gregor: it doesn't really matter. the program won't be necessary any more once superpoke is complete. it will contain every useful output the program can generate.
08:17:22 -!- FireFly has joined.
08:22:39 -!- Sgeo has quit (Read error: Connection reset by peer).
08:23:07 -!- Sgeo has joined.
08:28:18 -!- Zuu has quit (Ping timeout: 260 seconds).
08:34:39 -!- Zuu has joined.
08:58:17 <quintopia> woo! half done with superpoke!
09:07:02 -!- amca has joined.
09:10:27 -!- amca has quit (Quit: Farewell).
09:27:10 <quintopia> annnnnd...i made a mistake. time to rewrite the whole thing :/
10:25:57 -!- yorick has joined.
10:49:52 -!- BeholdMyGlory has joined.
10:51:58 -!- Sgeo has quit (Read error: Connection reset by peer).
10:52:28 -!- Sgeo has joined.
11:48:54 <quintopia> too bad no one is around to witness the awesomeness that i am about to bestow on this channel >_>
11:49:07 <quintopia> !bfjoust space_elevator http://sprunge.us/dZZK
11:50:57 <EgoBot> Score for quintopia_space_elevator: 0.6
11:51:19 <quintopia> bah
11:51:30 <quintopia> must have gotten a typo in there somewhere
11:53:03 -!- sebbu2 has joined.
11:57:25 -!- sebbu has quit (Ping timeout: 276 seconds).
12:00:03 <quintopia> !bfjoust space_elevator http://sprunge.us/CYBV
12:00:26 <quintopia> if it doesn't work this time, i'll have to wait til lance to try it out, because it means egojoust is severely broken
12:00:30 <EgoBot> Score for quintopia_space_elevator: 55.1
12:00:39 <quintopia> better
12:03:26 <quintopia> loses to saccharin_philip, speedy2, 3pass, careful, and careless. it will never beat speedy2, but i'll have to ponder the beating of careless type programs
12:21:52 -!- augur has quit (Remote host closed the connection).
12:40:02 -!- augur has joined.
12:48:33 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*9[-]])*10(>[(-)*9[+]])*10>(.-)*10000
12:48:55 <EgoBot> Score for Deewiant_maglev: 38.7
12:50:21 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*20<<(+)*42(>)*7(>[(+)*9[-]])*20>(.-)*10000
12:50:31 <EgoBot> Score for Deewiant_maglev: 37.1
12:51:16 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[(+)*9[-]])*20>(.-)*10000
12:51:22 <EgoBot> Score for Deewiant_maglev: 40.1
13:07:52 -!- pikhq_ has joined.
13:08:21 -!- pikhq has quit (Ping timeout: 276 seconds).
13:57:08 -!- MigoMipo has joined.
14:12:16 -!- Tritonio has joined.
14:33:53 <augur> anyone know if there are techniques for finding minimal turing machines?
14:37:12 <Slereah> Brute force?
14:37:39 <Slereah> Also, what do you mean by minimal?
14:39:18 <Deewiant> I'm pretty sure it's impossible to minimize Turing machines, but I can't remember how to demonstrate it
14:39:39 <Slereah> Well
14:39:45 <Slereah> Imagine for instance a decision problem
14:40:01 <Slereah> Minimizing it would just be one step saying yes or no?
14:40:28 <Deewiant> Right.
14:40:44 -!- Wamanuz has quit (Remote host closed the connection).
14:41:00 <Slereah> Hence not too goo
14:41:01 <Slereah> d
14:41:06 -!- Wamanuz has joined.
14:42:32 -!- Wamanuz has quit (Remote host closed the connection).
14:44:59 -!- Wamanuz has joined.
14:46:22 <Slereah> Although there's quite a few programs that you could minimize by brute force
14:46:37 <Slereah> I made one like that for Lazy Bird once
14:46:40 <Slereah> Called it
14:46:43 <Slereah> THE JUGGERNAUT
14:47:43 -!- p_q has joined.
14:48:01 -!- poiuy_qwert has quit (Ping timeout: 240 seconds).
14:51:23 <augur> Slereah: like, suppose you have a TM for a language (say its just a*). is there a way of making the TM as simple as possible?
14:51:32 <augur> eliminating redundant states, redundant transitions, or whatever?
14:52:11 <Slereah> Well, if it's just to eliminate a few loops, you can probably do it by brute force
14:52:28 <augur> sure, but in general, are there any such algorithms?
14:54:10 <Slereah> Can't think of any
14:57:24 -!- hiato has joined.
15:04:36 -!- iconmaster has joined.
15:07:17 -!- ais523_ has joined.
15:07:48 <ais523_> !c printf("%d", atoi(NULL));
15:09:41 <ais523_> !c printf("%s", "Hello, world!");
15:09:43 <EgoBot> Hello, world!
15:10:32 <iconmaster> !c printf("%s","Hi, I'm back.");
15:10:34 <EgoBot> Hi, I'm back.
15:10:51 <ais523_> so why no output for my first line?
15:10:55 <Slereah> !c printf("%s","SO RED");
15:10:57 <EgoBot> SO RED
15:11:02 <ais523_> I'm on a Windows computer atm, and wanted to know if it returned 0 or segfaulted
15:11:06 <Slereah> Awww
15:11:13 <iconmaster> you pined ""? idk, does EgoBot check for ""?
15:11:28 <ais523_> !c if(atoi(NULL)) printf("nonzero"); else printf("zero");
15:11:29 <iconmaster> *printed
15:11:32 <EgoBot> ./interps/gcccomp/gcccomp: line 52: 31448 Segmentation fault      /tmp/compiled.$$
15:11:42 <ais523_> ah, that's better
15:12:17 <iconmaster> Funny, it doesnt segfault if printf?
15:12:26 <ais523_> who knows?
15:12:37 <ais523_> it could be that the call to atoi was optimised out, or something like that
15:12:41 <ais523_> as it's probably undefined behaviour
15:13:15 <iconmaster> !c printf("%d",NULL);
15:13:17 <EgoBot> 0
15:13:38 <iconmaster> Huh.
15:14:02 <ais523_> that makes sense
15:14:10 <ais523_> (int)NULL doesn't have to be 0, but it generally is in practice
15:14:26 <iconmaster> Oh! so NULL is an int? I gots it.
15:14:34 <ais523_> no, NULL isn't an int, it's a pointer
15:14:37 <iconmaster> I only know a LITTLE C
15:14:38 <ais523_> but pointers can be interpreted as integers
15:14:47 <iconmaster> oh i knew that
15:14:57 <ais523_> thus, NULL isn't 0 at all, but (int)NULL often can be
15:15:23 <ais523_> (to add to the confusion, the value of NULL, as a pointer, is /written/ 0, although it doesn't refer to the integer 0 in that context)
15:15:44 <iconmaster> would '!c printf("%d",a=malloc(5));free(a)' glitch
15:15:58 <ais523_> you haven't declared a
15:16:02 <ais523_> but it should work otherwise
15:16:08 <iconmaster> int a;printf("%d",a=malloc(5));free(a)
15:16:17 <iconmaster> !c int a;printf("%d",a=malloc(5));free(a)
15:16:18 <EgoBot> ./interps/gcccomp/gcccomp: line 52: 31631 Segmentation fault      /tmp/compiled.$$
15:16:26 <ais523_> hmm, I wonder why that failed?
15:16:37 <iconmaster> idk
15:16:54 <ais523_> !c void* a; a=malloc(5); printf("%d",(int)a); free(a);
15:16:56 <EgoBot> 1302282256
15:17:01 -!- sebbu2 has quit (Ping timeout: 250 seconds).
15:17:03 <ais523_> !c void* a; a=malloc(5); printf("%d",a); free(a);
15:17:04 <EgoBot> 1967124496
15:17:08 <iconmaster> oops needed to be a void
15:17:14 <ais523_> !c void* a; printf("%d",a=malloc(5)); free(a);
15:17:16 <EgoBot> 1269907472
15:17:22 <ais523_> !c int a; printf("%d",a=malloc(5)); free(a);
15:17:24 <EgoBot> ./interps/gcccomp/gcccomp: line 52: 31809 Segmentation fault      /tmp/compiled.$$
15:17:41 <iconmaster> But a poined IS an int!
15:17:42 <ais523_> how strange, those pointer values fit into 32-bit int range
15:17:45 <iconmaster> *pointer
15:17:48 <ais523_> and not on a 64-bit system it isn't
15:17:52 <iconmaster> ooooooh.
15:18:01 <ais523_> 64-bit pointers, generally 32-bit ints
15:18:12 <iconmaster> would long int do it?
15:18:15 <ais523_> in fact, there technically doesn't need to be any connection at all
15:18:26 <ais523_> !c long a; printf("%d",a=malloc(5)); free(a);
15:18:28 <EgoBot> 1210388496
15:18:37 <iconmaster> aha! i knew it!
15:18:42 <ais523_> well, either EgoBot's on a 16-bit system, or something crazy's going on
15:19:05 <ais523_> !c printf("%zu %zu %zu",sizeof(void*),sizeof(int),sizeof(long));
15:19:06 <iconmaster> !c long a; printf("%d - %s",a=malloc(5),"A random number, lol."); free(a);
15:19:08 <EgoBot> 8 4 8
15:19:16 <ais523_> ah, it is on a 64-bit system
15:19:57 <iconmaster> !c long a; printf("%d - %s",a=malloc(5),"A random number, lol."); free(a);
15:20:02 <EgoBot> 1732182032 - A random number, lol.
15:20:59 <ais523_> !c printf("%p",malloc(5));
15:21:00 <EgoBot> 0x7f598479d010
15:21:20 <ais523_> oh, I see; %d prints out only the bottom 32 bits of the pointer
15:21:26 <ais523_> !c printf("%p",malloc(5));
15:21:28 <EgoBot> 0x7f2a1883d010
15:21:30 <ais523_> !c printf("%p",malloc(5));
15:21:31 <EgoBot> 0x7feb43f66010
15:21:50 <ais523_> (this isn't a memory leak because EgoBot cleans up mallocs between lines; it could be in other C-based systems)
15:22:26 <ais523_> !c printf("%p %p %p %p %p %p",malloc(5),malloc(5),malloc(5),malloc(5),malloc(5),malloc(5));
15:22:28 <EgoBot> 0x7fa048e1d0b0 0x7fa048e1d090 0x7fa048e1d070 0x7fa048e1d050 0x7fa048e1d030 0x7fa048e1d010
15:23:36 -!- ais523_ has quit (Quit: Page closed).
15:27:24 <hiato> where oh where did cpressey go? oh where oh where can he be?
15:55:14 -!- Slereah has quit (Ping timeout: 240 seconds).
15:59:45 -!- sftp has quit (Read error: Connection reset by peer).
16:01:21 -!- Slereah has joined.
16:14:55 -!- elliott has joined.
16:15:52 <elliott> 06:14:01 <Sgeo> I am not an iOS Developer, http://twitter.com/#!/GplSource_/ios-developers to the contrary
16:15:59 <elliott> oh god sgeo uses twitter
16:21:18 -!- sftp has joined.
16:25:49 -!- sftp has quit (Remote host closed the connection).
16:33:35 -!- sftp has joined.
16:36:47 -!- sftp has quit (Remote host closed the connection).
16:41:04 -!- sftp has joined.
16:54:45 -!- cheater- has quit (Ping timeout: 240 seconds).
16:55:51 -!- cheater- has joined.
16:57:14 -!- zeotrope has joined.
17:01:11 -!- asiekierka has quit (Ping timeout: 272 seconds).
17:03:17 -!- Leonidas_ has joined.
17:03:31 -!- Leonidas_ has changed nick to Leonidas.
17:12:20 -!- cheater- has quit (Ping timeout: 240 seconds).
17:14:28 -!- cheater- has joined.
17:17:45 -!- asiekierka has joined.
17:23:05 <elliott> 15:50:42 <hiato> where oh where did cpressey go? oh where oh where can he be?
17:23:06 <elliott> hiato: he left
17:25:31 <elliott> 06:53:57 <quintopia> you CAN rewrite it so that you can tell when you've cleared a cell. basically, instead of doing (+.)*32, you'd do (+[)*32, but keep going with your strategy INSIDE the loop, and stick all the ] at the end
17:25:34 <elliott> quintopia: INVALID CODE.
17:25:37 <elliott> quintopia: *BEEP.*
17:26:14 <Gregor> elliott: WHERE'S YUR GAL-BLUM DURPALANCE
17:26:37 <elliott> Gregor: Dude, I keep staring at the code, and I have absolutely no idea why it isn't working.
17:26:48 <elliott> Gregor: It seemed like repeats were off-by-oned. But they're not.
17:26:55 <elliott> Then it seemed like loop cycle timing was broken.
17:26:56 <elliott> It's not.
17:27:02 -!- ais523_ has joined.
17:27:04 -!- ais523_ has quit (Changing host).
17:27:05 -!- ais523_ has joined.
17:27:05 -!- ais523_ has quit (Changing host).
17:27:05 -!- ais523_ has joined.
17:27:08 <elliott> Hi ais523_.
17:27:13 <ais523_> hi
17:27:16 <Gregor> lawlwtf was that twice-changed-host.
17:27:21 <elliott> Yeah :-P
17:27:25 <elliott> * ais523_ (93bcc029@gateway/web/freenode/ip.147.188.192.41) has joined #esoteric
17:27:26 <elliott> * ais523_ has quit (Changing host)
17:27:26 <elliott> * ais523_ (93bcc029@unaffiliated/ais523) has joined #esoteric
17:27:26 <elliott> * ais523_ has quit (Changing host)
17:27:26 <elliott> * ais523_ (93bcc029@gateway/web/freenode/ip.147.188.192.41) has joined #esoteric
17:27:30 <elliott> I think web users are forced to show their host.
17:27:33 <elliott> So it got switched back.
17:28:03 <Gregor> ais523_: elliott is describing how he fails at writing BF Joust implementations.
17:28:11 <ais523_> I've been here all day, but needed to get some really boring marking done
17:28:20 <ais523_> and the only way to manage that is to not talk to friends who are a lot more interesting
17:28:28 <ais523_> (it was the kernel keylogger thing I was talking about earlier)
17:28:42 <ais523_> making it worse, I had to do it on Windows because that's where VirtualBox was installed
17:28:56 <elliott> How many of them actually logged keys?
17:28:58 <ais523_> (and you don't run likely-buggy and known-malicious kernel modules /outside/ a VM...)
17:29:10 <ais523_> well, they were just meant to log the timings
17:29:23 <ais523_> *procfile
17:29:25 <elliott> I dunno, I would run them outside of a VM... I already know exactly how they're malicious :P
17:29:25 <ais523_> but some logged keys as well, and made them available via a procifle
17:29:29 <elliott> The buggy thing, granted.
17:29:40 <ais523_> also, they all clashed with each other, obviously
17:29:47 <ais523_> and loading a snapshot was faster than repeatedly rebooting
17:29:48 -!- asiekierka has quit (Ping timeout: 240 seconds).
17:30:11 <ais523_> the one I'm most impressed with did a radix sort on the timings as soon as they were collected, to avoid having to store them anywhere
17:30:12 <Gregor> elliott: So, shall I write egojoust 2 >: )
17:30:15 <ais523_> it wouldn't have run out of memory for ages
17:30:30 <elliott> Gregor: no :(
17:30:39 <elliott> lance is good, i just have some stupid bu
17:30:39 <elliott> g
17:30:40 <Gregor> elliott: Well then why don't you SHOW SOME MOFO CODE
17:30:40 <ais523_> btw, I have a really good defence program that I wrote last night, but it isn't on this computer
17:30:51 <ais523_> I'll put it on the hill later
17:30:53 <elliott> Gregor: Is that you offering to do free work? :P
17:30:59 <elliott> ais523_: let me guess its name
17:31:01 <elliott> defend15?!?!!
17:31:05 <Gregor> elliott: Only if it results in me making fun of you for your stupidity 8-D
17:31:15 <ais523_> heh, it's actually definder/definder2
17:31:22 <ais523_> because "definder.pl" was the name of the program that generated most of it
17:31:31 <ais523_> I wrote a program to computer-search for good defence loops
17:31:31 <Gregor> FFFFFFFFFFFFFFFFUUUUUUUU
17:31:33 <elliott> ais523_: I don't know who you are any more
17:31:58 <ais523_> definder can deal with both two-cycle and three-cycle clears
17:32:24 <ais523_> definder2 also deals with 128-detectors, defence programs, and (unreliably, but generally well enough to beat 50%) shudderers
17:32:38 <ais523_> it's fun to see a defence program beat wiggle2/3 (although not on every tape length and polarity)
17:32:57 <ais523_> they do have a few losses, but it's mostly against bad programs that do weird things
17:33:06 <Deewiant> How does it do against space_elevator
17:33:26 <ais523_> I don't know, I didn't have a local copy of space_elevator when I wrote it
17:33:32 <ais523_> and I don't have a copy of definder2 on this computer
17:33:50 <Gregor>   2  45   52.08   20.43  quintopia_wireless.bfjoust
17:33:50 <Gregor>   3  11   47.41    3.24  ais523__double_tripwire_avoider.bfjoust
17:33:50 <Gregor>   4  39   47.32   15.86  quintopia_poke.bfjoust
17:33:51 <Gregor> lawl @ points
17:34:14 <Gregor> I love how double_tripwire_avoider solves only ONE problem, and yet is #3, with 3.24 points X-D
17:34:32 <elliott> ais523_: btw, quintopia realised that a hybrid program like i mentioned is actually probably possible
17:34:34 <elliott> and is working on one now
17:34:50 <elliott> lesson: everyone stop saying things are impossible!
17:35:21 <ais523_> Gregor: it actually solves multiple problems, although I admit that beating reverse decoy setups is its main purpose
17:35:40 <elliott> ais523_: 07:12:37 <Gregor> Damn it, I don't want to be a person who writes BFJ programs as long as defend13 X-P
17:35:51 <ais523_> definder2 is longer
17:36:06 <elliott> 07:20:44 <Gregor> !bfjoust saccharin_philip http://sprunge.us/iQEi
17:36:06 <elliott> 07:20:54 <EgoBot> Score for Gregor_saccharin_philip: 47.1
17:36:06 <elliott> 07:21:08 <Gregor> lawl, that change was even more minor than I thought :P
17:36:12 <elliott> Gregor: er does egojoust support that % nesting?
17:36:13 <ais523_> mostly because I had to write its defence loop three times, and its defence loop doesn't follow any pattern at all
17:36:16 <elliott> 07:29:32 <quintopia> Gregor: the one i'm working on is longer than defend13 by a mile
17:36:17 <elliott> :D
17:36:20 <Deewiant> defend13 is only 8.5K, space_elevator is 38K
17:36:28 <ais523_> in fact, it's completely bizarre
17:36:29 <elliott> 07:29:58 <quintopia> i'm about to write a program to help me write it because damn is this a lot of easy arithmetic i have to do to do it
17:36:30 <Gregor> elliott: egojoust only fails with {{}} nesting
17:36:33 <elliott> Deewiant: wtf is space_elevator
17:36:34 <elliott> !bfjoust
17:36:38 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
17:36:39 <ais523_> I think definder2 is somewhere in between
17:36:43 <Deewiant> elliott: Possibly the program of which you speak.
17:36:53 <elliott> ah, yes
17:37:02 <elliott> and it's at the top
17:37:04 <elliott> I'm not surprised
17:37:11 <elliott> ais523_: have you seen it?
17:37:14 <elliott> ais523_: http://codu.org/eso/bfjoust/in_egobot/quintopia_space_elevator.bfjoust
17:37:45 <elliott> welp, definitely looks like the age of huge strategic bf joust programs has begun
17:37:48 -!- ais523__ has joined.
17:37:55 <ais523__> that was weird
17:37:58 -!- ais523_ has quit (Disconnected by services).
17:38:02 -!- ais523__ has changed nick to ais523_.
17:38:19 <elliott> ais523_: erm, what was the last you saw
17:38:25 <ais523_> I don't know
17:38:38 <ais523_> Freenode webchat decided it had disconnected for no good reason
17:38:40 <elliott> ais523_: about quintopia's hybrid program:
17:38:41 <elliott> <elliott> ah, yes
17:38:41 <elliott> <elliott> and it's at the top
17:38:42 <elliott> <elliott> I'm not surprised
17:38:42 <elliott> <elliott> ais523_: have you seen it?
17:38:42 <elliott> <elliott> ais523_: http://codu.org/eso/bfjoust/in_egobot/quintopia_space_elevator.bfjoust
17:38:43 <elliott> <elliott> welp, definitely looks like the age of huge strategic bf joust programs has begun
17:38:44 <ais523_> and unlike Konversation, doesn't keep a log of the last it saw
17:38:51 * elliott is very impressed
17:39:39 <elliott> 09:21:23 <quintopia> woo! half done with superpoke!
17:39:39 <elliott> 09:50:16 <quintopia> annnnnd...i made a mistake. time to rewrite the whole thing :/
17:39:39 <elliott> :D
17:39:45 <elliott> 12:12:05 <quintopia> too bad no one is around to witness the awesomeness that i am about to bestow on this channel >_>
17:39:45 <elliott> 12:12:18 <quintopia> !bfjoust space_elevator http://sprunge.us/dZZK
17:39:46 <elliott> 12:14:08 <EgoBot> Score for quintopia_space_elevator: 0.6
17:39:46 <elliott> LOL
17:40:10 <olsner> is that a good or a bad score?
17:40:13 <ais523_> I've just been looking at space_elevator in egojsout
17:40:14 <ais523_> the source, that is
17:40:18 <ais523_> it's the sort of thing I would come up with
17:41:18 <elliott> olsner: terrible
17:41:23 <elliott> olsner: but it was due to a generator bug
17:41:29 <elliott> and once fixed, it went straight to the top of the hill
17:41:32 <elliott> beating almost every program
17:41:50 <ais523_> it loses quite dramatically to speedy2, anyway
17:41:50 <elliott> the only ones it doesn't beat are careless-style programs which quintopia says he's looking into, and speedy2 which it will apparently never beat
17:42:20 <Gregor> elliott: I STILL SEE NO CODE
17:42:24 <ais523_> I should check definder vs. speedy2 sometime
17:42:24 <Gregor> elliott: TIME TO WRITE EGOJOUST2 I SEE
17:42:30 <elliott> Gregor: Shut the fuck up.
17:42:38 <elliott> I'm working on fixing the bug now.
17:42:38 <Gregor> ^^
17:43:05 <elliott> It would help if the bug made any sense at all.
17:43:25 <elliott> OK, vague theory
17:43:38 <elliott> ais523_: for (a;b;c) { ... goto foo; ... foo: ; }
17:43:42 <ais523_> one thing I don't get is why poking works so well
17:43:47 <elliott> ais523_: When foo is gone-to, does the for header still work?
17:43:51 <elliott> i.e. does c, and then checks b and breaks
17:43:52 <ais523_> elliott: yes
17:43:59 <ais523_> also, why don't you say continue; rather than use that goto?
17:44:06 <elliott> ais523_: That's nice. If only it demonstrated such behaviour.
17:44:09 <ais523_> it'd be a lot clearer
17:44:10 <elliott> Also, that's a very good question/
17:44:12 <elliott> *question.
17:44:17 <elliott> It's actually
17:44:20 <elliott> for (...) {
17:44:25 <elliott>   switch (...) {
17:44:29 <elliott>     ... goto foo; ...
17:44:31 <ais523_> I think you're looking for your bug in the wrong place
17:44:31 <elliott>   }
17:44:32 <elliott>   something;
17:44:33 <elliott> foo: ;
17:44:34 <elliott> }
17:44:41 <ais523_> and continue; inside a switch will look for a loop outside it
17:44:45 <elliott> indeed
17:44:49 <elliott> ais523_: I've verified that the parser works perfectly
17:45:00 <ais523_> (whereas break breaks from the switch, in a nicely evil bit of asymmetry)
17:45:02 <elliott> and the bug is really odd
17:45:05 <ais523_> elliott: why don't you step through it in a debugger?
17:45:10 <elliott> you know that program where it should beat it consistently
17:45:12 <elliott> but with normal polarity
17:45:14 <elliott> on tape length 30
17:45:16 <elliott> it was the wrong way?
17:45:21 <elliott> well, i compared the trace to egojsout
17:45:38 <elliott> in egojsout, it moved right 9 times, then started taking two cycles to advance
17:45:42 <elliott> in mine, it moved right *10* times
17:45:42 <elliott> BUT
17:45:44 <fizzie> ais523_: It would be even worse if "continue" did 're-run' the switch by re-running the test and brancing again.
17:45:48 <elliott> i've verified that ()* has no off-by-one
17:45:50 <elliott> >_<
17:45:54 <elliott> and loop cycle timing looks perfect
17:46:00 <ais523_> fizzie: haha, I suppose that would be the orthogonal semantics
17:46:11 <ais523_> elliott: check to see if (>)*9 works the same way as >>>>>>>>>
17:46:20 <ais523_> that would at least help you pin down where the bug was
17:46:34 -!- impomatic has joined.
17:46:38 <ais523_> fizzie: also, those semantics for continue in switch would be really nice for state machines
17:46:46 <impomatic> Hi :-)
17:47:13 <elliott> 80  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <80 -- >0, <29
17:47:14 <elliott>  80 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  80 -- >1, <28
17:47:14 <elliott>  80  00 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  80 -- >2, <27
17:47:14 <elliott>  80  00  00 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  80 -- >3, <26
17:47:18 <elliott>  80  00  00  00 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  80 -- >4, <25
17:47:21 <elliott>  80  00  00  00  00 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  00  80 -- >5, <24
17:47:24 <elliott>  80  00  00  00  00  00 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  00  00  80 -- >6, <23
17:47:27 <elliott>  80  00  00  00  00  00  00 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  00  00  00  80 -- >7, <22
17:47:29 <ais523_> hi impomatic
17:47:30 <elliott>  80  00  00  00  00  00  00  00 >00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  00  00  00  00  80 -- >8, <21
17:47:30 <Gregor> Yay flooding...
17:47:33 <elliott>  80  00  00  00  00  00  00  00  00 >00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  00  00  00  00  00  80 -- >9, <20
17:47:35 <ais523_> I'm at work, but I have a fun new program to test out when I get home
17:47:36 <elliott>  80  00  00  00  00  00  00  00  00 >00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  00  00  00  00  00  80 -- >9, <20
17:47:39 <elliott> ais523_: Looks right to me.
17:47:40 <ais523_> which should be relatively soon
17:47:41 <elliott> Sorry for flood.
17:48:04 <elliott>       case LOOP:
17:48:04 <elliott>         if (!saves[prog]) {
17:48:04 <elliott>           progs[prog] = progs[prog]->jmp;
17:48:04 <elliott>           continue;
17:48:04 <elliott>         }
17:48:05 <elliott>         break;
17:48:07 <elliott>       case POOL:
17:48:09 <elliott>         if (saves[prog]) {
17:48:11 <elliott>           progs[prog] = progs[prog]->jmp;
17:48:13 <elliott>           continue;
17:48:15 <elliott>         }
17:48:19 <elliott>         break;
17:48:21 <elliott> I'm pretty sure this takes one less cycle than it should or something...
17:48:23 <elliott> (the continue advances the:     for (int prog=0; prog<2; prog++) loop)
17:48:31 <ais523_> you have a separate counter at the ( and the )?
17:48:41 <elliott> ais523_: that's [ and ]
17:48:45 <elliott> not ( and )
17:48:46 <ais523_> oh, right
17:49:07 <elliott>       case PARE:
17:49:08 <elliott>         if (progs[prog]->arg == 0)
17:49:08 <elliott>           progs[prog] = progs[prog]->jmp;
17:49:08 <elliott>         else {
17:49:08 <elliott>           repeatstk[++repeatstki] = progs[prog]->arg;
17:49:08 <elliott>           progs[prog]++;
17:49:10 <elliott>         }
17:49:12 <elliott>         goto rego;
17:49:13 <ais523_> I take it ->jmp is the square after the matching square bracket, in each case?
17:49:14 <elliott>       case ERAP:
17:49:18 <elliott>         if (--repeatstk[repeatstki] == 0) {
17:49:20 <elliott>           repeatstki--;
17:49:22 <elliott>           progs[prog]++;
17:49:24 <elliott>         } else
17:49:26 <elliott>           progs[prog] = progs[prog]->jmp;
17:49:28 <elliott>         goto rego;
17:49:30 <elliott> that's ( and ) ({}-less version)
17:49:32 <elliott> ais523_: yep
17:49:34 <elliott> rego runs the current program again
17:49:36 <elliott> /without/ advancing the IP
17:49:38 <elliott> (it just points to the start of the for loop _body_)
17:49:57 <ais523_> also, ()*0-style comments seem broken in egojoust, so I haven't been using them
17:50:01 <ais523_> I'm trying to write portable programs atm
17:50:12 <Sgeo> How are they broken?
17:50:12 <elliott> ais523_: they are, yes, but they work in lance :)
17:50:28 <elliott> Sgeo: they do weird things
17:50:37 <ais523_> (I assume (((((()*2)*2)*2)*2)*2)*2 is valid in lance, if a little redundant; egojoust seems to be more efficient on that sort of repetition, and I don't know why)
17:50:59 <elliott> ais523_: yep, that's valid in lance
17:51:17 <Sgeo> By efficient, you mean duels faster, not actually executing the program differently, right?
17:51:17 <ais523_> definder uses that for its reverse tripwire loop
17:51:21 <Sgeo> As in, processes
17:51:26 <ais523_> and they're improved reverse tripwires, as they don't use the value 1
17:51:50 <Sgeo> I want a list of BF Joust strategies
17:51:50 <ais523_> thus dodging them is basically impossible without tuning your program so closely to definer2 that it loses to everything else
17:51:54 <ais523_> Sgeo: yep, I mean it runs faste
17:51:58 <ais523_> *faster
17:52:07 <ais523_> and loads of people want one of those, and several people are thinking about compiling one
17:52:14 <ais523_> I'd do it myself if I wasn't so busy
17:52:37 * Sgeo wants to make a neural net that writes BF Joust programs
17:52:39 <elliott> ais523_: there's a wiki page for them
17:52:41 <Gregor> HEY GUYS REMEMBER THAT LIST OF BF JOUST STRATEGIES I STARTED? Add your favorite.
17:52:42 <elliott> Sgeo: NEURAL NETS ARE USELESS FOR THIS
17:52:49 <Sgeo> elliott, how so?
17:52:50 <elliott> stop talking about using neural nets for it, it doesn't make any sense
17:52:52 <Gregor> Yeah, neural nets are wildly useless for this.
17:52:55 <elliott> neural nets have nothing to do with this at all
17:52:57 <ais523_> ah, I haven't looked at the wiki for a while
17:52:58 <elliott> nothing
17:53:07 <elliott> ais523_: the page is rather sparse because we're all too lazy to edit it :)
17:53:18 <Sgeo> Humans certainly seem to do decently
17:53:31 <elliott> ...................
17:53:38 <Gregor> The brain is not a neural net.
17:53:42 <elliott> New heights of stupidity have been reached in this channel.
17:54:57 <elliott> I imagine Sgeo read the Wikipedia article [[neural nets]] yesterday or something.
17:55:06 <Sgeo> No, I didn't.
17:55:27 <Sgeo> ....I read about neural nets many years ago in a Kurzweil book >.>
17:55:57 <Sgeo> Too many years ago perhaps
17:56:50 <Gregor> elliott: CODE
17:57:01 <Sgeo> Gregor, typo code?
17:57:07 <impomatic> Oh.  Nice page :-) http://esolangs.org/wiki/BF_Joust_strategies
17:57:10 <elliott> Gregor: Only if you promise to not laugh at how ugly the code is :P
17:57:28 <impomatic> I was making a list but it looks like you beat me to it :-)
17:57:48 <Gregor> elliott: Oh I'll laugh.
17:57:55 <Gregor> impomatic: Then IMPROVE the list.
17:58:19 <elliott> Gregor: I'm going to have to require you to promise that you won't REPURPOSE this code for EGOJOUST 2.
17:58:37 <Gregor> If I were to write egojoust 2, I would just rewrite egojsout in C.
17:58:53 <Sgeo> !bfjoust foil_dumb_clears ->+>-
17:59:21 <elliott> Gregor: You know what, I'ma consult egojsout's code to fix this :P
17:59:41 <elliott> Whoops look at that, I scrolled past a big block of license text without reading it.
17:59:48 <elliott> Guess I din't agree to anything.
18:00:20 <EgoBot> Score for Sgeo_foil_dumb_clears: 0.0
18:00:50 <elliott> Gregor: You know what's great? My code is like, identical to yours!
18:00:52 <elliott> But still broken!
18:01:08 <Gregor> I know you didn't use a while (meta) loop :P
18:01:20 <elliott> What IS that :-P
18:01:27 <elliott> Oh, your replacement of gotos.
18:01:31 <Gregor> No gotos in JS :P
18:01:37 <Sgeo> Is EgoBot deceased?
18:01:44 <Sgeo> Oh
18:01:45 <Sgeo> Dub
18:01:46 <ais523_> well, I added a few more strategies
18:01:47 <Sgeo> *Duh
18:01:54 <ais523_> but I have to go home now
18:02:01 <elliott> bye ais523_
18:02:02 <Sgeo> ais523_, bye
18:02:05 <ais523_> I'll do more later
18:02:05 <Gregor> !echo It's only a flesh wound!
18:02:05 <EgoBot> It's only a flesh wound!
18:02:12 * elliott wonders wtf start.cbend is.
18:02:14 -!- ais523_ has quit (Quit: Page closed).
18:02:35 <Gregor> elliott: The ending curly-brace within that paren-set.
18:02:48 <elliott> Oh, right. I don't do curly-braces right now because SOMETHING IS BROKEN
18:03:20 <Sgeo> Are there any currently viable lock programs?
18:03:40 <Deewiant> The complicated ones, like ais's long defends and space_elevator
18:04:25 <Gregor> elliott: CODE
18:04:27 <elliott> Gregor: Erm. Don't you skip the first instruction in a () pair? You increment the program counter unconditionally.
18:04:36 <elliott> Or does the matching thing point to the [, not what's after it?
18:04:38 <elliott> (Same for ()
18:04:40 <elliott> *())
18:05:11 <Gregor> elliott: The PC at entry to the () is the '(', not the first instruction.
18:05:27 <elliott> Gregor: But wherever ) jumps back to, is the (, not the instruction after it, right?
18:05:34 <Gregor> Yes.
18:05:41 <elliott> Maybe I'll try that :P
18:06:24 <Gregor> ( carries all the data for that loop, {}) only carry the location of (, and all jumps are directly to the location of the matching character, not after it (it just increments afterwards)
18:07:06 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[(+)*9[-]][(-)*9[+]])*20>(.-)*10000
18:07:12 <EgoBot> Score for Deewiant_maglev: 40.0
18:07:22 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[(+)*9[-]])*20>(.-)*10000
18:07:27 <EgoBot> Score for Deewiant_maglev: 40.1
18:07:34 <elliott> $ ./lance '(>+>-)*4(>[(-)*9[+]])*21' '>>>>>>>>(>[-[++[---]]])*21'
18:07:34 <elliott> Sieve:  >>>>>>>>>>>>>>>>>>><<
18:07:34 <elliott> Kettle: >>>>>>>>>>>>>>>>>>>>>
18:07:36 <elliott> s i g h
18:07:50 <Gregor> elliott: CODE CODE CODE CODE CODE CODE CODE CODE CODE
18:07:54 <elliott> Gregor: Maybe your storing of the loop count in the ( is what makes it work :P
18:07:57 <elliott> ...in fact, I think it is.
18:08:04 <Deewiant> monorail and speedy2?
18:08:08 <elliott> ...no, it's not.
18:08:09 <Gregor> elliott: It certainly made my life fucktons easier.
18:08:22 <Gregor> elliott: But a stack should work the same.
18:08:25 <elliott>   int repeatstk[MAXCYCLES], repeatstki = -1;
18:08:25 <elliott>       case PARE:
18:08:25 <elliott>         if (progs[prog]->arg == 0)
18:08:25 <elliott>           progs[prog] = progs[prog]->jmp;
18:08:25 <elliott>         else
18:08:26 <elliott>           repeatstk[++repeatstki] = progs[prog]->arg;
18:08:27 <elliott>         goto rego;
18:08:29 <elliott>       case ERAP:
18:08:32 <elliott>         if (--repeatstk[repeatstki] == 0)
18:08:33 <elliott>           repeatstki--;
18:08:35 <elliott>         else
18:08:37 <elliott>           progs[prog] = progs[prog]->jmp;
18:08:39 <elliott>         goto rego;
18:08:42 <elliott> Yeah, I don't see why that shouldn't work :P
18:09:09 <elliott> I've figured it out.
18:09:11 <elliott> It's gremlins.
18:09:25 <impomatic> !bfjoust spacedust (>)*8(>([+{[(-)*10[-]]}])%9)*21
18:09:31 <EgoBot> Score for impomatic_spacedust: 18.1
18:10:15 <impomatic> !bfjoust spacedecoy >(+)*10>(-)*10(>)*6(>([+{[(-)*10[-]]}])%9)*21
18:10:24 <EgoBot> Score for impomatic_spacedecoy: 24.1
18:10:54 <elliott> impomatic: Trying to beat the 'vator? :P
18:11:08 <Gregor> elliott: Maybe the issue is in the parsing somewhere, and ->arg is wonr
18:11:11 <Gregor> ... that's right. wonr.
18:11:20 <elliott> Gregor: Nope, I specifically printed out the two specific parse trees.
18:11:26 <elliott> Gregor: The parsing is right, the args are right.
18:11:30 <impomatic> !bfjoust spacetime >(+)*8>(-)*6(>)*6(>([+{[(-)*5[-]]}])%4)*21
18:11:42 <impomatic> elliott: 'vator?
18:11:43 <EgoBot> Score for impomatic_spacetime: 18.6
18:11:49 <elliott> impomatic: space_elevator
18:12:03 <elliott> impomatic: The 38 kilobyte program at the top of the hill.
18:12:17 <Gregor> elliott: Damn it, NEED MORE CODE
18:12:43 <elliott> Gregor: Lemme take one more shot at fixing this first :P
18:12:47 <Gregor> X_X
18:13:38 <Sgeo> "opponent found. back off fast and build a big decoy"
18:13:41 <impomatic> elliott: naming coincidence... Will take a look at space_elevator :-)
18:13:45 <Sgeo> How can it know it found the opponent?
18:13:49 <elliott> impomatic: Prepare for crazy.
18:14:01 <Gregor> Sgeo: Nonzero cell
18:14:12 <Sgeo> Hm
18:14:35 <elliott> [0x1602140] [ (arg=0, jmp=0x1602160)
18:14:35 <elliott> [0x1602150] + (arg=0, jmp=(nil))
18:14:35 <elliott> [0x1602160] ] (arg=0, jmp=0x1602140)
18:14:41 <elliott> Parse tree's lookin' all right...
18:14:50 <Sgeo> lol how does it determine how large the tape is?
18:14:53 <Deewiant> !bfjoust berserk (>)*9((-)*128>)*20(-)*128[(-)*9[+]]
18:15:02 <EgoBot> Score for Deewiant_berserk: 0.0
18:15:09 <Gregor> Deewiant: Excellent.
18:15:15 <Deewiant> Expected.
18:15:23 <elliott> :D
18:15:24 -!- SimonRC has quit (Ping timeout: 255 seconds).
18:15:33 <elliott> !bfjoust
18:15:33 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
18:15:34 <Deewiant> (-)*128 isn't exactly a winning strategy.
18:16:32 <Deewiant> !bfjoust berserk (>)*8(>(-)*128[(-)*9[+]])*21
18:16:44 <Sgeo> Gregor, I know how you could halve running time
18:16:54 <EgoBot> Score for Deewiant_berserk: 4.9
18:16:59 <Gregor> Sgeo: If you say half the polarities I WILL SHOOT YOU
18:17:09 <Sgeo> =P
18:17:14 <Sgeo> May I ask why you won't do that?
18:17:17 <iconmaster> Half the polarities?
18:17:29 <Sgeo> iconmaster, EgoBot runs ++ +- -+ --
18:17:44 <Deewiant> Hmm, 4/4/34 against space_elevator, more than expected
18:17:54 * iconmaster wonders why gregor hasnt shot me yet
18:18:02 <elliott> Gregor: egojsout is... incredibly... bugged.
18:18:07 <elliott> Tape length 30
18:18:08 <elliott>     0:  โš‘    80 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  80  โš‘
18:18:08 <elliott>     1:  โš‘    80 >01  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  80  โš‘
18:18:08 <elliott>     2:  โš‘    80  01 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  80  โš‘
18:18:09 <elliott>     3:  โš‘    80  01 >FF  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  80  โš‘
18:18:19 <elliott> Gregor: Programs do not start on the cell > their flag.
18:18:20 <elliott> Ever.
18:18:24 <elliott> program 1: (>+>-)*4(>[(-)*9[+]])*21
18:18:25 <elliott> program 2: >>>>>>>>(>[-[++[---]]])*21
18:18:34 <Gregor> elliott: It never shows the first state, because the first state is boring.
18:18:40 -!- GreaseMonkey has joined.
18:18:41 <Sgeo> Gregor, in all the runs, has breakdown ever shown ++ and -- to not be equiv, or +- and -+ to not be equiv?
18:18:42 <Gregor> elliott: That's AFTER the given cycle.
18:18:44 <elliott> Gregor: >_<
18:19:15 <Gregor> Sgeo: I KNOW THEY'RE FUCKING EQUIVALENT SHUT THE FUCK UP STOP TELLING ME THIS EVERYONE OR I WILL KILL EVERY GOD DAMN PERSON IN THIS CHANNEL WITH FIRE ARGH
18:19:16 <Sgeo> elliott, can you explain why Gregor won't halve the polarties?
18:19:17 <Deewiant> !bfjoust unsure (>)*8(>(-)*10[(-)*9[-]])*21
18:19:35 <EgoBot> Score for Deewiant_unsure: 5.5
18:19:58 <Gregor> Basically egojoust is to die, so I'm not touching it.
18:20:02 <Gregor> But lance isn't up to snuff yet.
18:20:05 <Gregor> So there ya go.
18:20:16 <Sgeo> @ok
18:20:17 <lambdabot> Maybe you meant: . ? @ ask bf do ft id pl rc v wn yow
18:20:29 <Deewiant> !bfjoust skippy (>)*8(>(-)*10[(-)*9[-]]>)*10
18:20:36 <Gregor> We should start the flags at 127 JUST to make them nonequivalent :P
18:20:53 <EgoBot> Score for Deewiant_skippy: 1.0
18:21:26 <elliott> Gregor: According to lance, these two programs start all
18:21:30 <elliott> >80  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <80
18:21:30 <elliott> >80  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  80
18:21:30 <elliott>  80 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  80
18:21:30 <elliott>  80 >01  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  80
18:21:33 <elliott>  80  01 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  80
18:21:36 <elliott> But according to egojsout, it's all
18:21:40 <elliott> >80  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <80
18:21:41 <elliott>  80 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  80
18:21:44 <elliott>  80 >01  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  80
18:21:49 <elliott>  80  01 >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  80
18:21:52 <Gregor> So you've got a false noop or something.
18:21:52 <elliott>  80  01 >FF  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  80
18:21:54 <Gregor> TOO BAD WE CAN'T SEE THE CODE.
18:21:55 <elliott>  80  01  FF >00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00 <00  00  00  00  00  80
18:21:58 <elliott> (First line added by me.)
18:22:00 <elliott> (To be the initial state.)
18:22:02 <elliott> Something like that, yup.
18:22:04 <elliott> Gregor: THAT'S TOO BAD INDEED
18:22:11 <elliott> I'm going to release it under the General Public Except For Gregor Richards License.
18:22:13 -!- SimonRC has joined.
18:22:20 <Gregor> elliott: NON-FREE
18:22:28 <elliott> Anyone can read, modify and redistribute the code so long as it is under the GPEFGRL, apart from Gregor Richards.
18:22:31 <Gregor> elliott: CHINESE DISSIDENT PROBLEM IF I WERE A CHINESE DISSIDENT
18:22:39 <elliott> Gregor: wat
18:22:42 <elliott> :D
18:22:44 -!- fizzie` has joined.
18:23:00 <Deewiant> !bfjoust skippy (>)*8(>(+)*10[(-)*9[-]]>)*10
18:23:12 <EgoBot> Score for Deewiant_skippy: 1.7
18:23:19 <elliott> Perhaps my ( takes a cycle.
18:23:35 <Deewiant> !bfjoust skippy (>)*8(>(-)*10[(-)*9[+]]>)*10
18:23:53 <EgoBot> Score for Deewiant_skippy: 1.0
18:23:57 <elliott> Yah, that seems likely.
18:24:18 <Deewiant> !bfjoust skippy (>)*8(>(-)*10[(-)*22[-]]>)*10
18:24:31 <EgoBot> Score for Deewiant_skippy: 1.0
18:24:35 -!- pikhq_ has left (?).
18:24:41 -!- pikhq_ has joined.
18:24:49 <pikhq_> What the fucking hell was that?
18:25:06 <Deewiant> !bfjoust skippy (>)*8(>(-)*10[(-)*22[-]]>)*5(>(+)*10[(+)*22[+]]>)*5
18:25:13 <elliott> Sieve:  >>>>>>>>>>>>>>>>>>>>>
18:25:13 <elliott> Kettle: >>>>>>>>>>>>>>>>>>>><
18:25:13 <elliott> Right wins (40)
18:25:16 -!- fizzie has quit (Ping timeout: 276 seconds).
18:25:19 <elliott> AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRGHHHHHHHHHHHHHHHH
18:25:22 <EgoBot> Score for Deewiant_skippy: 1.0
18:25:30 <pikhq_> irssi was convinced that this was irc://irc.esper.net/esoteric
18:25:47 -!- pikhq_ has changed nick to pikhq.
18:25:49 <Deewiant> !bfjoust skippy (>)*8(>(-)*10[(-)*22[-]]>>(+)*10[(+)*22[+]]>)*5
18:26:00 <EgoBot> Score for Deewiant_skippy: 1.0
18:26:10 <pikhq> And yes, it *was* actually sending stuff to irc.esper.net.
18:26:42 <Deewiant> !bfjoust skippy (>)*8(>(-)*10[(-)*22[-]]>>(+)*10[(+)*22[+]]>)*5[[-]]
18:26:53 <EgoBot> Score for Deewiant_skippy: 1.2
18:27:53 <Deewiant> !bfjoust delirium (>)*8(>(-+-)*10[(-)*22[-]]>>(+-+)*10[(+)*22[+]]>)*5(-)*10[(-)*22[-]]
18:28:06 <EgoBot> Score for Deewiant_delirium: 1.4
18:28:46 <Deewiant> !bfjoust delirium (>)*8(>(-.-)*5[(-)*22[-]]>)*10(-)*10[(-)*22[-]]
18:28:58 <EgoBot> Score for Deewiant_delirium: 1.3
18:29:14 <Gregor> elliott: CODE CODE CODE CODE CODE CODE CODE CODE CODE
18:29:37 <elliott> Gregor: Okay, fine. But. Can I convince you to make egojsout capable of printing out a trace without the cycle count, and without the flag stuff?
18:29:45 <elliott> I dun wanna manually transform the two entire runs to diff them >_<
18:30:13 <Gregor> Why without the cycle count? Just output your own cycle count :P
18:30:22 <Gregor> I can understand not outputting Unicode flags :P
18:30:24 <elliott> Gregor: Without the flag then :P
18:30:32 <Deewiant> One run of sed shouldn't be a problem :-P
18:30:46 <elliott> Yeah, but it's two runs of not being lazy.
18:30:50 <Gregor> elliott: CODE FIRST
18:34:35 <Deewiant> !bfjoust delirium (>)*8(>[(-)*2[+]]>)*10[+[--[+++]]]
18:34:52 <EgoBot> Score for Deewiant_delirium: 4.8
18:35:32 <Deewiant> !bfjoust delirium (>)*8(>[(-)*2[+]]+>)*10[+[--[+++]]]
18:35:43 <EgoBot> Score for Deewiant_delirium: 2.4
18:36:23 <Deewiant> !bfjoust delirium (>)*8(>[(-)*2[+]]+)*21
18:36:33 <EgoBot> Score for Deewiant_delirium: 11.7
18:37:10 -!- GreaseMonkey has quit (Quit: The Other Game).
18:37:16 <Deewiant> !bfjoust delirium <
18:37:20 <EgoBot> Score for Deewiant_delirium: 0.0
18:43:38 <Sgeo> How much stuff would break with 127 as a flag instead of 128?
18:43:53 <Sgeo> We'd need new names for the 4 polarities
18:47:08 <elliott>  +[                       tripwire tripped! the opponent is working on our flag! 111 cycles into program. opponent cannot have reduced flag by more than 47. wait 98 and start 2-cycle defend
18:47:14 <elliott> quintopia: BEEP BEEP "." IN COMMENT
18:47:21 <elliott>  <-[                      tripwire tripped! the opponent is working on our flag! 111 cycles into program. opponent cannot have reduced flag by more than 47. wait 98 and start 2-cycle defend
18:47:21 <elliott> MOAR
18:48:02 <Deewiant> I'm more annoyed by the "tripewire" comments
18:48:12 <elliott> Tripe wire :D
18:49:03 -!- fizzie` has changed nick to fizzie.
18:49:47 -!- zzo38 has joined.
18:50:59 -!- zzo38 has set topic: This topic message is upsidedown.  | http://208.78.103.223/esoteric/ | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
18:51:57 <Gregor> Whoah, when you read it upside-down it makes perfect sense D-8
19:00:51 <zzo38> Did you know that TeXnicard can now convert DVI+GF to PBM correctly? I even made a file with the TeX logo and it works.
19:01:24 <impomatic> umopepisdn si ebassew?
19:01:30 <impomatic> I don't get it :-(
19:02:51 -!- sebbu has joined.
19:05:13 <elliott> Gregor: So are we ditching ()% and making it be ()* for everything or what?
19:05:26 <elliott> I think I kinda like the aesthetics of %...
19:05:28 <Gregor> * and % are equivalent
19:06:32 <quintopia> elliott: thanks. i doubt removing them will change anything.
19:06:38 <elliott> Gregor: I'm kinda tempted to make the distinction, i.e. make (a{b}c)*n invalid, if only because %n looks kinda nice.
19:06:55 <elliott> Gregor: And also because, theoretically, someone might want to make an exponential program :P
19:07:13 <quintopia> impomatic: 6 is a better upside-down g
19:07:13 <Gregor> elliott: I couldn't care less if you make the distinction or not :P
19:07:30 <quintopia> impomatic: a is a better upside-down e
19:07:35 -!- SimonRC has quit (Ping timeout: 255 seconds).
19:07:37 <elliott> Gregor: When do we get diabetic_philip? Or did you make that?
19:07:53 <Gregor> elliott: 'twas a faillol
19:08:15 <zzo38> Can you invent Underload with continuations?
19:08:17 -!- zeotrope has quit (Ping timeout: 240 seconds).
19:09:19 <impomatic> umopapisdn si a6essaw?
19:10:23 -!- ais523 has joined.
19:12:15 <elliott> hi ais523
19:12:23 <quintopia> impomatic: put ฟ at the beginning and you've got it
19:12:24 <ais523> hi
19:12:45 <elliott> ais523: good news: the Lance Bug is fixed
19:12:51 <elliott> and I'm finishing off my {}% implementation now
19:12:51 <ais523> what was causing it?
19:12:52 <Gregor> THANKS TO ME
19:12:59 <Gregor> Off-by-one error.
19:12:59 <elliott> ais523: One () stack for both programs.
19:13:04 <Gregor> Namely, off by one stack.
19:13:05 <ais523> haha, that's subtle
19:13:06 <elliott> :D
19:13:10 <Gregor> The number of stacks was off by one.
19:13:21 <quintopia> elliott: time until completion?
19:13:22 <ais523> I don't think that falls into any category of common error
19:13:25 <ais523> although my students do it occasionally
19:13:29 <ais523> confusing global and local state, perhaps?
19:13:36 <elliott> quintopia: not long at all until lance.c is complete; report.c tweaking will take a short while
19:14:03 <elliott> Weeding out the invalid programs on the hill will take a few minutes, shoving it all into EgoBot will take like 15.
19:14:11 <elliott> It should be done tonight.
19:14:45 <ais523> !bfjoust definder http://sprunge.us/LdAT
19:14:48 <ais523> !bfjoust definder2 http://sprunge.us/IBDL
19:14:49 <ais523> let's go!
19:15:10 <EgoBot> Score for ais523_definder: 26.5
19:15:14 <elliott> lmao
19:15:19 <ais523> expected
19:15:29 <ais523> definder has known losses to two strategies common on the hill
19:15:30 <elliott> ais523: oh, does definder2 make definer get a better score or something? :P
19:15:32 <elliott> right
19:15:34 <elliott> which strategies?
19:15:34 <elliott> poke?
19:15:36 <elliott> and?
19:15:40 <EgoBot> Score for ais523_definder2: 41.0
19:15:50 <ais523> definder : definder2 :: defend12 : defend13
19:15:58 <elliott> 41.0; not bad
19:16:05 <elliott> wow, the hill has really exploded lately
19:16:07 <ais523> and defence and careless
19:16:13 <elliott> defend13, I think, started it
19:16:20 <elliott> programs are very smart now
19:16:27 <elliott> hmm, double_tripwire_avoider is #2 now
19:16:31 <ais523> also, how did EgoBot do that so fast? my local testing took half an hour
19:16:45 <elliott> Dunno.
19:17:00 <Gregor> It took you a half hour just to run that against all the other programs?
19:17:05 <ais523> yep
19:17:13 <elliott> Deewiant: monorail is at the bottom.
19:17:14 <ais523> I think because I'm using a one-run version of egojoust
19:17:22 <ais523> so it has to parse the program again for every tape length and polarity
19:17:22 <elliott> egojoust _is_ one-run
19:17:25 <elliott> oh
19:17:33 <Deewiant> elliott: I know.
19:17:43 <elliott> Deewiant: Gonna save it? :P
19:17:56 <elliott> I can't believe rushpolarity, wiggle3, slowrush... are all still on the hill.
19:18:00 <elliott> Those programs are real tough.
19:18:11 <elliott> IIRC rushpolarity is just a polarity-flipped version of one of myndzi's :P
19:18:12 <ais523> definder2 beats wiggle3, defensively
19:18:21 <ais523> and without exploiting its detection
19:18:25 <Deewiant> maglev's the improved version, there's not much worth saving in monorail
19:18:47 <Deewiant> If you meant saving a copy of the code: it's so short that I remember it by heart :-P
19:18:48 <Sgeo> How can a polarity-flipped version of anything beat out the original on the hill?
19:18:52 <ais523> the big news about definder{,2} is: it can defend against three-cycle clears moderately reliably
19:19:02 <elliott> what's a three-cycle clear again?
19:19:06 <ais523> [-.]
19:19:08 <elliott> Deewiant: No, I just meant save it from death :P
19:19:14 <elliott> ais523: ah
19:19:15 <elliott> hmm, the oldest program on the hill is neon_glow
19:19:16 <ais523> basically, a clear designed to beat defend programs by screwing up their timing
19:19:21 <elliott> (>(+{>}-)%9)*2(>)*5([---[+]]>)*21
19:19:24 <elliott> impressively short
19:19:55 <Deewiant> !bfjoust magslow -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[(+)*9[-.]])*20>(.-)*10000
19:20:00 <EgoBot> Score for Deewiant_magslow: 40.4
19:20:01 <elliott> heh, there are no programs from 2010 on the hill
19:20:10 <ais523> (+{>}-)%9 would probably be a lot clearer as (+)*9>(-)*9
19:20:13 <elliott> seven from 2009, and the rest from just days ago
19:20:17 <elliott> the hill sure has been shaken up
19:20:19 <Gregor> lawl
19:20:30 <ais523> wow, defend7 is still there
19:20:38 <ais523> despite being really exploitable nowadays
19:20:43 <elliott> defend9 is too.
19:20:48 <elliott> I thought defend9 was crap nowadays :P
19:20:52 <Deewiant> !bfjoust steamroller <
19:20:58 <EgoBot> Score for Deewiant_steamroller: 0.0
19:21:17 <Gregor> Oh god my steamroller is stuck in reverse!
19:21:31 <fizzie> Heh, I added that "flag death only in two steps" property to chainlance, and it's actually a pessimization from egojoust now for real code. It runs this test-hill in 2.5 seconds (compared to 0.5 for egojoust); for the "synthetic benchmark" of "(.)*100000" vs itself it's a lot faster though, 0.05s vs 1s; and for "." vs itself it's 0.05s vs. 0.30s.
19:21:48 <elliott> :-D
19:21:59 <fizzie> (Well, it's either a pessimization or the death-check fails; but the results are exactly identical to egojoust, so I would think it works correctly.)
19:22:06 <quintopia> ais523: does definder's sequence work starting from most initial values?
19:22:21 <ais523> quintopia: it's designed to be tolerant to a certain amount of offsetting, etc
19:22:23 <fizzie> Lessons to learn: leave code generation to real compilers instead of blind translators.
19:22:33 <ais523> in fact, it's optimised to be tolerant to as much of that as is possible
19:22:41 <ais523> I did a computer search to find out what the maximum possible tolerance was
19:22:51 <quintopia> ais523: what fraction of starting values can it work from?
19:22:57 <elliott> hmm, oh dear
19:23:03 <elliott> ((a)*0)*-1 will lag lance up
19:23:06 <elliott> I need to remove *0s
19:23:12 <elliott> oh wait
19:23:13 <elliott> I do :)
19:23:21 <ais523> the actual lock can deal with a value up to 49 distant from where it thinks the flag is
19:23:28 <elliott> btw, important news
19:23:32 <elliott> in lance, *-1 will loop for 100K, not 10K
19:23:35 <elliott> 10K is just a bug in egobot
19:23:37 <elliott> so, uh, yeah
19:23:42 <elliott> if you rely on that... you're an idiot
19:24:09 <ais523> and 49 is the theoretically optimal value, I think
19:24:20 <Gregor> *egojoust
19:24:20 <ais523> at least, unless there's a mistake in my program
19:24:24 <quintopia> ais523: 49 in either direction?
19:24:31 <ais523> yep
19:24:47 <quintopia> ais523: and it can defend indefinitely from any of those values?
19:24:52 <ais523> in order to deal with offset clears, etc., this translates to waiting 98 cycles before starting the clear
19:25:05 <ais523> and yes, /but/ it ends up driving the value past 0 sometimes, that's unavoidable
19:25:13 <ais523> and some enemy programs change strategy upon that happening
19:25:24 <ais523> that's the most common reason for definder winning on short tapes but losing on long tapes
19:25:25 <elliott> Hmm, I just need to error out if you have * after a {}-enclosing (), and if you have % after a normal (), right?
19:25:29 <Gregor> !bfjoust furry_furry_bondage_girls (-)*127(>)*9([[-]]>)*21
19:25:32 <elliott> I never need to go and find another pair of ()s that might satisfy?
19:25:39 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 15.2
19:25:50 <quintopia> well, i knew that'd be unavoidable...as long as it drives it past it and not to it, that's okay :P
19:26:09 <ais523> well, it can drive it to 0 for one cycle, but will always change it in the same direction on the next cycle
19:26:22 <ais523> so it only dies if the opponent reverses direction, which makes it at least a five-cycle clear by definition
19:26:28 <ais523> and it can't deal with five-cycles anyway
19:26:29 <elliott> THX FOR ANSWERS GUYEZ
19:27:03 <coppro> !bfjoust suicide [-.]
19:27:13 <EgoBot> Score for coppro_suicide: 19.2
19:27:16 <coppro> WTF
19:27:19 <Deewiant> :-D
19:27:23 <Gregor> I am worse than suicide YESSSSSSS
19:28:08 <Gregor> !bfjoust furry_furry_bondage_girls (-)*127(>+>-)*4(>[[-]])*21
19:28:19 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 16.7
19:28:57 -!- olsner has quit (Quit: Leaving).
19:29:01 <quintopia> why do you keep submitting programs like that expecting they'll do any better :P
19:29:15 -!- Tritonio has quit (Quit: Leaving).
19:29:38 <Gregor> I'm hoping that some day the hill will adjust itself to be weak to mind-bogglingly-obvious strategies due to too much fighting/inbreeding between good ones :P
19:30:10 <Deewiant> !bfjoust maglev -(>)*8<+<<-<(-)*10<(+)*10<(+)*30(>)*6(>[(+)*9[-]])*20>(.-)*-1
19:30:17 <EgoBot> Score for Deewiant_maglev: 27.3
19:31:30 <quintopia> Gregor: nice theory, if completely wrong :P
19:31:40 <Deewiant> !bfjoust maglev ->+(>)*7+<<-<(-)*10<(+)*10<(+)*30(>)*5(>[(+)*9[-]])*20>(.-)*-1
19:31:51 <EgoBot> Score for Deewiant_maglev: 24.5
19:32:16 <quintopia> in fact, the whole reason we have such a big hill is so that mind-bogglingly obvious strategies that *do* work will stick around long enough that everyone learns to adapt to them.
19:32:33 <Deewiant> !bfjoust maglev ->++(>)*7+<----<-<(-)*10<(+)*10<(+)*30(>)*5(>[(+)*9[-]])*20>(.-)*-1
19:32:39 <EgoBot> Score for Deewiant_maglev: 25.6
19:32:46 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[(+)*9[-]])*20>(.-)*10000
19:33:01 <EgoBot> Score for Deewiant_maglev: 38.8
19:33:29 <elliott> ais523: Can I have a simple program using ({})%, and another program not using it, where the result is known?
19:33:34 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<(+)*30(>)*6(>[(+)*9[-]])*20>(.-)*10000
19:33:41 <EgoBot> Score for Deewiant_maglev: 38.0
19:33:43 <elliott> <quintopia> in fact, the whole reason we have such a big hill is so that mind-bogglingly obvious strategies that *do* work will stick around long enough that everyone learns to adapt to them.
19:33:50 <elliott> quintopia: no, we have a big hill because gregor made it big
19:33:53 <elliott> it's fixed-size
19:34:07 <quintopia> yes indeed
19:34:08 <Deewiant> !bfjoust maglev -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[(+)*9[-]])*20>(.-)*10000
19:34:21 <EgoBot> Score for Deewiant_maglev: 38.9
19:34:34 <quintopia> gregor made it big because we asked him to. we asked him to because it cut down on inbreeding by some amount.
19:34:35 <Deewiant> !bfjoust magslow -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[(+)*9[-.]])*20>(.-)*10000
19:34:39 <EgoBot> Score for Deewiant_magslow: 40.3
19:34:47 <ais523> elliott: the problem is, {}% programs tend not to be simple
19:34:50 <ais523> I'm trying to think of something
19:35:18 <elliott> ais523: It doesn't even have to have []s in it :P
19:35:28 <elliott> (>{+}>)%n or whatever would be fine.
19:35:31 -!- SimonRC has joined.
19:35:39 <ais523> !bfjoust (>)*8(>([+{[+]}>-<])%21)*256
19:35:39 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
19:35:45 <ais523> !bfjoust decoytuner3 (>)*8(>([+{[+]}>-<])%21)*256
19:35:50 <EgoBot> Score for ais523_decoytuner3: 9.5
19:35:53 <ais523> that one isn't very good
19:36:04 <ais523> I'll try it against a simple program on egojsout
19:36:57 <ais523> elliott: try that against [>[-]+++++]
19:37:14 <elliott> ais523: OK, thanks
19:37:27 <zzo38> What is the method of accessing remote files from EgoBot?
19:37:35 <zzo38> (Other than bfjoust)
19:37:57 <Gregor> EgoBot only lets you use remote files as input for interpreters.
19:38:06 <ais523> it has a nontrivial win/loss record on kettle polarity
19:38:07 <ais523> (and obviously loses quite badly on sink)
19:38:08 <ais523> zzo38: generally you can't, but BF Joust programs are put online
19:38:09 <elliott> zzo38: pass a URL
19:38:09 <ais523> for HackEgo, you can tell it to pastebin its files
19:38:25 <zzo38> Gregor: For which interpreters?
19:38:27 <elliott> you're all misinterpreting zzo38, I think
19:38:35 <elliott> he means how do you, from within EgoBot, cause it to access remote files
19:38:40 <ais523> !bfjoust decoytuner3 (>)*8(>([+{[+]}>+<])%21)*256
19:38:46 <elliott> you forgot to turn off your parser's error-correction when reading his line
19:38:46 <EgoBot> Score for ais523_decoytuner3: 8.8
19:38:51 <variable> http://gatoni.gr/wp-content/themes/zenlite/images/banner.jpg -> ha!
19:38:58 <Gregor> wget :P
19:39:09 <elliott> no, he means, like !bfjoust foo http://
19:39:12 <elliott> I'm not sure what the answer is, though
19:39:16 <elliott> at least that's what i think he means
19:39:24 <elliott> variable: That's an ancient xkcd, how has everybody not seen it :P
19:39:47 <variable> elliott: I've seen most of them - but I don't remember them all
19:39:58 <variable> I assumed it was either abstruse goose or xkcd
19:40:09 -!- olsner has joined.
19:41:24 <elliott> lance.c:287: warning: ' ' flag used with โ€˜%nโ€™ gnu_printf format
19:41:27 -!- pumpkin has joined.
19:41:28 <elliott> The relevant line:
19:41:29 <elliott>         fprintf(stderr, "%d : Oi -- you have a * or a % not followed by a digit. Did your parents drop you on your head as a kid? (%c)\n", n, *p);
19:41:50 <elliott> $ ./lance '(>+>-)*4(>[(-)*9[+]])*21' '>>>>>>>>(>[-[++[---]]])*21'
19:41:50 <elliott> 1 : Oi -- your nesting is too deep, birdbrains.
19:41:52 <elliott> No it's not...
19:42:09 <ais523> elliott: you put a bare % in the string
19:42:14 <ais523> so you wrote % space n
19:42:14 <elliott> indeed
19:42:30 <ais523> I tend to nowadays use %s with constant strings, rather than embed them into the printf format
19:42:37 <ais523> due to, umm, reflex vs. SQL injection, I suppose
19:42:42 -!- copumpkin has quit (Ping timeout: 276 seconds).
19:43:41 <Gregor> elliott: scanf("%c", &yn); if (yn == 'y' || yn == 'Y') fprintf(stderr, "Oh, I'm ... I'm terribly sorry ... but your program is still invalid.\n");
19:44:02 <elliott> :D
19:44:08 <quintopia> obtw, Gregor: it'd be nice if the trace on egojsout displayed the programs as-is, without whitespace removed. not sure how you're stripping it, but is it difficult to put back in?
19:44:18 <elliott> quintopia: That would be annoying to do.
19:44:26 <elliott> Signed, -person whose implementation strategy in that area is identical to egojsout's.
19:44:29 <zzo38> I think wget doesn't seem to work on there, though, maybe
19:44:30 <Gregor> quintopia: I intentionally left it out because defend13 is friggin' enormous :P
19:44:56 <Gregor> !sh wget http://www.google.com/ -O /dev/null
19:44:56 <EgoBot> --2011-02-13 20:08:22--  http://www.google.com/
19:45:17 <elliott> !sh wget http://thepiratebay.org/ -O /dev/null
19:45:17 <EgoBot> --2011-02-13 20:08:43--  http://thepiratebay.org/
19:45:23 <ais523> Gregor: defend14 is rather larger
19:45:24 <elliott> LAME
19:45:27 <Gregor> Nope, doesn't set the environment variable since you're really not meant to do it from there.
19:45:31 <zzo38> Gregor: I can't get anything more than that, it seems
19:45:43 <Gregor> Too bad, that's not what EgoBot is for.
19:45:51 <zzo38> I can't seem to make it request files in my computer, or use wc, or whatever
19:45:56 <Gregor> Too bad, that's not what EgoBot is for.
19:46:05 <quintopia> Gregor: space_elevator is enormous even without the whitespace. you aren't saving much.
19:46:14 <elliott> How on EARTH could the nesting be too deap.
19:46:18 <zzo38> It doesn't really matter that much, I was just wondering why it does that.
19:46:35 <elliott> deap :D
19:46:43 <elliott>   if (neststki >= sizeof(neststk)/sizeof(ins_t *)) { \
19:46:43 <elliott>     fprintf(stderr, "%d : Oi -- your nesting is too deep, birdbrains.\n", n); \
19:46:45 <Gregor> zzo38: It rejects all communication except to localhost, and has a proxy on localhost to allow certain HTTP connections.
19:48:54 <zzo38> It would seem that knowing how to make it work is important if you want to add a user interpreter?
19:49:24 <Gregor> zzo38: No. If the input is "http*something*", then it will be downloaded first out of your control.
19:49:39 <zzo38> O, OK, so that's how it works.
19:50:35 <zzo38> Can the program used to install the user interpreter be remote?
19:50:38 <elliott> Hey ais523, that program is too deeply nested :P
19:50:49 <Gregor> zzo38: Yes, but it'll only download once.
19:50:51 <ais523> elliott: %256 should be easily handlable
19:50:59 <ais523> if it can't be, that defeats the whole point of using %
19:51:00 <elliott> ais523: No, as in, the nest stack gets too big.
19:51:02 <elliott> It's obviously a bug :P
19:51:06 <elliott> But a CONFUSING one.
19:51:07 <elliott> Oh.
19:51:09 <ais523> ah
19:51:10 <elliott> Maybe it wraps arou... no.
19:51:11 <elliott> hmm
19:51:11 <zzo38> Gregor: It shouldn't need to download more than once, I think
19:51:18 <elliott> ais523: in "signed >= unsigned", does the latter get coerced to signed
19:51:21 <elliott> or the former to unsigned?
19:51:33 <elliott> I could see, e.g. neststki becoming negative accidentally.
19:51:40 <Deewiant> unsigned
19:51:44 <Deewiant> I'm pretty sure
19:51:45 <elliott> Joy.
19:51:50 <Deewiant> In any case, you should be explicit about it and cast :-P
19:52:09 <ais523> I think it casts to unsigned, but I'm not sure
19:52:19 <elliott> It should never be a problem, I just have a bug :P
19:52:21 <ais523> it's sufficiently confusing that people normally cast explicitly rather than using the defaults
19:54:46 <elliott> In what world is "1 >= sizeof(neststk)/sizeof(ins_t *)" OH OH OH
19:54:47 <elliott> OHHH
19:54:50 <elliott> OH! that makes sense.
19:54:51 <elliott> It's malloced now.
19:54:54 <elliott> X-D
19:55:12 <elliott> Segmentation fault
19:55:13 <elliott> Woop woop
20:03:59 <elliott> wait...argh!
20:04:28 <elliott> how did this break the rest of my program?!
20:04:49 <zzo38> Now what did you break?
20:06:26 -!- zzo38 has quit (Quit: This quit message is rightsideup.).
20:07:19 -!- sebbu2 has joined.
20:07:36 <Sgeo> elliott, dont ever tell me that DS9 can never be soap opera'y
20:08:03 <ais523> I like zzo38's quit message
20:09:15 <elliott> Now this is confusing.
20:10:44 -!- sebbu has quit (Ping timeout: 240 seconds).
20:12:36 -!- cheater- has quit (Ping timeout: 240 seconds).
20:15:08 -!- cheater- has joined.
20:15:38 <elliott> Sieve:  HOUSE
20:15:38 <elliott> HOUSE
20:15:38 <elliott> >80  00  00  00  00  00  00  00  00 <80 -- >0, <9
20:15:38 <elliott> HOUSE
20:15:38 <elliott> Segmentation fault
20:15:39 <elliott> O KAY
20:16:24 <quintopia> FIX ITTTTTT
20:16:48 -!- pumpkin has quit (Read error: Connection reset by peer).
20:17:00 -!- copumpkin has joined.
20:17:06 <elliott> WHERE THE HELL IS THIS SEGFAULTING
20:17:09 <elliott> COPUMPKIN WHAT DID YOU DO
20:17:16 <elliott> Hey Gregor, wanna find my bug again
20:17:28 <copumpkin> power went out
20:17:51 <quintopia> elliott: gdb :P
20:17:59 <elliott> yeah this is like the one case where gdb is useful
20:18:02 <elliott> random segfault
20:18:26 <elliott> Program received signal SIGSEGV, Segmentation fault.
20:18:27 <elliott> 0x00000000004016e0 in parse (into=0x1603080, p=0x0, n=1) at lance.c:198
20:18:27 <elliott> What.
20:18:33 <elliott> It failed much after that with -O2 >_<
20:18:37 <elliott> OH
20:18:40 <elliott> Forgot to supply arguments
20:19:35 -!- sebbu2 has quit (Read error: Connection reset by peer).
20:20:26 -!- sebbu has joined.
20:21:23 <elliott> Program received signal SIGSEGV, Segmentation fault.
20:21:23 <elliott> 0x0000000000400c66 in duel (p=0x1603080, q=0x603080, pol=SIEVE, tapesz=10) at lance.c:133
20:21:23 <elliott> 133          repeatstk[prog][++repeatstki[prog]] = progs[prog]->arg;
20:21:24 <elliott> O KAY
20:21:27 <elliott> oh, I need calloc
20:21:32 <elliott> I think
20:21:33 <elliott> wait, no
20:22:22 <elliott> oh, duh
20:23:09 <elliott> WTF
20:28:39 <elliott> ais523: http://sprunge.us/FjRH Looks like a draw to me!
20:28:51 <elliott> wait.
20:28:53 <elliott> It actually does.
20:29:05 <elliott> YAY, OFF BY ONE.
20:32:26 <elliott> [0x1602100] ( (arg=1, jmp=0x16021a0)
20:32:26 <elliott> Try "21".
20:32:47 <elliott> OH DUR
20:34:12 <elliott> ais523: defend14 is bugged
20:34:17 <elliott>       ([(+)*128(>)* 7(.+)*57(<)* 7)*5
20:34:22 <elliott> "* 7"
20:34:24 <elliott> needs to be *7
20:34:36 <ais523> elliott: no? space is a comment
20:34:39 <ais523> and it makes the comments line up
20:34:42 <ais523> *columns
20:34:48 <ais523> the space is there deliberately to make the program more readable
20:34:50 <elliott> ais523: No, * has to be followed by an integer.
20:34:56 <ais523> it is, it's followed by 7
20:35:03 <elliott> also, they don't actually line up
20:35:07 <elliott>       ([(+)*128(>)* 7(.+)*57(<)* 7)*5
20:35:07 <elliott>         ((+)*128(>)* 8(.+)*56(<)* 8)*5
20:35:08 <elliott> ais523: No.
20:35:10 <elliott> ais523: It's followed by a space.
20:35:25 <ais523> and yes, that is correct, I got Emacs to autoindent it for me
20:35:30 <elliott> ais523: Do you think (+)*  x12xoy=3 is a valid program?
20:35:35 <ais523> the other columns line up, that one's offset because of the [
20:35:37 <elliott> Meaning (+)*123?
20:35:40 <ais523> elliott: yep
20:35:47 <elliott> ais523: Too bad, 'cuz it's not.
20:36:01 <ais523> OH LOOK LANCE PARSES INCORRECTLY
20:36:18 <elliott> Gregor: Does egojoust support "(+)*  x12xoy=3"?
20:37:51 <ais523> !bfjoust (>)*8(>++++[-])*x2 x1
20:38:00 <EgoBot> Score for ais523_____8_______-___x2: 6.3
20:38:01 <ais523> umm, forgot the name
20:38:09 <ais523> !bfjoust simpleoffset (>)*8(>++++[-])*x2 x1
20:38:17 <EgoBot> Score for ais523_simpleoffset: 6.3
20:38:18 <elliott> It uses atoi.
20:38:21 <elliott> So I know for a fact it doesn't support that.
20:38:30 <ais523> unless it filters the xs out first
20:38:34 <elliott> It doesn't.
20:38:40 <Gregor> elliott: Uhhh ... no?
20:38:47 <elliott> Gregor: ais523 thinks it means (+)*123.
20:38:57 <Gregor> wtf
20:39:05 <Gregor> ais523: No
20:39:32 <ais523> allowing spaces after * is definitely useful, anyway
20:39:33 -!- iconmaster has quit.
20:39:39 <ais523> just like C allows spaces around +
20:39:45 <ais523> there's no sensible reason to disallow it
20:39:47 <Gregor> ais523: DO NOT WANT
20:40:08 <ais523> you mean I have to make my programs less readable just so they parse?
20:40:13 <ais523> that's the opposite of the spirit of BF
20:40:30 <elliott> ...with what definition of "the spirit of BF"?
20:40:30 <elliott> ais523: <prog> := '' | <ins> <prog>; <pcntprog> := '' | <ins> <pcntprog> | '{' <pcntprog> '}'; <ins> := '+' | '-' | '<' | '>' | '[' <prog> ']' | '(' <prog> ')*' <int> | '(' <pcntprog> ')%' <int> | [^+-<>\[\]()*%]
20:40:30 <ais523> you're making it /whitespace-sensitive/
20:40:40 <ais523> you're making /brainfuck/ /whitespace-sensitive/
20:40:45 <elliott> ais523: With the constraint that <pcntprog>s must include one and only one {}.
20:40:53 <elliott> ais523: No.
20:40:56 <ais523> yes!
20:40:58 <Deewiant> Yes.
20:41:03 <elliott> ais523: We're making a /brainfuck/ /macro language/ whitespace-sensitive.
20:41:18 <ais523> that's still an incredibly bad idea
20:41:21 <Deewiant> "We're making ... /brainfuck/ ... whitespace-sensitive."
20:41:27 <Deewiant> You said it!
20:41:31 <Gregor> elliott: ais523 is not implementing an interpreter. He who codes chooses. QED.
20:41:46 <elliott> Gregor: Really? I'm going to require all programs start with "ELLIOTT IS FUCKING AWESOME".
20:41:50 <ais523> Gregor: I have one already, that expands {} in place just fine
20:41:51 <elliott> Fuck yeah.
20:41:55 <ais523> it's just slow for other reasons
20:41:57 <Gregor> elliott: I own EgoBot :P
20:41:59 <elliott> "expands {} in place" "just fine"
20:42:02 <elliott> Contradiction.
20:42:06 <elliott> Expanding {} = not fine.
20:42:50 <elliott> Gregor: What if I pipe all programs through s/[^+\-<>[\]()*%]//g beforehand :P
20:42:54 <elliott> *sed '...'
20:42:56 * variable should watch this channel more often - I learn a lot
20:42:58 <Gregor> elliott: I own EgoBot :P
20:43:02 <elliott> Gregor: What if I pipe all programs through s/[^+\-<>[\]()*%]//g beforehand :P
20:43:20 <Gregor> elliott: I notice the lack of digits.
20:43:21 <elliott> That doesn't actually work with that syntax but whatever
20:43:27 <elliott> Gregor: Err, right X-D
20:44:02 <elliott> Huh, tr -d '+\-<>[]()*%0-9' doesn't work.
20:44:08 <Gregor> I don't like the notion that    (...)*3 // 3 because I'm brilliant  expands 33 times
20:44:16 <elliott> ...yeah, that's awful.
20:44:30 <elliott> At the most, I'll allow spaces before the count.
20:44:35 <Gregor> Or, for that matter, (...)*3\n\n\r\n\t\v3 because I'm brilliant
20:44:38 <ais523> elliott: add a second (null) arg? or do you need -c as well
20:44:47 <elliott> ais523: "-d"
20:44:51 <elliott> Oh
20:44:51 <elliott> Right
20:44:52 <elliott> -c
20:44:52 <elliott> :P
20:45:02 <ais523> I'm trying to remember exactly what -d does
20:45:05 <Gregor> Yeah, I might be willing to tolerate whitespace between ), {*,%} and the number
20:45:17 <ais523> Gregor: --- // 3 - signs because Gregor is apparently brilliant
20:45:32 <elliott>  $ tr -cd '+\-<>[]()*%0-9'; echo
20:45:32 <elliott> (abc)*3             // This is 3 because I'm brilliant
20:45:32 <elliott> ()*33
20:45:33 <elliott> Yeahno
20:46:14 <Gregor> NEW IDEA
20:46:18 <elliott> ais523: How about ')' ('*' | '%') (' ' *) <int>
20:46:19 <ais523> elliott: the same thing happens with every other command
20:46:22 <elliott> ais523: How about ')' ('*' | '%') (' ' *) <int>
20:46:24 <elliott> And no, wrong
20:46:28 <elliott> That creates _new_ commands
20:46:30 <ais523> elliott: I'd tolerate that
20:46:30 <Gregor> elliott: We'll make it UTF-8, and you have to represent the repeat count as the relevant Unicode character.
20:46:33 <elliott> This abomination modifies _existing_ commands
20:46:37 <elliott> Gregor: It is done.
20:46:41 <Gregor> elliott: That way, you can't have any space between digits, since there are no digits.
20:47:08 <elliott> Admittedly the // thing is academic because ()*0 exists
20:47:31 <Gregor> Well, anything invalid is also a comment, I was just putting that there to make my intention clear :P
20:48:43 <elliott> It makes sense because in BF, whitespace is allowed between /instructions/
20:48:45 <elliott> i.e. atomic units
20:48:54 <elliott> The fact that an integer takes multiple characters to represent is an implementation detail
20:49:10 <elliott> You can have anything you want before and after it, so (+)*xasldkjad\n\n3 is valid,
20:49:16 <elliott> but you can't put random crap in the middle.
20:49:29 <elliott> Also, )* and )% totally count as one instruction.
20:49:37 <elliott> Now wait until ais523 says that he uses ")     %" to make things line up nicely.
20:49:55 <elliott> Apparently defend14 has an unmatched [.
20:50:04 <elliott>       ([(+)*128(>)*7(.+)*57(<)*7)*5
20:50:08 <elliott> ais523: You're a very bad person.
20:50:15 <elliott>         (]
20:50:16 <elliott> Very, very bad.
20:50:30 <elliott> OK, time to find another competitor that *doesn't* break the rules :-P
20:50:31 <ais523> possibly not deliberately
20:50:39 <elliott> ais523: "(]" looks quite deliberate
20:50:43 <ais523> but that thing was really massively long and complex, and had to be made to work in Egojous
20:50:45 <ais523> *Egojoust
20:50:55 <elliott> ais523: agreed; however, you might want to fix it in time for lance
20:51:03 <ais523> does defend13 work? it's a bit simpler
20:52:25 <elliott> ais523: I'll try
20:53:35 <quintopia> ais523: definder beats space_elevator on one polarity because the zeroes *never* correspond to my ]. I suspect fiddling with the timings for the rush code wouldn't help either, since it would just make it so 2-cycle clears fail on the *other* polarity instead. i can't for the life of me think of a way a standard rush tactic can beat both defend9 and definder without using *huge* offsets (or something like that binary search thing that ...
20:53:57 <elliott> Yess, it runs correcty
20:53:59 <elliott> *correctly
20:54:01 <ais523> quintopia: definder gets a lot of random polarity-sensitive wins like that
20:54:20 <elliott> I'm not sure whether to bother preprocessing (A[B)*nC(D]E)*n...
20:54:25 <ais523> I don't think it's possible to make it do any better; it turns out to be impossible to deal with 2 and 3 cycle on both polarities and also maintain the average to prevent something zeroing
20:54:32 <elliott> It's really trivial to fix it in programs, and writing a preprocessor is like condoning it :P
20:54:57 <elliott> $ time ./lance "$(cat spelevator)" "$(cat defend13)" >/dev/null
20:54:58 <elliott> real0m0.040s
20:54:58 <elliott> NOT BAD
20:55:21 <Deewiant> Compared to EJ?
20:55:30 <elliott> Deewiant: Dunno, but tbh, the raw performance is irrelevant.
20:55:36 <Gregor> elliott: The fact that lance takes raw code instead of files as args = lame :P
20:55:43 <elliott> The fact is that EgoBot's % handling is O(slow) and O(big), and mine isn't.
20:55:50 <elliott> Gregor: It's a test >_<
20:55:58 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
20:55:59 <Gregor> lawl@O(slow)
20:56:32 <elliott> Gregor: BTW, it's okay if my modified report.c keeps all breakdowns, right?
20:56:44 <elliott> It'd be nice to be able to go to breakdowns/quintopia_space_elevator.txt and see :P
20:56:50 <Gregor> elliott: Preferable, I never modified mine to do so because it didn't actually know which was added :P
20:56:50 <elliott> And would also solve the whole clashing thing.
20:57:16 <Gregor> (And I was lazy)
20:57:18 <elliott> Gregor: Can I make !egojoust link you to the breakdown at the beginning? :-p
20:57:20 <elliott> *:-P
20:57:21 <elliott> *!bfjoust
20:57:32 <Gregor> NO
20:57:38 <elliott> Gregor: Because otherwise you'd have to go to the file specifically named after your program :(
20:57:41 <elliott> Unless I maintained a symlink X-D
20:57:46 <quintopia> ais523: ... saccharin_philip uses) what's it most sensitive to?
20:58:41 <elliott> Gregor: Can Apache handle symlinks? :P
20:59:02 <elliott> Gregor: But also, if it did that, then you could refresh and it'd be someone else's program instead :(
20:59:07 <elliott> What if it just /notice user'd the URL?
20:59:11 <elliott> Then it wouldn't bother anyone else.
20:59:17 <Gregor> Of course Apache can handle symlinks.
20:59:38 <Gregor> elliott: How about just include the breakdown URL with the score :P
20:59:52 <Gregor> That way it's one line, it's done by then, and everybody can see it.
20:59:53 <quintopia> `quote add <elliott> The fact is that [egojoust's] % handling is O(slow) and O(big), and mine isn't.
20:59:55 <elliott> Gregor: I was going to go all "OMG BUT WHAT IF IT TAKES AGES", but then I realised that lance is fucking fast :P
20:59:58 <elliott> quintopia: fail
21:00:17 <Deewiant> quintopia: `addquote, I think
21:00:21 <quintopia> oh
21:00:21 <elliott> $ time ( for i in $(seq 50); do ./lance "$(cat spelevator)" "$(cat defend13)" >/dev/null; done )
21:00:21 <elliott> real0m0.952s
21:00:25 <elliott> Yah, that should be fine then.
21:00:26 <HackEgo> No output.
21:00:30 <elliott> I'll try spelevator v. spelevator.
21:00:39 <elliott> 1.261s :P
21:00:43 <quintopia> `addquote <elliott> The fact is that [egojoust's] % handling is O(slow) and O(big), and mine isn't.
21:00:44 <HackEgo> 304) <elliott> The fact is that [egojoust's] % handling is O(slow) and O(big), and mine isn't.
21:00:57 <quintopia> why didn't he put it all in the quote program? why break it all up like that? :P
21:01:09 <elliott> Unix philosophy, bitch.
21:01:11 <elliott> `cat bin/addquote
21:01:12 <HackEgo> #!/bin/sh \ [ "$1" ] || exit 1 \ printf "%s\n" "$1" >>quotes \ echo $(wc -l quotes | cut -d' ' -f1)") $1"
21:01:18 <elliott> Besides, it was a separate program right from the start.
21:01:23 <elliott> With Gregor's crazy SQLite system.
21:01:40 <elliott> `delquote 304
21:01:42 <HackEgo> *poof*
21:01:48 <elliott> `addquote [on egojoust] <elliott> The fact is that EgoBot's % handling is O(slow) and O(big), and mine isn't.
21:01:49 <HackEgo> 304) [on egojoust] <elliott> The fact is that EgoBot's % handling is O(slow) and O(big), and mine isn't.
21:01:57 <elliott> No MISQUOTING unless it's FUNNY
21:02:03 <quintopia> so you didn't take the opportunity to do it in one program? "why make one program to handle quotes when i could make *two!*"
21:02:17 <elliott> quintopia: Unix philosophy.
21:02:20 <elliott> quintopia: Unix philosophy.
21:02:20 <elliott> quintopia: Unix philosophy.
21:02:20 <elliott> quintopia: Unix philosophy.
21:02:42 <quintopia> unix philosophy is do one thing and do it well. that one thing can be "quotes" in my mind
21:02:49 <elliott> One thing = add a quote.
21:02:51 <elliott> One thing = view a quote.
21:03:01 <quintopia> or "handle all quote processing"
21:03:03 <elliott> They all use the common format (a plain text file) and do one thing on it.
21:03:06 <elliott> quintopia: That's multiple things.
21:03:11 <quintopia> it's one thing :P
21:03:14 <quintopia> also
21:03:14 <elliott> No, it's not.
21:03:17 <elliott> Ask Ken Thompson.
21:03:38 <quintopia> i didn't misquote
21:03:54 <quintopia> using [] to replace certain strings is standard journalistic practice
21:04:04 <elliott> Standard journalistic practice, but also still misquoting :P
21:04:13 <elliott> Being able to grep for the source of a quote is nice, anyway.
21:04:16 <Sgeo> So is busybox anti-Unix?
21:04:25 <quintopia> how can it be misquoting if it's part of the *standard for quotes*?
21:04:34 <elliott> It's a quote, and it's not what I said.
21:04:39 <elliott> Therefore it's not a true quote, and therefore a mis- quote.
21:04:57 <quintopia> it's understood that you said everything not in []
21:05:07 <quintopia> and therefore the quote is correctly reflecting what you said
21:05:54 <elliott> This is tedious.
21:06:01 <quintopia> have you finished lance yet
21:06:19 <elliott> Yes. I just have to do one final parser change.
21:06:24 <elliott> Gregor: Can you link me to report.c? :-P
21:06:54 <elliott> Gregor: OHOH what was that program with {{}} that you had to change for egojoust?
21:07:10 <elliott> ais523: You are okay with ")*" not allowing a space, right? :-P
21:07:29 <ais523> between the ) and the *? if you really insist, although I don't see a reason to enforce it
21:07:56 <elliott> ais523: Makes the parser simpler :P
21:08:06 <elliott> ais523: By whitespace, I also mean comments.
21:08:13 <elliott> It'd actually make bugs a bit hard to catch...
21:08:23 <elliott> Consider (abc)[... ten pages...][stray *]
21:08:30 <elliott> Although ... wait, naw.
21:08:32 <elliott> I'll allow it.
21:10:11 <elliott> Gregor: PINGY
21:10:46 <elliott> ais523: does defend14 tie with defend13?
21:10:51 <ais523> no
21:10:57 <elliott> ah, not always
21:10:58 <elliott> but sometimes
21:11:16 <ais523> they have different timings on their defence detection
21:11:39 * elliott just wants two complicated programs that tie :P
21:11:44 <elliott> At least some of the time.
21:13:47 <Deewiant> What's "complicated" :-P
21:14:07 <elliott> Deewiant: With ()%, preferably.
21:14:38 <Deewiant> space_elevator doesn't have any, d'oh
21:15:12 <elliott> Deewiant: X-D
21:15:14 <elliott> Preferably, I said.
21:15:19 <elliott> Not madatorililily.
21:15:57 <Deewiant> Well, some of my skippy/delirium programs from earlier tie with space_elevator
21:16:09 <Deewiant> They're not complicated but maybe space_elevator is enough? :-P
21:16:32 <elliott> Paste the one you think is best :P
21:16:40 <Deewiant> I can't remember which ones tie and which don't
21:16:43 <elliott> Gregor: PINGGGG
21:16:45 <elliott> info
21:16:46 <elliott> info
21:16:47 <elliott> !info
21:16:48 <Deewiant> !bfjoust delirium (>)*8(>[(-)*2[+]]+>)*10[+[--[+++]]]
21:16:49 <EgoBot> EgoBot is a bot for running programs in esoteric programming languages. If you'd like to add support for your language to EgoBot, check out the source via mercurial at https://codu.org/projects/egobot/hg/ . Cheers and patches (preferably hg bundles) can be sent to Richards@codu.org , PayPal donations can be sent to AKAQuinn@hotmail.com , complaints can be sent to /dev/null
21:17:09 <EgoBot> Score for Deewiant_delirium: 3.1
21:17:39 <Deewiant> !bfjoust delirium (>)*8(>[(-)*2[+]]>)*10[+[--[+++]]]
21:17:43 <EgoBot> Score for Deewiant_delirium: 5.2
21:17:56 <Deewiant> !bfjoust delirium (>)*8(>(-.-)*5[(-)*22[-]]>)*10(-)*10[(-)*22[-]]
21:18:28 <EgoBot> Score for Deewiant_delirium: 2.6
21:18:37 <Deewiant> elliott: That one
21:18:42 <elliott> Deewiant: thx
21:18:43 <Deewiant> <><>>>>>>>>>>>>>>>>>> <>>><><><XXXXX>>>>>>>
21:19:17 <elliott> $ ./lance "(>)*8(>(-.-)*5[(-)*22[-]]>)*10(-)*10[(-)*22[-]]" "$(cat spelevator)"
21:19:18 <elliott> Sieve:  <><>>>>>>>>>>>>>>>>>>
21:19:18 <elliott> Kettle: <>>><><><=====>>>>>>>
21:19:19 <elliott> Looks right to me
21:19:22 <ais523> Gregor: NetHack tournament players complain at /dev/null quite a lot
21:20:34 <quintopia> space_elevator isn't that complicated. it's just long. because it special cases every single tape length
21:20:50 <coppro> !bfjoust suicide_faster (-)*128
21:20:54 <EgoBot> Score for coppro_suicide_faster: 8.5
21:21:00 <elliott> yeah
21:21:05 <elliott> Gregor Gregor Gregor Gregor Gregor
21:21:08 <Deewiant> It's complicated compared to the <100-byte programs :-P
21:21:10 <quintopia> what do the suicide programs beat?
21:21:47 <coppro> !bfjoust suicide_slower [][-.]
21:22:03 <quintopia> coppro: that second code block is never reached
21:22:11 <quintopia> okay
21:22:32 <EgoBot> Score for coppro_suicide_slower: 6.3
21:22:46 <quintopia> it might be sometimes by really silly programs that do something like (>[(-)*256])*29
21:23:22 <elliott> Gregor: I like how report.c has a variable called fyb
21:23:24 <Gregor> Suicide can beat careless turtles in some timings.
21:23:34 <Gregor> elliott: So does your mom.
21:25:26 <ais523> suicide beats tripwire avoiders, too
21:25:46 <ais523> because they jump off the tape before the suicide can kill itself
21:25:55 <quintopia> Gregor: *beat*? or just win some rounds against?
21:26:05 <fizzie> elliott: Heh, I converted chainlance into a computed-goto driven interp (with the same actions chainlance uses, except expressed in C) dubbed 'cranklance', and now I get (ego, chain, crank) for the test-hill (0.5, 2.5, 0.4) seconds, for 100k-cycle wait (0.30, 0.05, 0.12) seconds. I think I'll use the crank for some hill-clustering/result-visualization/whatever tests. (Maybe I should've also tried generating C from chain.)
21:26:40 <elliott> fizzie: I might be interested in integrating that with lance at some point if the better ({}) semantics will work with it.
21:27:08 <Gregor> quintopia: Mmm, probably beat.
21:27:24 <quintopia> i'll have to check that out
21:27:46 <elliott> Gregor: pinggg
21:27:49 <elliott> Gregor: OKAY SO
21:27:54 <elliott> Gregor: that program that had nested {{}}s
21:27:56 <elliott> that you had to fix for egobot
21:27:57 <elliott> which is that
21:28:13 <Gregor> elliott: The philip family, lemme paste one unexpanded.
21:28:18 <Gregor> Also, *egojoust
21:28:24 <elliott> Yesyesyes
21:29:05 <Gregor> elliott: high_fructose_corn_philip: http://sprunge.us/Ijgi
21:29:44 <elliott> Gregor: Is that the current hill versi00000n?
21:29:47 <elliott> Oooon.
21:30:01 <Deewiant> No, that's http://codu.org/eso/bfjoust/in_egobot/Gregor_high_fructose_corn_philip.bfjoust
21:30:12 <elliott> Deewiant: ...he expands it for egojoust use.
21:30:14 <elliott> So it might very well be.
21:30:19 <elliott> $ ./lance "$(cat spelevator)" "$(cat hfcp)"
21:30:19 <elliott> Segmentation fault
21:30:23 <elliott> Congratulations, Gregor.
21:30:29 <Deewiant> I thought you just meant if it's the same exact source
21:30:34 <elliott> Ah.
21:31:20 <quintopia> Gregor: ohhh, i see. mapping_turtle only increments 127 times before going on, which sometimes means it has had time to get to zero when the other program is modifying its own flag
21:31:31 <Gregor> quintopia: Yup
21:31:50 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
21:33:06 <fizzie> elliott: I'm not entirely certain what those are, yet; I haven't been following. Currently it only accepts (a[b{c}d]e)*N style code where leftover [s in "a[b" exactly match extra ]s in "d]e", and there is only one {} on a ()-level; it doesn't do any special nested {}s. So (a{b(c{d}e)*Nf}g)*M goes, ((a{b{c}d}e)*N)*M not, if you were allowing something like that. But of course it could be changes.
21:33:38 <elliott> fizzie: Irrelevant.
21:33:42 <elliott> fizzie: The thing is that you expand %N.
21:33:50 <elliott> You don't have to.
21:33:57 <fizzie> Well, no, I don't.
21:34:08 <elliott> Oh?
21:34:12 <elliott> What do you do then?
21:34:33 <elliott> The nested thing is (a(b{c{d}e}f)%Mg)%N.
21:34:39 <elliott> The innermost {} associates with the %N one.
21:34:55 <elliott> fizzie: But how do you handle ({}) then?
21:38:22 <Gregor> fizzie: You should put your impl on the wiki btw
21:38:30 <fizzie> Well, it does loopless (a{b}c)%n the obvious way (decrement repeat-count on { and jump to (; reinitialize count at } and have ) jump there) and the jiggles the repeat counters when loops jump over the {} body. That was what I could sensibly retrofit in the plain-dumb asm-translator with everything in regs. It might well have bugs; it was a really quick retrofit on the existing code that didn't allow loops crossing {}.
21:38:57 <elliott> fizzie: that fails
21:39:01 <elliott> you need to keep it around after {
21:39:04 <elliott> and then decrement for } and )
21:39:15 <elliott> But, er, crossing {} how?
21:39:22 <elliott> (a[b{c]}d)?
21:39:23 <elliott> That's not valid.
21:40:16 <ais523> I think fizzie meant (a[b{c}d]e)%n, which is the intended use
21:40:31 <Sgeo> http://thehill.com/blogs/blog-briefing-room/news/143671-gop-rep-i-made-a-terrible-mistake-in-last-years-patriot-act-vote A republican I agree with? What.
21:40:51 <ais523> Sgeo: I don't think there's anything inherently intrinsically stupid or wrong about democrats or republicans
21:41:04 <ais523> the two parties are so close to each other that it makes sense that moderate republicans are saner than extreme democrats
21:41:13 <ais523> even if everyone in the world outside the US thinks the democrats are marginally saner
21:41:19 <elliott> Ha, ais523 got to the "Sgeo, honestly, they're the fucking same" thing before me.
21:41:24 <elliott> Except with less profanity.
21:41:42 <fizzie> ais523: Yes, what he said.
21:41:42 <Gregor> Should've said "inb4same
21:41:42 <Gregor> "
21:41:47 * Sgeo pokes pikhq 
21:41:52 <ais523> I rarely use profanity altogether, because there's rarely a context where it makes sense
21:42:04 <elliott> What's scary is that Democrat supports think they're _liberal_ *because they support the Democrats*.
21:42:07 <ais523> (saying "brainfuck" or whatever is fine, although it rather annoys my parents)
21:42:09 <elliott> *a lot of Democrat supporters
21:42:21 <fizzie> Anyway, it doesn't fail for loopless code, and I didn't want to touch it much yet.
21:43:03 <elliott> How the heck did Gregor's philip segfault my code.
21:43:17 <elliott> Phew. At least it is during parsing.
21:43:58 <Sgeo> http://www.reddit.com/user/GreenEggsAndBacon extremist Democrat?
21:46:55 <elliott> yay, NULL!
21:46:59 <elliott> ais523: who loves NULL?!
21:47:03 <elliott> everyone loves NULL!
21:47:04 <elliott> the best pointer!
21:47:25 <ais523> it's certainly the most unique pointer
21:47:36 <elliott> everyone's unique!
21:49:31 <elliott> wow, bfjoust.pl is insane
21:49:46 <elliott>     89 print "Both programs are waiting."
21:49:47 <elliott>     90   if $tape[$i1] && $tape[$i2] && $p1 =~ /^\[\]/ && $p2 =~ /^\[\]/;
21:49:50 <elliott> ooh, that's clever
21:49:57 <elliott> (but probably not worth optimising for)
21:50:30 <elliott> ais523: wait, if without ()s?
21:50:32 <elliott> is that perl 6?
21:50:37 <elliott> no, it'd be @tape[$i1] for perl 6
21:50:49 <ais523> elliott: it's a reverse if
21:50:52 <ais523> command if conditoin
21:50:54 <ais523> *condition
21:50:54 <Deewiant> x if y;
21:50:57 <elliott> right
21:50:58 <Deewiant> if (y) x;
21:51:08 <ais523> just split over two lines because perl(1) isn't whitespace-significant like lance is
21:51:09 <Deewiant> if (y) { x } rather
21:51:15 <elliott> ais523: ho ho ho
21:51:17 <elliott> ais523: I fixed that :P
21:51:29 <elliott> ais523: the only thing is that "1x3" is the same as 1
21:51:37 <elliott> because, I figure in BF, the thing is that you can put whatever you want /between instructions/
21:51:39 <elliott> instruction = atomic unit
21:51:44 <ais523> hmm, OK
21:51:49 <elliott> that an integer takes multiple bytes to represent is an implementation detail of ASCII
21:52:00 <elliott> it's an atomic unit, so the actual integer digits have to be together to count as one
21:52:14 <fizzie> Does egojsout do the (a[b{c}d]e)%N thing correctly (disregarding nested {} for now) or what should I use as a reference? (Well, maybe I could use just an expanded program as a reference, actually.)
21:52:15 <elliott> hmm, does perl 6 make "foo bar { baz }" the same as "baz foo bar" in all cases?
21:52:19 <elliott> it removed the parens from if
21:52:28 <Gregor> fizzie: egojsout does everything right.
21:52:29 <elliott> fizzie: egojsout is pretty much perfect, but I'd use lance as the reference.
21:52:32 <elliott> Because it's almost done :P
21:52:37 <elliott> Gregor: Apart from some ties, right?
21:52:40 <elliott> e.g. [-] vs [-]
21:53:04 <Gregor> elliott: ... no, those tie properly.
21:53:07 <elliott> Oh.
21:53:17 -!- MigoMipo has quit (Read error: Connection reset by peer).
21:53:29 <Gregor> The confusion was with respect to whether suicide-vs-flag-dropped is a tie.
21:53:36 <Gregor> I consider those a tie, but there's some contention.
21:53:44 <ais523> Gregor: suicide by dropped flag, versus what?
21:53:45 <fizzie> Gregor: It doesn't interpret  >++(-[.{.}.])%3<[-]  identically to  >++-[.-[.-[...].].]<[-]  even though unless I've misunderstood the syntax, the latter is the expanded form of the former.
21:53:49 <ais523> as in, what's the other death?
21:54:12 <Gregor> ais523: As in, one side's flag is down for two turns, but on the second turn the other side jumps ship.
21:54:22 <ais523> oh, that's a win for the side which was slightly slower at suicidng
21:54:22 <elliott> hmm, I don't think I handle that
21:54:24 <ais523> *suiciding
21:54:33 <ais523> because its flag hasn't been down for two turns yet
21:54:35 <elliott> someone give me a program to test that :P
21:54:40 <elliott> but yes, what ais523 said
21:54:41 <elliott> it's a tie
21:54:45 <elliott> because you die at the _end_ of the second turn
21:54:49 <elliott> that your flag is 0
21:54:50 <ais523> elliott: *it's not a tie?
21:54:55 <elliott> or, the beginning of the turn after
21:54:57 <elliott> which never happens
21:54:58 <elliott> ais523: right
21:54:59 <elliott> not a tie
21:55:11 <Gregor> fizzie: Wha? No, it does that right.
21:55:41 <fizzie> Gregor: I just put those two programs in, and the left end of the tape looks different from the right end in the trace.
21:56:04 <elliott> I appear to handle that.
21:57:03 <fizzie> (Also right wins in all of them, even though it should be a tie according to my logic, assuming the programs are indeed intended to be identical.)
21:57:03 <Gregor> Whoah, wtf, they do look different.
21:57:11 -!- jcp has quit (Ping timeout: 276 seconds).
21:57:17 <elliott> LANCE IS PERFECT HAVE I MENTIONED
21:57:27 <elliott> Gregor CAN'T CODE (but he can fix my bugs)
21:58:05 <elliott> hmm, afaict this code is perfect
21:58:22 <elliott> there's no reason neststk[i] for i < neststki-1 should ever be NULL
21:58:25 <elliott> and yet it is
21:59:14 <Gregor> Off-by-one error :)
21:59:56 <elliott> Gregor: >_<
22:00:04 <Gregor> fizzie: Fixt.
22:00:14 <Gregor> elliott: I was actually referring to MY off-by-one error :P
22:00:30 <elliott> Gregor: We need to make a language without any integers, even implicitly in e.g. list length/depth, so that off-by-one errors are impossible.
22:00:36 <elliott> ONLY THEN will we have conquered the beast.
22:00:48 <elliott> Also, no names, thus eliminating two of the two hard problems of computer science.
22:00:53 <elliott> All we have to tackle then is cache invalidation.
22:01:02 -!- jcp has joined.
22:01:50 <Sgeo> How to make data structures that can only store a continuous amount of items
22:01:53 <Sgeo> And not discrete
22:02:05 <Gregor> Sgeo: By not using digital computers?
22:02:07 <Sgeo> How would you go about making a continuous data structure in the first place?
22:02:09 <Sgeo> Hmm
22:02:14 <elliott> Use neural nets instead.
22:02:26 <pikhq> Analog computing solves all problems.
22:02:27 <pikhq> ALL
22:02:32 <elliott> PROBLEMS
22:02:38 <Gregor> ARE
22:02:42 <elliott> ABOUT
22:02:48 <Gregor> TEN
22:02:51 <elliott> BIRDS
22:02:57 <Gregor> WORTH
22:03:02 <pikhq> TEN
22:03:05 <elliott> DOUBTFUL
22:03:15 <Gregor> GALLONS
22:03:18 <pikhq> OF
22:03:22 <Gregor> BROTH
22:03:22 <elliott> NON-EUCLIDEAN
22:03:30 <elliott> (X-D)
22:03:36 <elliott> WHILE
22:03:41 <pikhq> (ah, the broth non-euclidean)
22:03:49 <elliott> (It was non-euclidean broth on my end, which was hilarious)
22:03:51 <elliott> (Carry on)
22:04:09 <Sgeo> (I just turned VLC's volume down to 3%)
22:05:02 -!- Gregor has set topic: All problems are about ten birds worth ten doubtful gallons of broth non-euclidean. | http://208.78.103.223/esoteric/ | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
22:05:27 -!- elliott has set topic: All problems are about ten birds worth ten doubtful gallons of non-euclidean broth. | http://208.78.103.223/esoteric/ | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
22:05:34 <elliott> Mine is far better, and I won't let lag ruin a good sentence :P
22:05:44 <Sgeo> And some chef will come in here randomly
22:05:46 <Gregor> Uhh, I think ours is better.
22:05:50 <elliott> By what metric.
22:05:50 <Gregor> It is the broth non-euclidean.
22:05:52 <elliott> Yours doesn't even make sense.
22:06:10 <Sgeo> Tea Earl-gray hot.
22:06:12 <Gregor> It's still a noun phrase, and non-euclidean is still a descriptive adjective, ours is just more stylish.
22:06:42 <Gregor> Like how a poem might rhyme by saying you're going to the garden green instead of the green garden.
22:06:44 <Gregor> Long story short:
22:06:48 -!- Gregor has set topic: All problems are about ten birds worth ten doubtful gallons of broth non-euclidean. | http://208.78.103.223/esoteric/ | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
22:07:02 <Sgeo> Words are a problem.
22:07:33 <elliott> All problems are about ten birds
22:07:38 <elliott> worth ten doubtful gallons
22:07:42 <elliott> of broth non-euclidean /
22:07:45 <elliott> And as you go
22:07:46 <elliott> along the path
22:07:49 <elliott> to the garden green
22:07:51 <elliott> know this: /
22:07:54 <elliott> All problems are about ten birds
22:07:57 <elliott> worth ten doubtful gallons
22:08:00 <elliott> of broth non-euclidean.
22:08:03 <elliott> Gregor: PRIZE PLZ
22:08:19 * Gregor gives elliott the Nobel Prize in ... chemistry.
22:08:28 <elliott> I was thinking the Fields Medal.
22:08:44 <elliott> Non-euclidean broth would definitely be worth a Nobel Prize in chemistry :P
22:09:21 -!- GreaseMonkey has joined.
22:10:05 <ais523> grr, I need to finish this Firefox extension that rewrites all the links on Wikia to end ?useskin=monobook
22:10:21 <ais523> hmm, I suppose I could just log in instead
22:10:22 * Sgeo wants a Chrome extension now
22:10:32 <ais523> but where's the fun in that?
22:11:39 <fizzie> Heh, as far as the >++(-[.{.}.])%3<[-] test case is concerned, my loop-counter-jiggling approach to (a[b{c}d]e)%N is just fine... but it's not perhaps the simplest thing ever to adapt to nested {}s. "Oh well."
22:11:40 <elliott> ais523: Can't you just use greasemonkey or something?
22:11:42 <elliott> (no ping intended)
22:12:01 <ais523> possibly
22:12:12 <elliott> HOW CAN NESTSTK POSSIBLY GET NULLS IN IT
22:12:13 <pikhq> It'd be easier.
22:12:34 <ais523> oh, the login doesn't actually work
22:12:58 <elliott> pikhq: ?
22:13:04 <elliott> oh, yes
22:13:10 <elliott> greasemonkey would be easier than writing a full ff extension
22:13:20 <elliott> In fact, I suspect there might be some "rewrite URLs" extension already.
22:14:15 <ais523> hmm, so I go and tell Firefox to no longer allow and block cookies from Wikia at pseudorandom, now the login page doesn't load at all
22:14:55 <quintopia> ais523: how did you come up with 85 as the optimal decoy size? does it have to do with careless turtle type strategies? if you put both polarities of decoys on the tape, isn't a smaller decoy better?
22:15:07 <ais523> it's a third of 256
22:15:17 <ais523> but you're right, thinking about it all that's needed is to fool enemy offset clears
22:15:57 <ais523> OK, I give up, logging into Wikia is harder than writing a Firefox extension
22:16:11 <Sgeo> !bfjoust weird_decoy >>>(-)*23
22:16:29 <quintopia> because the average time to clear n and -n is 256 cycles for all large enough n, yes?
22:16:29 <elliott> ais523: seriously, search for a rewrite urls extension
22:16:31 <elliott> `addquote <ais523> OK, I give up, logging into Wikia is harder than writing a Firefox extension
22:16:35 <elliott> ais523: it'll save you a lot of effort
22:16:40 <ais523> I just did
22:17:02 <EgoBot> Score for Sgeo_weird_decoy: 1.1
22:17:11 <ais523> gah, why is there not a "view source" option?
22:17:49 <HackEgo> 305) <ais523> OK, I give up, logging into Wikia is harder than writing a Firefox extension
22:18:24 <ais523> hmm, this looks quite close to what I would have written
22:18:50 -!- copumpkin has joined.
22:18:57 <ais523> and it doesn't seem malicious
22:18:59 <ais523> I'll install it
22:19:07 <ais523> (it isn't popular enough for me to assume it's nonmalicious based on network effects)
22:19:27 <elliott> ais523: hmm, is it not reviewed?
22:19:30 <elliott> most addons on mozilla.org are
22:19:36 <ais523> too new
22:19:37 <elliott> and if you trust firefox you trust them
22:19:38 <elliott> ah
22:19:50 <ais523> that's why I was being extra-careful
22:20:14 -!- augur has quit (Ping timeout: 272 seconds).
22:21:52 <elliott> I wonder what on earth introduced this bug... and how it even... and... what...
22:21:59 <elliott> It just... maybe...except... whaaat.
22:22:02 <elliott> THIS MAKES NO SENSE
22:22:07 <elliott> Hey Gregor, wanna debug my program
22:22:30 <ais523> it doesn't seem to work, at least
22:22:40 <ais523> it's translating the URLs correctly, but not rewriting them
22:22:50 <elliott> (gdb) print neststk[0]
22:22:50 <elliott> $3 = (ins_t *) 0x16030f0
22:22:50 <elliott> (gdb) print neststk[1]
22:22:50 <elliott> $4 = (ins_t *) 0x1603110
22:22:50 <elliott> (gdb) print neststk[2]
22:22:50 <elliott> $5 = (ins_t *) 0x0
22:22:52 <elliott> (gdb) print neststk[3]
22:22:54 <elliott> $6 = (ins_t *) 0x0
22:22:56 <elliott> hmm
22:23:03 <elliott> Yet neststki is 2.
22:23:07 <elliott> ...but that's what it should be.
22:23:11 <elliott> But I start at neststki-1.
22:23:17 <elliott> ais523: how do you go back in gdb?
22:23:20 <elliott> IIRC you can do it
22:23:24 <elliott> though perhaps not after a segfault
22:23:24 <ais523> I'm not sure, it's a really new feature
22:23:27 <elliott> *LOL*
22:23:31 <elliott>       for (int i=neststki-1; i>=0; i++)
22:23:36 <elliott> Hey kids, it's time to play Spot The Bug!
22:23:48 <Deewiant> i++
22:23:55 <elliott> DEEWIANT WINS THE GRAND PRIZE
22:24:01 <elliott> AMUSINGLY, that's an off-by-one error!
22:24:05 <Deewiant> for (unsigned i = neststki; i--;)
22:24:09 <ais523> ah, it only seems to trigger on things entered into the URL bar
22:24:14 <elliott> Well, an off-by-two.
22:24:16 <elliott> (1 vs. -1)
22:24:23 <elliott> Deewiant: Ooh, optomized.
22:24:30 <Deewiant> Just more clear, IMO :-P
22:24:32 <ais523> I need to make it rewrite links too
22:24:33 <Deewiant> And works for unsigned
22:24:34 <quintopia> !bfjoust wirless (>)*8+<-<(+)*18<(-)*19(<(-)*33<(+)*33)*2<(-)*17(>)*9([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*10[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
22:24:42 <EgoBot> Score for quintopia_wirless: 59.4
22:24:47 <Deewiant> Gah
22:24:48 <quintopia> !bfjoust wirless <
22:24:52 <Deewiant> STOP WINNING
22:24:52 <quintopia> !bfjoust wireless (>)*8+<-<(+)*18<(-)*19(<(-)*33<(+)*33)*2<(-)*17(>)*9([[[[-[++[(+)*9.[.-].[.++-------]]]]]]]>[[[[-[++[(+)*9.[-].[.++-------]]]]]]]>)*10[[[[-[++[(+)*9.[.-].[.++-------]]]]]]]
22:24:53 <elliott> Wirless :D
22:24:55 <EgoBot> Score for quintopia_wirless: 0.0
22:25:04 <elliott> $ ./lance '>++(-[.{.}.])%3<[-]' '>++-[.-[.-[...].].]<[-]'
22:25:04 <elliott> Sieve:  >>>>>>>>>>>>>>>>>>>>>
22:25:05 <elliott> Kettle: >>>>>>>>>>>>>>>>>>>>>
22:25:06 <elliott> So er fizzie
22:25:07 <quintopia> ais523: smaller decoy = better
22:25:07 <elliott> What's with that
22:25:13 <EgoBot> Score for quintopia_wireless: 58.6
22:25:19 <elliott> ...how did it go down?
22:25:20 <elliott> >_<
22:25:27 <quintopia> elliott: because it beat wireless
22:25:30 <elliott> X-D
22:25:38 <ais523> quintopia: so long as it's large than the opponent's offset clear; I think I agree
22:25:38 <fizzie> Maybe what's up with it is what was up with egojsout?-)
22:25:58 <elliott> Gregor: What was your off-by-one in egojsout
22:26:28 <fizzie> $ echo '>++(-[.{.}.])%3<[-]' > test_a.b ; echo '>++-[.-[.-[...].].]<[-]' > test_b.b ; ./cranklance test_a.b test_b.b
22:26:28 <fizzie> XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX 0
22:26:42 <fizzie> (It probably bugs a whole lot in other code.)
22:26:42 * quintopia goes to put small decoys in space_elevator :P
22:27:14 <ais523> this is an improvement anyway, I can click on the URL bar and press return to fix the skin
22:27:39 <Gregor> elliott: The up-side went from 0 to len-1, but the downside went from len to 1, so if you looped you'd be off by one on the other side.
22:27:51 <Gregor> That is, if you did a []-loop that went over a {}
22:28:03 <elliott> UPSIDE:
22:28:07 <elliott>       case PARE:
22:28:07 <elliott>         if (progs[prog]->arg == 0)
22:28:07 <elliott>           progs[prog] = progs[prog]->jmp;
22:28:07 <elliott>         else
22:28:07 <elliott>           repeatstk[prog][++repeatstki[prog]] = progs[prog]->arg;
22:28:08 <Sgeo> How do tripwires work?
22:28:09 <elliott>         progs[prog]++;
22:28:11 <elliott>         goto rego;
22:28:17 <elliott>       case ONCE:
22:28:17 <Gregor> Sgeo: Ask ais523 :P
22:28:17 <elliott>         if (++repeatstk[prog][repeatstki[prog]] == progs[prog]->jmp->arg)
22:28:17 <elliott>           repeatstki[prog]--;
22:28:19 <elliott>         else
22:28:21 <elliott>           progs[prog] = progs[prog]->jmp;
22:28:23 <elliott>         progs[prog]++;
22:28:25 <elliott>         goto rego;
22:28:27 <elliott> DOWNSIDE:
22:28:29 <elliott>       case ERAP:
22:28:31 <elliott>         if (--repeatstk[prog][repeatstki[prog]] == 0)
22:28:33 <elliott>           repeatstki[prog]--;
22:28:35 <elliott>         else
22:28:37 <elliott>           progs[prog] = progs[prog]->jmp;
22:28:38 <Deewiant> elliott: FFS, learn to use pastebins.
22:28:41 <elliott>         progs[prog]++;
22:28:43 <elliott>         goto rego;
22:28:45 <elliott> Looks right to me, Gregor. Unless you mean the bug was in []?
22:28:45 <ais523> Sgeo: set a value to nonzero, do [], when you break out of the loop you know the opponent's data pointer was there the turn before
22:28:51 <elliott> Deewiant: I use them all the time, I had a sudden burst of LAZY.
22:28:53 <elliott> Gregor: Show me a diff :P
22:29:12 <Sgeo> ais523, and what's the goal when you see the data pointer there?
22:29:29 <ais523> you use it to time a defensive lock
22:29:46 <elliott> ais523: Or to know when to attack.
22:29:50 <ais523> unless you're impomatic, and crazy enough to try a defensive lock without first setting the pointer
22:30:00 <ais523> elliott: plausibly, but I don't know if anyone's tried that tactic
22:30:02 <elliott> Go close to the opponent, set up a tripwire, wait for it to be tripped, attack madly.
22:30:02 <Gregor> elliott: http://sprunge.us/ZEPW
22:30:09 <elliott> ais523: I think I did and it went badly :P
22:30:25 <ais523> I'm not going to say it's necessarily completely unviable, but I can't think of a sane use for it
22:30:34 <elliott> Gregor: Your } *does* things?
22:30:36 <elliott> Or is that {?
22:30:57 <elliott> My } is a nop.
22:31:02 <Gregor> My } sets the iterator. In principle it shouldn't need to, it's just defensive in case I fucked something up :)
22:31:52 <elliott> Gregor: That first snippet is from your ( code, right?
22:31:59 <Sgeo> !bfjoust badly_implemented_elliot_strategy (>)*8+[]+[>[-]+]
22:32:14 <Gregor> elliott: No, )
22:32:16 <EgoBot> Score for Sgeo_badly_implemented_elliot_strategy: 0.0
22:32:19 <Sgeo> aww
22:32:24 <elliott> Gregor: Err, doesn't ) behave the same whether there's curlies or not?
22:32:33 <Gregor> elliott: No.
22:32:36 <elliott> Why not
22:32:42 <Sgeo> Wait, I'm falling off the edge, aren't  I?
22:33:04 <Deewiant> You might be. Which is why you typically use ()*21 instead of a loop :-P
22:33:07 <Gregor> elliott: With no braces, () can loop up or down, doesn't matter. With braces, ({ must loop up and }) must loop down, or vice-versa. So ) has to know the difference to know which way to change the iterator and which edge case to check.
22:33:36 <elliott> Gregor: I just make ) always count down...
22:33:45 <elliott> normal-( pushes the maximum count, so ) works by counting down.
22:33:45 <Gregor> elliott: Then you're doing it wrong :)
22:33:49 <fizzie> Current cranklance gives a "parse error: matching [...] across (...) levels" error for defend14, defend9, spookygoth, wiggle3, careful, and careless. :/ (At least some of those seem to be doing a generic sort of (])*8 thing though.)
22:33:50 <elliott> braces-( pushes 0, then { counts it up.
22:33:53 <elliott> Then ) counts it down.
22:33:56 <elliott> Gregor: What's wrong with ^
22:34:00 <elliott> fizzie: Yes, those are broken.
22:34:17 <elliott> fizzie: It's ok, we're just going to ditch them until their authors fix. ...or actually someone else has to fix wiggle3.
22:34:18 <Gregor> elliott: When you have both ({ and }) loops, you have to count in both directions for [] to work. I suppose you could also check for [] that jumps over a {} and invert the iterator ...
22:34:32 <elliott> Gregor: I do count in both directions.
22:34:42 <elliott> Gregor: (...{ goes up, and *leaves it on the stack*.
22:34:48 <elliott> Gregor: Then } does nothing, and ) goes down.
22:34:51 <Sgeo> Meh, I can't figure out how to stop on the first non-0 value
22:34:52 <elliott> (Jumping to the } each time)
22:34:55 <Gregor> elliott: OH, I see.
22:35:03 <Gregor> elliott: But then, doesn't ) count up if there is no {}?
22:35:07 <elliott> This being exactly what oerjan said :P
22:35:10 <elliott> Gregor: No. ) counts down.
22:35:14 <elliott> Gregor: Normal ( pushes the max count.
22:35:15 <Deewiant> !bfjoust tripwire (>)*8+[](>[(-)*9[+]])*20(-.)*-1
22:35:18 <elliott> Gregor: Braces ( pushes 0.
22:35:24 <elliott> That way counting down on ) always works.
22:35:25 <Gregor> elliott: OH, you have a distinguished () for each case, got it.
22:35:27 <EgoBot> Score for Deewiant_tripwire: 1.9
22:35:28 <Gregor> elliott: Then you should be fine.
22:35:30 <elliott> Gregor: Just a distinguished (.
22:35:33 <elliott> ) is always the same, like I said.
22:35:34 <Gregor> elliott: I only have one ( and one ), so I check at runtime.
22:35:45 <Gregor> elliott: Yeahyeah, finefine.
22:35:47 <fizzie> Gregor: What cranklance does is that, actually; I count down in both (...{ and }...), and then in [ and ] that cross the {...} part I do rep = N-(rep-1).
22:35:53 <elliott> Gregor: Except that it's NOT working.
22:35:54 <Sgeo> Deewiant, is that what I was triyng to do?
22:35:57 <elliott> $ ./lance '>++(-[.{.}.])%3<[-]' '>++-[.-[.-[...].].]<[-]'
22:35:58 <elliott> Sieve:  >>>>>>>>>>>>>>>>>>>>>
22:35:58 <elliott> Kettle: >>>>>>>>>>>>>>>>>>>>>
22:36:05 <Deewiant> Sgeo: Pretty much.
22:36:11 <Gregor> fizzie: Yeah, that'd work too.
22:36:14 <elliott> ...wait.
22:36:16 <elliott> is that inner bit correct?
22:36:19 <elliott> Shouldn't it be [.]? Wait, no.
22:36:22 <Gregor> elliott: I refuse to respond to tiny bits of pasted code that you THINK contain the error. All or nothing.
22:36:30 <elliott> I didn't say fix the error.
22:36:36 <elliott> I just said that "you should be fine" _- I'm not :P
22:36:37 <elliott> *-
22:36:58 <elliott> But sure, I guess, if you reaaaaaaally want to debug it :P
22:40:43 -!- FireFly has quit (Quit: swatted to death).
22:41:05 <fizzie> I wonder if I should "fix" that "second consecutive 0-flag vs. falling off the tape" tie into a loss; I did it as a tie "naturally", but the Authority (ais523) seems to disagree.
22:41:24 <elliott> It's obviously a loss.
22:41:31 <ais523> well, the thing is, everyone seems to think it's obvious
22:41:33 <elliott> You only expire _after_ the second turn of hopelessness.
22:41:35 <ais523> just they can't agree on what it should be
22:41:37 <elliott> Otherwise, [-] wouldn't draw with [-].
22:41:42 <elliott> well
22:41:45 <elliott> (>)*9(-)*128
22:41:49 <elliott> wouldn't draw on tape length 10
22:41:53 <elliott> because the last - wouldn't happen
22:41:58 <elliott> because it'd happen on the second turn of zeroness
22:42:21 <ais523> another good comparison is [-] to .[-]
22:42:32 <ais523> to me, it's obvious that the first program should lose there, as it suicides faster
22:42:46 <fizzie> ais523: It's just that the Wiki rules for the original variant says "A program loses if: [falls off, flag is zero] -- These conditions [as in, both flag-check and running-off] are only evaluated at the end of each cycle -- If both programs lose simultaneously [it's a tie]", and your variant-specification doesn't exactly alter that latter bit.
22:42:57 <elliott> the original variant was beyond broken
22:43:00 <elliott> we should just forget it ever existed
22:43:03 <ais523> fizzie: the non-original variant changes it to "two cycles"
22:43:15 <fizzie> ais523: Yes, but it doesn't change when the test occurs.
22:43:18 <elliott> that's what happens when a fisheries research biologist tries to program!!!!!!
22:43:22 <elliott> </Sgeomeme>
22:43:35 <Sgeo> Wha?
22:43:45 <fizzie> ais523: Anyway, [-] and .[-] work the same way in both interpretations, don't they?
22:43:46 <ais523> fizzie: indeed; it sees that one flag is down for two cycles (loss), and the other flag is down for one cycle (not a loss)
22:43:52 <Sgeo> elliott, a meme only you care about?
22:43:52 <ais523> and both checks are done at the same time
22:44:11 <fizzie> ais523: That's not what this is about, at least not what I've understood.
22:44:34 <elliott> the disagreement is
22:44:37 <ais523> "now replace the man with a computer"?
22:44:46 <ais523> (B Nomic meme, mostly coming up in ##nomic)
22:44:51 <elliott> (>)*9(-)*128 vs. (.)*138<
22:44:55 <elliott> or 137, I can't figure out which
22:45:13 <fizzie> ais523: As far as I know the argument was about when A's flag has been down for two cycles, and B runs off the tape during the cycle when A's flag is it's second 0; whether that's a tie or a loss.
22:45:25 <elliott> err, right
22:45:27 <elliott> Gregor: confirm?
22:45:30 <ais523> oh, second 0 run off
22:45:52 <ais523> I think that's generally considered to be a loss for the player who runs off, but I don't think it's obvious either way
22:45:59 <elliott> so (>)*9(-)*128.> vs. sitting duck
22:46:00 <quintopia> !bfjoust space_elevator http://sprunge.us/WhYM
22:46:00 <elliott> on tape length 10
22:46:08 <EgoBot> Score for quintopia_space_elevator: 60.2
22:46:15 <elliott> yeah, I think running off the edge is "worse"
22:46:19 <fizzie> As in, whether (-)*128 and (.)*128< should be a tie or not.
22:46:22 <Deewiant> DAMMIT QUINTOPIA
22:46:24 <Gregor> The debate is (>[(-)*128>])*30 vs nothing
22:46:28 <Sgeo> !bfjoust home_tripwire ([]+)*-1
22:46:35 <elliott> So Gregor, found the bug yet :P
22:46:36 <Gregor> Err, wait
22:46:36 <Gregor> Yeah, that's right.
22:46:44 <Gregor> elliott: I realized I don't care.
22:46:47 <EgoBot> Score for Sgeo_home_tripwire: 5.3
22:46:53 <fizzie> GreaseMonkey: My example is shorter. :p
22:46:59 <fizzie> s/GreaseMonkey/Gregor/
22:47:01 <fizzie> Damnable tab.
22:47:03 <elliott> <Gregor> TOTES NOT GONNA FIX EGOJOUST BECAUSE LANCE IS AWESOME
22:47:04 <quintopia> prognosis: space_elevator now beats speedy2
22:47:09 <elliott> <Gregor> lance? Pfft, so yesterday
22:47:17 <elliott> ais523: wow ^
22:47:18 <elliott> !bfjous
22:47:18 <Gregor> elliott: I don't care /to fix it/
22:47:19 <elliott> !bfjoust
22:47:20 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
22:47:32 <elliott> Gregor: FORGOT YOU CAN'T PROGRAM</trollllllll>
22:47:44 <elliott> quintopia: CAN ANYTHING STOP THE SPACE ELEVATOR MASSACRE
22:47:46 <ais523> quintopia: by changing the flag to something that isn't equal to 2 mod 3?
22:47:54 <ais523> or does that not speed it up enough?
22:48:21 <quintopia> ais523: i made the decoys smaller so i could start attacking its flag faster
22:48:39 <Sgeo> quintopia, it's still listed as version 1_0
22:48:45 <ais523> ah, so it's simply a case of outspeeding
22:48:54 <quintopia> sgeo: whoops
22:49:23 <quintopia> !bfjoust space_elevator http://sprunge.us/ahXj
22:49:27 <quintopia> now it says 1_1
22:49:28 <quintopia> happy?
22:49:33 <EgoBot> Score for quintopia_space_elevator: 60.2
22:49:40 <Gregor> D-8
22:49:47 <Deewiant> I refuse to be happy with scores like that
22:50:04 <quintopia> Deewiant: don't get mad. get even!
22:50:40 <Sgeo> We have a possible hero in myndzi
22:50:51 <Deewiant> Hmm, doesn't wireless go too far > before it starts clearing cells?
22:51:24 <ais523> looks like the age of the freakishly complex program is really drawing near
22:51:26 <quintopia> Deewiant: does it ever suicide?
22:51:40 <ais523> is space_elevator intended to be generically good, or to pick on all the existing programs individually?
22:51:45 <Deewiant> It seems like it should on length 10
22:51:55 <Deewiant> Unless my arithmetic is off
22:52:05 <quintopia> Deewiant: check the bfjsout breakdown and see
22:52:08 <elliott> quintopia: now remove all the . comments
22:52:13 <Deewiant> quintopia: It doesn't have a breakdown
22:52:16 <quintopia> elliott: done
22:52:23 <quintopia> sorry
22:52:26 <quintopia> i did it again
22:52:28 <quintopia> egojsout
22:52:31 <Sgeo> quintopia, how does it know tape size?
22:52:40 <quintopia> Sgeo: it doesn't, really.
22:52:40 * elliott is working on antispaceelevator
22:52:48 <elliott> quintopia: <ais523> is space_elevator intended to be generically good, or to pick on all the existing programs individually?
22:53:02 <quintopia> elliott: i was about to answer that. it seems like you're picking on me!
22:53:04 <elliott> I think it's meant to be generically
22:53:08 <ais523> so do I
22:53:16 <elliott> but hey
22:53:18 <elliott> i was right
22:53:20 <elliott> hybrids are possible
22:53:22 <Sgeo> It makes some assumptions thogh
22:53:22 <ais523> I think definder might be tweakable to beat everything except some of impomatic's oddballs
22:53:24 <elliott> quintopia: eat hat plz
22:53:25 <elliott> post video
22:53:28 <ais523> but I'll need to look into it
22:53:37 <quintopia> elliott: sorry. i already ate it.
22:53:42 <elliott> :(
22:54:10 <elliott> < < > > > > > > > > > > > > > > > > > > <
22:54:10 <elliott> < < > > > > > > > > > > > > > > > > > > <
22:54:11 <elliott> how oddball
22:54:32 <quintopia> ais523: i tuned it to beat particular *strategies* not particular programs. it will do well against strategies that are currently being used on the hill, but i don't know how generically good it is.
22:54:44 <ais523> quintopia: seems about right
22:54:49 <ais523> that's what I was doing with definder
22:54:58 <ais523> although I was working from an old hill, which is why it's far from perfect
22:55:30 <quintopia> i think definder has some major promise
22:56:28 <elliott> YES
22:56:32 <elliott> !bfjoust
22:56:32 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
22:56:36 <elliott> !bfjoust anti_space_elevator (>)*9([-[++[(-)*128[-]]]]>)*20(-)*128
22:56:41 <quintopia> esp. since it is one of the few things that beats space_elevator. with some tuning and hybridization, it could dominate.
22:56:41 <EgoBot> Score for elliott_anti_space_elevator: 30.1
22:56:44 <elliott> \o/
22:56:44 <myndzi>   |
22:56:45 <myndzi>  /ยด\
22:56:48 <quintopia> lul
22:56:54 <elliott> hey, 30.1 isn't bad
22:57:00 <elliott> and i beat space_elevator on every tape length and polarity
22:57:01 <Gregor> #30 :P
22:57:12 <elliott> heh, i beat defend14 but not defend13
22:57:23 <elliott> Gregor: meh, high up enough
22:57:28 -!- SimonRC has quit (Remote host closed the connection).
22:57:33 <elliott> it's quite a good strategy, in fact
22:57:35 -!- SimonRC has joined.
22:57:42 <elliott> if you're dealing with decoys at both ends of the spectrum
22:57:52 <elliott> and an opponent that doesn't change its flag
22:57:57 <elliott> just so long as it's not a super-fast rush
22:58:05 <elliott> because you take more cycles per 0 cell
22:58:06 <quintopia> elliott: i could beat that too if i treated my own flag like a decoy
22:58:11 <elliott> quintopia: go for it
22:58:17 <elliott> quintopia: that'd be more interesting to anti-
22:58:23 <elliott> this was disappointingly easy
22:58:28 <Gregor> quintopia: It'd be nice if you described the poke strategy on the wiki btw ;)
22:58:54 <quintopia> Gregor: i was actually working on that article earlier, then it dawned on me that decoys were too big, and i had to check it out
22:58:59 <quintopia> i'll go back to it now
23:00:04 <elliott> quintopia: hey, treat your flag like a decoy first :P
23:02:27 <Gregor> It'd be nice if every strategy on the wiki had a short, canonical program to go with it, even if that program wouldn't actually be very good in and of itself.
23:03:23 <quintopia> elliott: no that's not the way i need to beat that. the way to beat that would be to make my first decoy smaller, and then wait less time to start defending
23:03:28 <quintopia> and yes, it is quite a good strategy
23:03:47 <quintopia> Gregor: i've been adding examples
23:06:32 <elliott> !bfjoust anti_space_elevator (>)*9([-[++[(-)*129[-]]]]>)*20(-)*128
23:06:39 <EgoBot> Score for elliott_anti_space_elevator: 28.7
23:06:55 <elliott> wat
23:06:59 <elliott> how did it do worse :D
23:07:05 <elliott> !bfjoust anti_space_elevator (>)*9([-[++[(-)*129[+]]]]>)*20(-)*128
23:07:17 <EgoBot> Score for elliott_anti_space_elevator: 29.9
23:07:27 <elliott> !bfjoust anti_space_elevator (>)*9([-[++[(-)*128[+]]]]>)*20(-)*128
23:07:30 <Sgeo> elliott_anti_space_elevator.bfjoust vs quintopia_space_elevator.bfjoust:
23:07:30 <Sgeo> <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<
23:07:30 <Sgeo> elliott_anti_space_elevator.bfjoust wins
23:07:32 * Sgeo claps
23:07:33 <EgoBot> Score for elliott_anti_space_elevator: 22.4
23:07:41 <elliott> shrug
23:08:01 <elliott> !bfjoust anti_space_elevator (>)*9([-[++[(-)*128[-]]]]>)*20(-)*128
23:08:05 <EgoBot> Score for elliott_anti_space_elevator: 29.9
23:08:26 <elliott> ...
23:08:30 <elliott> ok, who submitted a program
23:09:12 <Gregor> elliott: It could also just be whatever you knocked off the hill.
23:09:32 <elliott> True.
23:09:55 <elliott> !bfjoust anti_space_elevator (>)*9([-[++[(-)*128[-]]]]>)*20(-)*128[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
23:10:00 <EgoBot> Score for elliott_anti_space_elevator: 29.6
23:10:04 <elliott> x_x
23:10:27 <Deewiant> !bfjoust pendolino -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-]]]])*20>(.-)*10000
23:10:35 <EgoBot> Score for Deewiant_pendolino: 41.6
23:10:43 <elliott> !bfjoust anti_space_elevator (>)*9([-[++[(-)*128[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]>)*20(-)*128
23:11:00 <EgoBot> Score for elliott_anti_space_elevator: 26.4
23:11:09 <elliott> X-D
23:11:34 <Deewiant> !bfjoust pendolino -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-].]]])*21
23:11:43 <EgoBot> Score for Deewiant_pendolino: 40.8
23:13:34 <Deewiant> !bfjoust pendolino -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-].[.-]]]])*21
23:13:53 <EgoBot> Score for Deewiant_pendolino: 41.4
23:14:30 <elliott> We really need something for loops that look like this:
23:14:41 <elliott> -[-[-[-[-[-[-[-[-[-[-[-[-[+(LOTS OF ]S)
23:14:46 <elliott> Any syntax suggestions? :P
23:15:29 <Deewiant> !bfjoust pendolino -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-].[.-]]]])*20>(.-)*-1
23:15:30 -!- SimonRC has quit (Ping timeout: 265 seconds).
23:15:46 <elliott> Gregor: Does egojsout support ([)*n? :P
23:16:20 <EgoBot> Score for Deewiant_pendolino: 36.8
23:17:05 <Gregor> elliott: No
23:17:07 -!- SimonRC has joined.
23:17:17 <Deewiant> !bfjoust pendolino -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-].[.-]]]])*10(>[+[--[(-)*9[+].[.+]]]])*10>[-[++[(+)*9[-].[.-]]]]
23:17:30 <EgoBot> Score for Deewiant_pendolino: 40.9
23:18:16 <Deewiant> !bfjoust pendolino -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-][.-]]]])*21
23:18:23 <EgoBot> Score for Deewiant_pendolino: 38.6
23:18:33 <Deewiant> !bfjoust pendolino -(>)*7+<-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:18:35 <elliott> NOTE TO SELF: Tape length 17.
23:18:41 <EgoBot> Score for Deewiant_pendolino: 42.3
23:18:41 <elliott> Gregor: Then it doesn't support testing against defend14?
23:18:44 <elliott> And the like?
23:18:45 <quintopia> gregor. i may have found a bug in egojsout
23:19:01 <Gregor> elliott: defend14 has ([)???
23:19:11 <elliott> Gregor: Yep. Actually (a[b)*n I think.
23:19:15 <Gregor> >_<
23:19:19 <Deewiant> !bfjoust pendolino -(>)*6-<(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:19:19 <Gregor> quintopia: Yes?
23:19:26 <EgoBot> Score for Deewiant_pendolino: 41.4
23:19:26 <quintopia> Gregor: it actually just stopped simulating this program
23:19:39 <Deewiant> !bfjoust pendolino -(>)*5(+)*10<(-)*10<(-)*30<<(+)*30(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:19:49 <quintopia> Gregor: the traces show the instructions in all the correct places, but the program pointer isn't moving
23:19:50 <EgoBot> Score for Deewiant_pendolino: 42.6
23:20:04 <Gregor> quintopia: And the programs ARE?
23:20:14 <quintopia> Gregor: lemme make sure i can repro first
23:20:25 <elliott> Hmm, I think I've thought of a syntax for my loop thing.
23:20:46 <quintopia> Gregor: do poke on the left and (>)*8(>[(<)*8(-)*33(>)*9([-[++[(+)*9[-]]]]>)*21])*21 on the right. look at tape length 30
23:20:56 <Deewiant> !bfjoust pendolino -(>)*6(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:21:00 <EgoBot> Score for Deewiant_pendolino: 34.5
23:21:05 <elliott> (a{b}c)&3 -> aaabccc
23:21:07 <elliott> Specifically,
23:21:17 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:21:23 <elliott> (a{b}c)&0 -> b; (a{b}c)&(n+1) -> a(a{b}c)&nc
23:21:23 <Gregor> quintopia: You have unmatched [] in (), which egojsout neither supports nor checks for
23:21:27 <elliott> Any objections?
23:21:32 <elliott> For instance,
23:21:35 <EgoBot> Score for Deewiant_pendolino: 43.3
23:21:43 <elliott> (-[+[{-}]])&n
23:21:47 <elliott> generates e.g.
23:21:54 <elliott> +[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-[+[-]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]
23:21:55 <quintopia> Gregor: then it should say parse error instead of simulating the program like it's working
23:22:04 <Gregor> quintopia: It never gives parse errors, I'm lazy :P
23:22:24 <quintopia> Gregor: where is the unmatched bracket?
23:22:24 <elliott> GUYS I PROPOSED NEW SYNTAX, HI
23:22:38 <Gregor> quintopia: (>[(<)*8
23:22:52 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*20<(+)*20(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:23:05 <EgoBot> Score for Deewiant_pendolino: 41.9
23:23:06 <quintopia> Gregor: then you're matching wrong
23:23:11 <quintopia> ohn
23:23:13 <quintopia> nvm
23:23:13 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*20<(+)*30(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:23:16 <quintopia> i dropped a P
23:23:17 <quintopia> (
23:23:23 <EgoBot> Score for Deewiant_pendolino: 41.1
23:23:24 <quintopia> wait no
23:23:30 <quintopia> WTF GREGOR THAT'S PERFECTLY RIGHT
23:23:44 <Gregor> Ohwait, I misread X-P
23:23:51 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*20(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:23:55 <EgoBot> Score for Deewiant_pendolino: 40.9
23:24:09 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*25<(+)*25(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:24:18 <EgoBot> Score for Deewiant_pendolino: 40.5
23:24:21 <quintopia> Deewiant: what are you tuning for?
23:24:26 <quintopia> decoy size?
23:24:27 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*28<(+)*28(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:24:32 <EgoBot> Score for Deewiant_pendolino: 43.0
23:24:33 <Deewiant> Yeah, now
23:24:40 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*35<(+)*35(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:24:42 <quintopia> Gregor: any idea what that is?
23:24:52 <Gregor> quintopia: Which is it that's stuck for you, poke or the other?
23:25:09 <EgoBot> Score for Deewiant_pendolino: 42.6
23:25:17 <quintopia> ah, it appears to be poke
23:25:27 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*42<(+)*42(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:25:30 <Gregor> quintopia: In that case, it's because *20 is wrong, you wanted *21 :P
23:25:33 <EgoBot> Score for Deewiant_pendolino: 42.2
23:25:35 <quintopia> Gregor: thx
23:25:36 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*31<(+)*31(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:25:46 <EgoBot> Score for Deewiant_pendolino: 43.0
23:25:46 <quintopia> i was confused because poke was still winning
23:25:49 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:25:55 <EgoBot> Score for Deewiant_pendolino: 43.3
23:25:56 <quintopia> but realized it was the other one suiciding XD
23:26:25 <elliott> how does one tell vi to blink matching parens? :P
23:26:30 <elliott> without any syntax mode
23:26:49 <Deewiant> :set sm
23:27:03 <elliott> Thanks.
23:27:14 <Deewiant> Note: Use of the short form is rated PG.
23:27:49 <Sgeo> short form?
23:27:59 <Deewiant> Instead of :set showmatch.
23:28:09 <quintopia> !bfjoust poke http://sprunge.us/IhJd
23:28:20 <Sgeo> I don't geddit
23:28:21 <EgoBot> Score for quintopia_poke: 4.1
23:28:25 <Sgeo> S&M?
23:28:26 <quintopia> wat
23:28:48 <quintopia> oh that change didn't stick
23:29:43 <quintopia> !bfjoust poke http://sprunge.us/MEhZ
23:29:48 <EgoBot> Score for quintopia_poke: 0.0
23:29:53 <quintopia> XD
23:30:19 <elliott> !bfjoust
23:30:20 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
23:30:26 <elliott> !bfjoust slowest_fucking_rush_in_all_of_history (>)*8+[>[-[++[-[-[-[-[-[-[-[-[(+)*9[+[+[+[+[+[+[+[(-)*136[-]]]]]]]]]]]]]]]]]]]]+]
23:30:32 <quintopia> !bfjoust poke http://sprunge.us/ATag
23:30:34 <EgoBot> Score for elliott_slowest_fucking_rush_in_all_of_history: 13.6
23:30:37 <elliott> X-D
23:31:03 <elliott> !bfjoust slowest_fucking_rush_in_all_of_history (>)*9([-[++[-[-[-[-[-[-[-[-[(+)*9[+[+[+[+[+[+[+[(-)*136[-]]]]]]]]]]]]]]]]]]]]>)*20
23:31:08 <EgoBot> Score for elliott_slowest_fucking_rush_in_all_of_history: 20.0
23:31:16 <elliott> Good against programs that fill the entire tape with decoys instantly :P
23:31:22 <elliott> !bfjoust slowest_fucking_rush_in_all_of_history <
23:31:26 <EgoBot> Score for elliott_slowest_fucking_rush_in_all_of_history: 0.0
23:31:44 <elliott> !bfjoust snorlax (.)*3000(>)*9([-[++[-[-[-[-[-[-[-[-[(+)*9[+[+[+[+[+[+[+[(-)*136[-]]]]]]]]]]]]]]]]]]]]>)*20
23:31:50 <EgoBot> Score for elliott_snorlax: 12.1
23:31:58 <elliott> !bfjoust snorlax (.)*-1(>)*9([-[++[-[-[-[-[-[-[-[-[(+)*9[+[+[+[+[+[+[+[(-)*136[-]]]]]]]]]]]]]]]]]]]]>)*20
23:32:03 <EgoBot> Score for elliott_snorlax: 21.6
23:32:05 <quintopia> wat
23:32:06 <elliott> What.
23:32:15 <elliott> X-D
23:32:21 <quintopia> i am so confused elliott
23:32:27 <elliott> 21.6.
23:32:29 <elliott> That is amazing.
23:32:31 <elliott> (And -6.69 points)
23:32:35 <quintopia> !bfjoust poke http://sprunge.us/ATag
23:32:36 <elliott> Gregor: I love your score system :P
23:32:42 <EgoBot> Score for quintopia_poke: 42.0
23:32:43 <EgoBot> Score for quintopia_poke: 42.0
23:32:45 <quintopia> oh
23:32:46 <quintopia> weird
23:32:53 <elliott> ais523_defend13.bfjoust vs elliott_snorlax.bfjoust:
23:32:53 <elliott> >>>>><<<<<<<<<<<<<<<< >>>>>>>>>>>>>>>>>>>>< >>>>>>>>>>>>>>>>>>>>< >>>>><<<<<<<<<<<<<<<<
23:32:53 <elliott> elliott_snorlax.bfjoust wins
23:32:54 <quintopia> it did them out of order with elliott's
23:32:54 <elliott> ais523: How...
23:33:09 <elliott> omg
23:33:09 <Gregor> elliott: Whether you're being sarcastic or not, the score system actually is pretty good.
23:33:09 <elliott> sotp
23:33:12 <elliott> everyone stop
23:33:14 <ais523> elliott: probably a misdetection
23:33:15 <elliott> neon_glow is at the bottom
23:33:17 <Gregor> elliott: It's good for hill churn.
23:33:18 <elliott> we do NOT want it to fall off
23:33:20 <elliott> it's the oldest
23:33:23 <elliott> !bfjoust shieeeeeeet <
23:33:29 <EgoBot> Score for elliott_shieeeeeeet: 0.0
23:33:29 <ais523> meh, it deserves to fall off if it can't cut it
23:33:33 <quintopia> !bfjoust minipoke (>)*8(>[(<)*8(-)*33(>)*8([-[++[(+)*9[-]]]]>)*21])*21
23:33:35 <elliott> NOOOOO
23:33:37 <quintopia> FALL OFF!
23:33:37 <elliott> IT'S GONE!
23:33:39 <quintopia> WOOOOO!
23:33:40 <elliott> THE OLDEST PROGRAM ON THE HILL!
23:33:40 <quintopia> :D
23:33:42 <elliott> NOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
23:33:44 <elliott> ;_;
23:33:45 <EgoBot> Score for quintopia_minipoke: 20.9
23:33:55 <quintopia> !bfjoust minipoke <
23:34:05 <EgoBot> Score for quintopia_minipoke: 0.0
23:34:14 <elliott> ais523: you should write a program to figure out the optimal [-[++[-[-[-[-[-[-[-[-[(+)*9[+[+[+[+[+[+[+[(-)*136[-]]]]]]]]]]]]]]]]]]]]-style loop
23:34:29 <elliott> i.e. a loop that is effectively a bunch of limited [-] and [+]s
23:34:34 <elliott> you could also mix it up with [-[+[-
23:34:37 <elliott> :P
23:34:41 <elliott> or [+.[+.[+.
23:34:49 <ais523> I wondered about that, but it would be massively complex and probably very hill-dependent
23:34:53 <ais523> definder was crazy enough
23:35:04 <ais523> e.g. the -------------------------..+ bit in definder1
23:35:13 <elliott> ais523: well, the fact that snorlax actually got points for that loop...
23:35:26 <ais523> not very many
23:36:31 <quintopia> elliott: my guess is something binary search-like
23:36:37 <quintopia> for maximum staying power
23:37:02 <elliott> ais523: yes, but that's because it's bloody stupid
23:37:12 <quintopia> as that would be guaranteed to take no more than twice as long + O(1) as it needed to if it knew which direction to go
23:37:14 <elliott> ais523: it's basically (>)*9([-]>)*20, except with a better loop
23:37:20 <elliott> ais523: a better strategy with that loop...
23:37:22 <ais523> quintopia: you can't know what direction to go
23:37:33 <quintopia> ais523: exactly
23:37:35 <ais523> oh, you mean +1, -2, +4, -8, +16, etc
23:37:41 <ais523> not really binary search, more a binary oscillation
23:37:49 <quintopia> well
23:37:58 <quintopia> i did the calculation once
23:38:19 <elliott> yeah the problem with that is that it oscillates
23:38:20 <quintopia> and it actually takes at most 9x as long as it would have knowing the right direction
23:38:36 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30(>)*6(>[-[++[(+)*9[-].[.+]]]])*21
23:38:40 <elliott> the stupidest form is ([-{+}])%n
23:38:41 <EgoBot> Score for Deewiant_pendolino: 36.8
23:38:42 <quintopia> so for small deviations, it's not bad
23:38:53 <elliott> erm
23:38:55 <quintopia> for big ones, it's better to just go all the way around the cell
23:38:56 <elliott> the stupidest form is ([-{[+]}])%n
23:39:02 <Deewiant> !bfjoust pendolino -(>)*6(+)*10<(-)*10<(-)*30<(+)*30(>)*5(>[-[++[(+)*9[-].[.+]]]])*21
23:39:02 <elliott> for some n
23:39:06 <EgoBot> Score for Deewiant_pendolino: 37.4
23:39:18 <elliott> the second-stupidest form is ([-{[(+)*n+]}])%n
23:39:18 <Deewiant> !bfjoust pendolino -(>)*5(+)*10<(-)*10<(-)*30<(+)*30(>)*6(>[-[++[(+)*9[-].[.+]]]])*21
23:39:24 <EgoBot> Score for Deewiant_pendolino: 40.3
23:39:47 <Deewiant> !bfjoust pendolino -(>)*4(+)*30<(-)*30<(-)*10<(+)*10(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:40:04 <EgoBot> Score for Deewiant_pendolino: 39.9
23:40:27 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++[(+)*11[-].[.+]]]])*21
23:40:33 <EgoBot> Score for Deewiant_pendolino: 41.9
23:40:51 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++[(+)*8[-].[.+]]]])*21
23:40:52 <elliott> Deewiant: Tweaker.
23:40:56 <Deewiant> Yep
23:41:00 <Gregor> OK, EgoJSout now (somewhat poorly) reports parse errors.
23:41:08 <Gregor> Making defend14 vs wiggle3 very amusing.
23:41:09 <EgoBot> Score for Deewiant_pendolino: 37.7
23:41:12 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++[(-)*9[+].[.-]]]])*21
23:41:17 <EgoBot> Score for Deewiant_pendolino: 35.2
23:42:01 <elliott> Gregor: SO DO TWO PARSE ERRORS DRAW
23:42:14 <Gregor> elliott: Anything that didn't match becomes a noop.
23:42:18 <elliott> It was a joke.
23:42:30 <Gregor> elliott: So's your face, but you don't see me laughing.
23:42:37 <elliott> Yes I do.
23:42:55 <Gregor> <elliott> In my dreams.
23:43:02 <quintopia> !bfjoust stupiddefender http://sprunge.us/fgNG
23:43:13 <EgoBot> Score for quintopia_stupiddefender: 16.1
23:43:16 <elliott> Gregor wishes I dreamt about him.
23:43:19 <elliott> quintopia: heh, was that program-generated?
23:43:23 <quintopia> yes
23:43:25 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++[(+)*9[-].[.+]]]])*21
23:43:30 <EgoBot> Score for Deewiant_pendolino: 43.3
23:43:30 <elliott> I should have a go at generating some programs
23:43:34 <elliott> maybe with Mathematica, just for the hell of it :-D
23:43:35 <quintopia> it's my example for the wiki
23:43:45 <elliott> quintopia: err, something shorter would be nicer
23:43:47 <quintopia> just making sure that the examples suck enough to go on the wiki
23:43:51 <elliott> and more comprehensible
23:43:53 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[+++[(+)*9[-].[.+]]]])*21
23:43:53 <Gregor> Hah X-D
23:43:58 <EgoBot> Score for Deewiant_pendolino: 42.7
23:44:02 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[+[(+)*9[-].[.+]]]])*21
23:44:09 <EgoBot> Score for Deewiant_pendolino: 37.7
23:44:17 <Gregor> quintopia: I was actually considering extending that article once it gets some strategies by listing all or most of the programs that have ever been #1 and the strategies they use.
23:44:23 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[+++[(+)*8[-].[.+]]]])*21
23:44:23 <quintopia> elliott: i can make it shorter, but not more comprehensible. it's a fucking defender for crissake
23:44:24 <Gregor> It's like how chess masters study former chess games :)
23:44:29 <EgoBot> Score for Deewiant_pendolino: 44.1
23:44:31 <elliott> ais523: show him defend1
23:44:32 <elliott> :P
23:44:46 <elliott> Gregor: Ooh, ooh, we need cycle-by-cycle commentary.
23:44:48 <ais523> defend1 isn't very good
23:44:50 <elliott> It'd be almost as tedious as it is for chess!
23:44:54 <elliott> ais523: but it's simpler than what quintopia did
23:44:58 <elliott> all we need is a defender, not a good one
23:44:59 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++++[(+)*7[-].[.+]]]])*21
23:45:04 <EgoBot> Score for Deewiant_pendolino: 43.3
23:45:07 <Gregor> elliott: I think just a brief paragraph per will be sufficient :P
23:45:12 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[(+)*5[(+)*6[-].[.+]]]])*21
23:45:17 <ais523> !bfjoust defend1 [>+[]<(.)*258(+)*127]
23:45:17 <quintopia> elliott: i'll just make this one the obvious stupid short one, even though it's less efficient
23:45:20 <EgoBot> Score for Deewiant_pendolino: 43.1
23:45:34 <EgoBot> Score for ais523_defend1: 1.9
23:45:47 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[+++[[(+)*8[-]].[.+]]]])*21
23:45:49 <ais523> it's a really cheesy defence program, it basically reclaims the flag at the exact instant attack1 would drop the flag
23:45:53 <EgoBot> Score for Deewiant_pendolino: 41.1
23:45:53 <ais523> thus causing it to run off the end
23:45:59 <ais523> I don't think it works well against anything else
23:46:14 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[++[+[(+)*8[-].[.+]]]]])*21
23:46:19 <EgoBot> Score for Deewiant_pendolino: 43.7
23:46:53 <Gregor> There have only been 34 programs that have ever been #1.
23:46:58 <elliott> OK, gotta fix this off-by-one.
23:47:06 <elliott> Gregor: really?
23:47:13 <Gregor> If you compress some of those where there's an "improved" version and only show the improved one, you could probably get away with 20 or so.
23:47:14 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[+[+[+[(+)*8[-].[.+]]]]]])*21
23:47:18 <EgoBot> Score for Deewiant_pendolino: 46.7
23:47:29 <elliott> If you consider only ones that don't suck, you could make it 15.
23:47:35 <elliott> (The hill was... volatile in the bad old days.)
23:47:41 <Gregor> elliott: True :P
23:47:48 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[+[+[+[(+)*7[-].[.+]]]]]])*21
23:47:53 <EgoBot> Score for Deewiant_pendolino: 41.4
23:47:57 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[+[+[+[(+)*9[-].[.+]]]]]])*21
23:48:04 <EgoBot> Score for Deewiant_pendolino: 46.3
23:48:09 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-[+[+[+[(+)*8[-].[.+]]]]]])*21
23:48:14 <EgoBot> Score for Deewiant_pendolino: 46.7
23:49:55 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-([+{[(+)*8[-].[.+]]}])%3])*21
23:50:02 <EgoBot> Score for Deewiant_pendolino: 46.7
23:50:18 <Gregor> elliott: If you look at only 2010 and later, there have been only 17.
23:50:39 <elliott> Gregor: There were good ones in 2009 :P
23:50:48 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-([+{[(+)*8[-].[.+]]}])%4])*21
23:50:52 <EgoBot> Score for Deewiant_pendolino: 43.0
23:50:54 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-([+{[(+)*8[-].[.+]]}])%2])*21
23:51:01 <EgoBot> Score for Deewiant_pendolino: 39.0
23:51:02 <Gregor> elliott: Yeahyeahyeah :P
23:51:05 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>)*7(>[-([+{[(+)*8[-].[.+]]}])%3])*21
23:51:10 <EgoBot> Score for Deewiant_pendolino: 46.7
23:51:36 <elliott> Gregor: I wouldn't want to be the one to have to explain space_elevator.
23:51:47 <Gregor> elliott: Hyuk
23:52:16 <quintopia> ais523: defend1 is really clever, but it's surprising that it works at all. wouldn't it get off by a couple of digits every time it got to a new cell?
23:52:33 <ais523> that's what the tripwire's for
23:52:40 <ais523> it's really incredibly situational
23:52:59 <ais523> also, defence detection ruins it
23:53:03 <Gregor> ais523: plz can haz description of tripwires on the wiki from the master?
23:53:51 <quintopia> ais523: also, it looks like it locks itself into an infinite loop on the tripwire :P
23:54:05 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>-)*7(>[-([+{[(+)*8[-].[.+]]}])%3])*21
23:54:10 <EgoBot> Score for Deewiant_pendolino: 47.1
23:54:22 <ais523> quintopia: isn't that what tripwires are for? or do I misunderstand you?
23:54:28 <ais523> Gregor: not today, maybe tomorrow
23:54:42 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>-)*7(>[-([+{[(+)*8[-].[.+]]}])%3]+)*21
23:54:46 <quintopia> ais523: i mean, it locks itself there once its opponent has already tripped it once
23:54:49 <EgoBot> Score for Deewiant_pendolino: 44.6
23:54:54 <Deewiant> !bfjoust pendolino -(>)*4(+)*10<(-)*10<(-)*30<(+)*30(>-)*7(>[-([+{[(+)*8[-].[.+]]}])%3])*21
23:54:57 <ais523> quintopia: yep, I'm not sure why it does that
23:55:00 <EgoBot> Score for Deewiant_pendolino: 47.1
23:55:11 <quintopia> ais523: because you were stupid when you wrote it :P
23:55:15 <quintopia> Gregor: i was just getting to that
23:59:31 -!- cheater00 has joined.