←2011-02-07 2011-02-08 2011-02-09→ ↑2011 ↑all
00:00:10 <elliott> yay good math bad math
00:00:27 <variable> elliott, yeap
00:00:37 <variable> I've been reading that blog for years
00:00:45 <variable> months? over a year
00:01:04 <Sgeo> elliott
00:01:11 <Sgeo> hmm :(
00:01:31 <elliott> variable: do you want to see an example of BEAUTY and ELEGANCE in Haskell code? too bad, because all I have is this horrible crock!
00:01:48 <variable> elliott, ????
00:01:52 <elliott> just commenting
00:01:55 <elliott> on how awful this code is
00:01:56 <elliott> right now :D
00:02:02 <variable> elliott, FIX IT
00:02:08 <elliott> variable: you fix it: http://sprunge.us/PidB
00:02:48 -!- FireFly has quit (Quit: swatted to death).
00:06:46 <elliott> i think i just horrified variable to death
00:07:02 <variable> elliott, yes
00:08:44 <Sgeo> I think I partially solved my Reddit Chrome problems
00:09:36 -!- Behold has quit (Remote host closed the connection).
00:12:34 <elliott> variable: at least it's shorter than it would be in C :P
00:13:52 <elliott> :t catch
00:13:53 <lambdabot> forall a. IO a -> (IOError -> IO a) -> IO a
00:13:56 <elliott> :t Control.Exception.catch
00:13:57 <lambdabot> forall a e. (GHC.Exception.Exception e) => IO a -> (e -> IO a) -> IO a
00:14:35 <elliott> hmm
00:16:08 <variable> elliott, shorter != better
00:16:17 <elliott> variable: Less crap == better.
00:16:23 <variable> but yes - I get the point
00:16:24 <elliott> Manual memory allocation definitely counts as crap. :P
00:17:31 <Sgeo> There are a lot of imperative compiled languages that do automatic stuff
00:30:49 <elliott> variable: yay! apart from i and o, everything works! (directed at you, the only active person)
00:34:41 -!- Mathnerd314 has joined.
00:34:45 <variable> elliott, ya know - I proved P≠NP but I just can't get the program to output
00:34:50 <elliott> :D
00:34:59 <elliott> i and o are file-handling instructions here :P
00:35:11 <variable> elliott, I figured "input" and "output"
00:35:15 <elliott> they are
00:35:18 <variable> also - use normal names for your functions
00:35:19 <elliott> i reads in some fungespace from a file
00:35:21 <elliott> o outputs it
00:35:24 <elliott> variable: instructions
00:35:28 <elliott> variable: this is Befunge-98
00:35:32 <variable> elliott, ah ok
00:35:34 <elliott> the instructions are i and o :P
00:35:37 * variable should learn it
00:35:45 <elliott> variable: it's more interesting to implement than use imo
00:35:46 <elliott> ^source
00:35:47 <fungot> http://git.zem.fi/fungot/blob/HEAD:/fungot.b98
00:35:52 <elliott> fungot, our friendly babble bot, is written in it ^
00:35:53 <fungot> elliott: grep and cron? :-p) if that's what you were saying something interesting about it
00:35:59 <elliott> and underload/bf interpreting bot :P
00:36:06 <elliott> that source is quite a sight
00:36:10 <variable> elliott, also - I have a programming language that I need some help putting into normal words
00:36:22 <variable> I have the concept down though
00:36:28 <elliott> you think i'm equipped for normal words after implementing a program that (will be able to) run http://git.zem.fi/fungot/blob/HEAD:/fungot.b98? :D
00:36:28 <fungot> elliott: you don't need
00:36:34 <elliott> i don't need normal words? i see
00:36:53 * variable is away for a bit
00:37:04 <olsner> elliott: 'tards don't have to use normal words if they're not able to
00:37:06 <elliott> first few lines of the test-suite i've been running against:
00:37:09 <elliott> 0#@>. 1#@v>#@,55+"skrow , :DOOG",,,,,,,,,,,,,,1#v:$v>"pud t'nseod : DAB",,,,,,,v> v >" 1 naht erom spiks "v
00:37:10 <elliott> v"@.4"@#<.+@,,,,,,,,,,,,,,,,"BAD: : reflects"+55<v _^ @,+55,,,,,,,,,,,< v+---<vfv#< < vdv#< < v<v": a doesn't push 10"+55_v# -+91av#< v "BAD: # across left edge" <
00:37:13 <elliott> >$#v5#.< #5 >:#,_$v#"GGGOOD: : duplicates"+730$<>"OOG">:#,_22#v-#v_19+"0 = 2"v >9-v ^< < ^e^#< < vbv#<^># #< "DAB">:#,_@#"BBAD: a reflects"># 0# 5# 5# +# <
00:37:16 <elliott> >3.#@$ .^@5v"ro"+820_28+"orez spop kcats ytpme :D"^v"-2 != 0"+550 <v"GOOD: 2-"< v a_a"51-11 h"v ^c^#< < >:#,_^#"GGOOD: a pushes 10"># 0# 5# 5# +# < "
00:37:19 <elliott> ^ 0@# 4.2< >"eznon spop kcats ytpme :DAB"v "BAD: - reflects"+55< >:#,_v >v >")seod a taht gnitseretni( krow t'nod f-b :DAB">:#,_@#: < > vc >055+"llec tsom"v
00:37:22 <elliott> v.6_5.@>7.^>+"stcelfer \">" :DAB">:#,_@#:< "BAD: 2"< v"GOOD: | works"+<>#v|>0v v"OD: b-f pus"<>a"tfel snrut [ :DOOG">:#,_v " e v"kips eastern"<
00:37:25 <elliott> hells yeah
00:38:09 <elliott> ("Va=",(60,119),"Vb=",(0,31))
00:38:10 <elliott> BAD: i should have pushed (60, 119) as Va
00:38:11 <elliott> BAD: i should have pushed (90, 16) as Vb
00:38:13 <elliott> hm...
00:38:57 <elliott> heh mycology now takes almost 6.6 seconds
00:39:05 <elliott> i'll optimise that bounds recalculation later with a population count...
00:39:26 <Sgeo> elliott, you got Mycology at the point where it can run? Awesome
00:39:26 <elliott> io $ print ("Va=",offset,"Vb=",(bx-ox,by-oy),"(bx,by)=",(bx,by))
00:39:28 <elliott> olsner: haskell debugging
00:39:54 <olsner> elliott: I think the root cause is an error in the code
00:40:02 <olsner> what did I win?
00:40:17 <elliott> olsner: oh yeah so much money
00:40:21 <elliott> ("Va=",(60,119),"Vb=",(0,31),"(bx,by)=",(60,150))
00:40:21 <elliott> BAD: i should have pushed (60, 119) as Va
00:40:22 <elliott> BAD: i should have pushed (90, 16) as Vb
00:40:23 <elliott> x_X
00:40:46 <elliott> colloquially i would describe this situation as "shit is most fucked-up"
00:40:47 -!- TLUL has quit (Read error: Connection reset by peer).
00:40:56 <elliott> the most fuckest-upness of the shits
00:41:10 <olsner> I like to call that state "nothing fucking works"
00:41:29 -!- TLUL has joined.
00:41:58 -!- TLUL has quit (Read error: Connection reset by peer).
00:42:19 <olsner> (but mostly that's when someone else starts screaming about how nothing fucking works while really it's Just Not That Big A Deal)
00:43:19 <elliott> olsner: you think this isn't a big deal?
00:43:21 <elliott> this is
00:43:21 <elliott> so
00:43:24 <elliott> IMPORTANT
00:43:39 <olsner> I don't care, so obviously it's not really that important
00:43:49 <elliott> That the environment variables are:
00:43:49 <elliott> orihs/edoC/ttoille/emoh/=DWPDLO
00:43:49 <elliott> orihs/orihs/edoC/ttoille/emoh/=_
00:43:49 <elliott> lanimret-emong=MRETROLOC
00:43:49 <elliott> esabatad/67schb-ttoille-rof-htua/mdg/nur/rav/=YTIROHTUAX
00:43:59 <elliott> olsner: where else can you see entertaining bugs like that
00:44:13 <olsner> haha, you're using lanimret-emong
00:44:30 <elliott> olsner: lol
00:44:41 <Gregor> http://codu.org/tmp/dirge-for-accordion.ogg I declare this Best Ever
00:44:44 <elliott> olsner: i had no idea what that said until i typed it out backwards
00:44:46 <elliott> gnome-terminal isn't that bad
00:44:52 <elliott> i'm too lazy to install anything else
00:45:15 <elliott> Gregor: Needs more organ
00:45:18 <elliott> But I like it
00:45:26 <Gregor> Needs more /organ/?
00:45:46 <elliott> Yes.
00:45:53 <olsner> a terminal that has a menu bar and/or a way to configure it is not a worthy terminal
00:45:53 <elliott> Trust me.
00:45:53 * Gregor shakes his fist :P
00:46:08 <elliott> olsner: .Xresources is a way to configure
00:46:11 <elliott> olsner: in fact, xterm has menus to configure
00:46:14 <elliott> your point?
00:46:26 <elliott> also, /me just disabled gnome-terminal's menubar
00:46:31 <elliott> that was hard
00:46:32 <olsner> none really, I just remember gnome-terminal not being to my liking
00:46:46 <olsner> hence it is completely worthless
00:46:49 <elliott> It lets me open URLs nicely, which is more than xterm does :P
00:47:01 <elliott> Also, handles Unicode properly.
00:47:07 <olsner> not doing that is a feature :P
00:47:09 <elliott> Which is a bitch in some terminals.
00:47:16 <elliott> olsner: Because you... like pain?
00:47:22 -!- poiuy_qwert has joined.
00:48:29 <olsner> i just find it perfectly fine to select and paste instead of getting hit by a million ways to get url detection wrong :)
00:48:31 <Sgeo> Atomo has been updated
00:50:43 <elliott> olsner: hit? if i don't want to open it as a url, i don't ctrl-click it
00:50:51 <elliott> in the rare case that it gets something wrong, I do it manually
00:50:53 <elliott> what's the problem :P
00:51:01 <elliott> it also handles emails IIRC, but again, clicking does nothing, it's ctrl+click
00:51:04 <elliott> or I think middle click
00:54:44 <elliott> oh god
00:54:47 <elliott> slashdot redesigned
00:54:55 <elliott> and it's... far better, actually
00:57:27 <elliott> mergeByteString :: Vector -> FungeSpace -> ByteString -> (Vector, FungeSpace)
00:57:27 <elliott> mergeByteString (ox,oy) fs s = ((by,bx),fs')
00:57:28 <elliott> where ((_,by),fs',_,bx) = B.foldl' byte ((ox,oy),fs,False,0) s
00:57:28 <elliott> byte (p@(x,y),fs,lastWasCR,biggestX) w
00:57:28 <elliott> | w == ff || (w == lf && lastWasCR) = (p, fs, False, biggestX)
00:57:28 <elliott> | w == cr || w == lf = ((ox,y+1), fs, w == cr, biggestX)
00:57:30 <elliott> | w == space = ((x+1,y), fs, False, max (x+1) biggestX)
00:57:32 <elliott> | otherwise = ((x+1,y), insertFS p (fromIntegral w) fs, False, max (x+1) biggestX)
00:57:34 <elliott> variable: where's the really obvious bug?
00:57:46 <elliott> because i don't know :D
00:57:58 <Lymia> !bfjoust evo-shortened-0 >++<[..[.++.]+]
00:58:19 <Lymia> !bfjoust evo-shortened-1 [..[.++.]+]
00:58:21 <Lymia> !bfjoust evo-shortened-2 [..[.++.]]
01:00:07 <EgoBot> Score for Lymia_evo-shortened-1: 12.1
01:00:07 <EgoBot> Score for Lymia_evo-shortened-2: 12.0
01:00:07 <EgoBot> Score for Lymia_evo-shortened-0: 17.4
01:00:21 <elliott> haskell development feels like it goes slower
01:00:28 <elliott> because you can't just go through the loop in your head until it makes sense
01:00:36 <elliott> you just sit there thinking... or in my case, not thinking
01:01:22 <Lymia> Bluh.
01:01:29 <Lymia> I have no idea why that works so well.
01:01:36 <Lymia> elliott, shouldn't the outer loop be an noop?
01:01:50 <elliott> Lymia: no, because the interpreter could change the cell in that cycle
01:01:53 <elliott> both [ and ] take a cycle
01:01:55 <Lymia> Ah.
01:02:01 <Lymia> And there's noops there too.
01:02:04 <elliott> although...
01:02:10 <elliott> ]] i think is a nop
01:02:10 <elliott> wait no
01:02:15 <elliott> i think there's one case where you could not die
01:02:17 <elliott> hmm
01:02:20 <elliott> don't try and understand it
01:02:24 <elliott> it's machine code :P
01:02:27 <Lymia> =p
01:02:43 <Lymia> Although.
01:02:48 <Lymia> >< is a true noop
01:02:58 <Lymia> ...unless you're at the end of the tape...
01:03:15 <elliott> Lymia: in bf joust, [-][] can loop forever
01:03:16 <elliott> :)
01:03:26 <elliott> even if the [-] finishes
01:03:52 <Lymia> And [] can terminate.
01:03:53 <Lymia> =p
01:04:00 -!- augur has joined.
01:04:04 <elliott> indeed
01:04:08 <elliott> well, +[] can, rather
01:05:10 <Lymia> I find it quite suprizing really.
01:05:24 <Lymia> That a defensive program evolved that is.
01:05:30 <Lymia> I should try and find out where it came from.
01:06:05 <Lymia> ...
01:06:06 <Lymia> +..[[+-><+.[-[[++.]-[]]++][]+[>.+<[]][<--<>-]<(>.+[]-(-[+<[]]+[])*1<-+->.++<.[+.]>><+<.->.+..+)*7].<]><.-++-<+<+
01:06:12 <Lymia> This is generation 100.
01:06:18 <Lymia> Looks like it was defensive from the start.
01:06:36 <elliott> surprizing, that's a new spelling ::D
01:06:38 <elliott> *:D
01:06:44 <Lymia> :(
01:06:48 <elliott> Lymia: are you sure the hill didn't start out with a bunch of defence programs?
01:06:56 <Lymia> The hill started out randomly.
01:07:42 <elliott> ah
01:07:59 <elliott> Lymia: make a new evolver hill with the current hill, that might be interesting, if your evolver has improved any
01:08:05 <elliott> it seems to be avoiding too many ()s which is an improvement
01:08:18 <elliott> of course the problem is breeding two completely different strategies just results in a clusterfuck
01:08:23 <elliott> do you do breeding yet?
01:08:25 <Lymia> No.
01:08:31 <Lymia> It hasn't really been worked on recenty.
01:08:33 <Lymia> recently*
01:08:39 <Ilari> Heh. Reminds me of evolutionary rock-paper-scissors. :-)
01:08:44 <Lymia> I don't want to try breeding really.
01:08:55 <Lymia> I /could/ try snipping of dead code tohg.
01:08:57 <Lymia> though*
01:10:02 <elliott> Lymia: that would help
01:10:10 <elliott> otherwise it will probably just expand and mutate dead code in the long run
01:10:12 <Ilari> Evolutionary rock-paper-scissors occurs when there are three species/subspecies, such that each of three can outcompete one of the others but is outcompeted by the remaining one. Result is dominant species/subspecies cyclically shifting.
01:10:47 <elliott> Lymia: you may want to talk to impomatic, he's from the core war world and they do a _lot_ of evolving to great success (really competitive), albeit of assembly programs and I think mostly short ones (really short: like less than 20 instructions)
01:10:53 <elliott> might be able to gets tips :P
01:10:54 <elliott> *get
01:11:03 <Lymia> What I really want to do is to try and prevent speicies from dying out.
01:11:09 <Lymia> I might need to modify the core to do this.
01:11:15 <Lymia> (i.e. the non-mutation routines)
01:11:30 <elliott> Lymia: clearly, you need to evolve the mutation routines as a genetic algorithm
01:11:30 <Lymia> Having more than one species alive at the same time would really help, methinks.
01:11:31 <elliott> :D
01:11:38 <Ilari> Other fun evolved stuff: Three species, one peaking 3 year intervals, one peaking 5 year intervals and one peaking 7 year intervals. All intervals are prime and minimize the number of years where multiple peak at the same year.
01:11:38 <Sgeo> Was BF Joust invented in Agora, or just appropriated by it?
01:12:36 <Lymia> Ilari.
01:12:37 <Lymia> Well.
01:12:41 <elliott> Ilari: i thought you meant an evolutionary algorithm for rock paper scissors :D
01:12:46 <Lymia> I know that defence->dumb rush
01:12:50 <Sgeo> Ah, it was an Agoran invention
01:12:53 <Lymia> I don't know what closes the circuit.
01:12:54 <Lymia> =p
01:12:59 <Gregor> elliott: BEST - IDEA - EVER
01:13:21 <elliott> Gregor: TOTALLY
01:14:27 <Lymia> BF Rock Paper Scissors
01:15:39 <elliott> aha!
01:15:42 <elliott> i think i know what the wrongs are.
01:15:48 <elliott> yes: the wrongs
01:16:32 <elliott> GOOD: i pushed correct Va (60, 119)
01:16:32 <elliott> GOOD: i pushed correct Vb (90, 16)
01:16:34 <elliott> SQUEESOME
01:16:44 <Gregor> http://codu.org/tmp/dirge-for-accordion.ogg I NOTICE PEOPLE ARE NOT HEAPING PRAISE ON ME FOR THIS
01:16:52 <elliott> Gregor: I loved it...
01:17:04 <Gregor> elliott: "People" is plural! X-P
01:17:17 <Sgeo> !bfjouse test_d [[+]+]
01:17:24 <Sgeo> !bfjoust test_d [[+]+]
01:17:51 <EgoBot> Score for Sgeo_test_d: 8.3
01:18:30 <Sgeo> !bfjoust lose [-]
01:18:55 <EgoBot> Score for Sgeo_lose: 8.4
01:18:59 <elliott> BAD: (-8, -9) should be @
01:19:03 <Sgeo> ...
01:19:08 <elliott> Deewiant: Would be totally cool if it told you what it is instead :P
01:19:22 <Sgeo> Gregor, why is... those things?
01:19:45 <Gregor> Sgeo: ITYM "I just shit my pants"
01:20:08 <elliott> [[Montgomery: What facts are your opinions based on?
01:20:08 <elliott> Britta Sundberg-Weitman: Facts.]] --Assange trial
01:20:11 <elliott> :D
01:20:37 <Sgeo> What's the lowest score a program can have?
01:20:40 <elliott> Sgeo: It's a G. invention.
01:20:44 <Sgeo> !bfjoust noop .
01:20:48 <Lymia> !bfjoust lose <
01:20:57 <Sgeo> Lymia, good point
01:20:58 <EgoBot> Score for Sgeo_noop: 8.3
01:20:59 <EgoBot> Score for Lymia_lose: 0.0
01:21:12 <elliott> !bfjoust poop [>>+]
01:21:12 <Sgeo> Who am I winning against?
01:21:16 <EgoBot> Score for elliott_poop: 0.0
01:21:18 <Sgeo> This is distressing
01:21:25 <elliott> !bfjoust poop [>>+<-]
01:21:26 <elliott> Score for elliott_poop2: 98.7
01:21:28 <Lymia> A tripwire variant.
01:21:30 <elliott> *poop:
01:21:32 <elliott> Darn :P
01:21:35 <elliott> Broke my joke.
01:21:35 <Lymia> elliott, w-wha?
01:21:37 <EgoBot> Score for elliott_poop: 0.0
01:21:40 <elliott> Lymia: It was a joke :P
01:21:43 <elliott> I was predicting my score.
01:21:48 <Lymia> Heh.
01:22:00 <Lymia> !bfjoust willwin >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
01:22:03 <EgoBot> Score for Lymia_willwin: 0.0
01:22:11 <Sgeo> tripwire?
01:22:34 <elliott> !bfjoust crap >>>>>>>>>(-)*128
01:22:35 <Lymia> !bfjoust wontlose >.< < Eirin Eirin, Help me Eirin
01:22:47 <EgoBot> Score for elliott_crap: 2.9
01:22:47 <EgoBot> Score for Lymia_wontlose: 0.0
01:22:50 <elliott> !bfjoust crap >>>>>>>>>[(-)*128>]
01:23:00 <elliott> !bfjoust crap2 >>>>>>>>>-[(-)*127>-]
01:23:00 <EgoBot> Score for elliott_crap: 8.1
01:23:10 <Sgeo> !bfjoust braindead_attack (>)*128[-]
01:23:16 <EgoBot> Score for elliott_crap2: 1.8
01:23:16 <EgoBot> Score for Sgeo_braindead_attack: 0.0
01:23:18 <Lymia> Sgeo, that really is braindead.
01:23:21 <Lymia> It goes off the edge.
01:24:08 <elliott> !bfjoust crap2 >>>>>>>>>-[(-)*128.+[-]>-]
01:24:20 <Sgeo> !bfjoust attack_15 (>)*15[-]
01:24:25 <elliott> crap 2, electric boogaloo
01:24:36 <EgoBot> Score for elliott_crap2: 4.3
01:24:36 <EgoBot> Score for Sgeo_attack_15: 2.9
01:25:11 <elliott> !bfjoust crap2 >>>>>>>>>-((-)*128.+[-]>-)*20
01:25:18 <Sgeo> New contest: Smallest positive score
01:25:19 <Sgeo> ;)
01:25:22 <elliott> !bfjoust crap2 >>>>>>>>>((-)*128.+[-]>-)*20
01:25:27 <elliott> !bfjoust crap2 >>>>>>>>>-((-)*127.+[-]>-)*20
01:25:30 <Sgeo> Oh, ellott wins that dangit
01:25:35 <Sgeo> ellott
01:25:44 <EgoBot> Score for elliott_crap2: 2.6
01:25:45 <EgoBot> Score for elliott_crap2: 2.6
01:25:45 <EgoBot> Score for elliott_crap2: 2.6
01:25:54 <Sgeo> I N C E P T E L L O T T
01:26:06 <Lymia> Sgeo, simple.
01:26:07 <elliott> 2cool4skool
01:26:26 <Lymia> !bfjoust low_score (>)*10([-])*1000
01:26:26 <Sgeo> Lymia, hm?
01:26:35 <elliott> !bfjoust crap2 >-[[-]>-]
01:26:41 <elliott> stop fucking up my shit, shitfuckers
01:26:57 <Sgeo> Lymia, how is that different from attack_15? What's the point of he *1000?
01:27:01 <Sgeo> *the
01:27:04 <EgoBot> Score for elliott_crap2: 2.0
01:27:04 <EgoBot> Score for Lymia_low_score: 7.8
01:27:07 <Lymia> Crap.
01:27:13 <elliott> !bfjoust crap2 >-[[-.]>-]
01:27:27 <Lymia> !bfjoust low_score (>-)*10([-]>)*2
01:27:46 <Sgeo> !bfjoust d_2 [[.]+]
01:28:12 <EgoBot> Score for Sgeo_d_2: 7.9
01:28:13 <EgoBot> Score for elliott_crap2: 6.8
01:28:13 <EgoBot> Score for Lymia_low_score: 0.1
01:28:21 <Sgeo> Hah!
01:28:41 <elliott> 6.8
01:28:42 <Lymia> I win.
01:28:42 <elliott> that's not bad
01:28:45 <Lymia> 0.1
01:28:45 <elliott> that's not bad at all
01:28:50 <elliott> Lymia: i'm trying to do _well_ :D
01:28:51 <Lymia> elliott, can you get lower without going to 0?
01:29:02 <elliott> !bfjoust crap2 >-[[-.]>+[+.]>-]
01:29:04 <Lymia> elliott, I'm letting my evolver (try to) do that for me.
01:29:04 <Lymia> =)
01:29:05 <Sgeo> Lymia, how does it work?
01:29:16 <Lymia> Sgeo, first, it plants a decoy to let tripwire, etc kill it.
01:29:27 <EgoBot> Score for elliott_crap2: 11.5
01:29:33 <Lymia> Then it goes over to the first cell of the possible enemy tape, and tries to clear it.
01:29:39 <Lymia> Then it tries to clear the second cell there.
01:29:46 -!- sebbu2 has joined.
01:29:53 <elliott> 11.5
01:29:55 <elliott> 11.fucking5
01:30:10 <elliott> !bfjoust absolute_defecation >-[([-.]>+[+.]>-)*10]
01:30:26 <Lymia> !bfjoust evolotion_of_shit -.+-><-.-[.[(.)*2++]]-(-.)*1-+(>-.-<<+..<...<.<-.>>..+.)*3-.-<.-+<-+<-<>..-.<>.><-+-<+++.--.+-+<+<-+<+<-.<++-+<>-++>+[.<-.[<]]<.+<+<><<<><<.><>+>>-<-.<---[]+[]-.>
01:30:28 <EgoBot> Score for elliott_absolute_defecation: 15.9
01:30:46 <Sgeo> lolwhat at the []
01:30:49 <elliott> 15.9
01:30:51 <elliott> i am
01:30:51 <elliott> so good
01:31:07 <Lymia> Sgeo, I didn't write that program.
01:31:08 <Lymia> =)
01:31:13 <Lymia> I wrote the program that wrote it.
01:31:17 <elliott> the evoLOTION of shit?
01:31:19 <Sgeo> Why does your evolver allow it?
01:31:27 <EgoBot> Score for Lymia_evolotion_of_shit: 16.4
01:31:31 <elliott> !bfjoust absolute_defecation >-[([++-.]>+[+--.]>-)*10]
01:31:33 <Sgeo> Does it have any effect on timing?
01:31:34 <EgoBot> Score for elliott_absolute_defecation: 18.5
01:31:38 <elliott> 18.5
01:31:40 <elliott> 18.5
01:31:45 <Lymia> Sgeo, yes.
01:31:47 <Lymia> In fact.
01:31:53 <Lymia> [] on the home tile can detect attempts to kill you.
01:31:54 <Sgeo> Ah, so it may be useful
01:32:01 <elliott> !bfjoust absolute_defecation >-[([++-.]>+[+--.]>-[-++])*10>-]
01:32:05 <EgoBot> Score for elliott_absolute_defecation: 7.1
01:32:05 <Sgeo> So I didn't need to write [.]
01:32:06 <elliott> Lymia: not quite
01:32:09 <elliott> Lymia: it was changed so that doesn't work
01:32:12 <elliott> because ] takes up a cycle
01:32:12 <Lymia> Ah.
01:32:14 <elliott> meaning you die
01:32:16 <Lymia> :(
01:32:27 <Sgeo> ! d_3 [[]+]
01:32:28 <elliott> !bfjoust pounce [[]-]
01:32:28 -!- sebbu has quit (Ping timeout: 255 seconds).
01:32:29 -!- sebbu2 has changed nick to sebbu.
01:32:37 <Sgeo> !bfjoust d_3 [[]+]
01:32:39 <Lymia> You'll beat tripwire
01:32:51 <elliott> :D
01:32:55 <EgoBot> Score for Sgeo_d_3: 7.6
01:32:56 <EgoBot> Score for elliott_pounce: 7.6
01:33:09 <Sgeo> I thought it would be funny if they got different scores
01:33:10 <Sgeo> Darn
01:33:40 <Sgeo> [e.g. a program being fooled by 1 but not -1 or visa versa]
01:34:11 <Sgeo> Oh wait, it's not two spaces then you're dead, is it
01:34:25 <Sgeo> !bfjoust lie >(+)*127
01:34:31 <elliott> !bfjoust ponce []---------->>>>>>>>>((-)*127>)*20
01:34:47 <EgoBot> Score for Sgeo_lie: 0.0
01:34:48 <EgoBot> Score for elliott_ponce: 8.2
01:34:52 <Sgeo> What?
01:34:57 <elliott> 8.2
01:34:58 <elliott> :D
01:35:07 <elliott> !bfjoust ponce [--+.]---------->>>>>>>>>((-)*127>)*20
01:35:15 <EgoBot> Score for elliott_ponce: 8.6
01:35:21 <Sgeo> How did I win not even against the stupid junk? How did noops win more than lie did?
01:35:26 -!- Lymia_ has joined.
01:35:36 <Sgeo> Lymia_, see my question please
01:35:46 -!- Lymia has quit (Disconnected by services).
01:35:46 -!- Lymia_ has changed nick to Lymia.
01:35:47 -!- Lymia has quit (Changing host).
01:35:47 -!- Lymia has joined.
01:35:52 <elliott> !bfjoust ponce [--+++--+-++-+--.]---------->>>>>>>>>((-)*127>)*20
01:35:56 <EgoBot> Score for elliott_ponce: 10.7
01:36:15 <Sgeo> !bfjoust elliott_why_did_this_die >(+)*127
01:36:26 <EgoBot> Score for Sgeo_elliott_why_did_this_die: 2.1
01:36:32 <Sgeo> ...
01:36:49 <elliott> !bfjoust because_poop
01:36:49 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
01:37:06 <Lymia> Sgeo, because your decoy is horrible.
01:37:11 <Lymia> And you do nothing else than set it.
01:37:25 <Sgeo> Yes, but no-ops at least got positive scores before
01:37:41 <Sgeo> Better question: How dymanic is the hill, that I got a positive score the second time
01:37:46 <Lymia> "tripwires" as they seem to be called.
01:38:06 <Lymia> They expect decoys.
01:38:14 <Lymia> And so skip over the first filled cell.
01:38:16 <elliott> someone
01:38:17 <elliott> fix
01:38:17 <elliott> this
01:38:18 <elliott> fucking
01:38:18 <elliott> code
01:38:19 <elliott> shit
01:38:23 <elliott> it's a shitty code
01:38:24 <elliott> of shitness
01:38:29 <elliott> that's an my opinion
01:38:30 <Sgeo> Lymia, _just_ the first?
01:38:40 <elliott> wait
01:38:41 <elliott> maybe i a stupids
01:39:08 <Sgeo> !bfjoust dumb_tripwire_decoy >(+)*127>(+)*127
01:39:19 <EgoBot> Score for Sgeo_dumb_tripwire_decoy: 2.1
01:39:21 <elliott> oh my god it worked!! just kitting
01:39:24 <elliott> i mean kidding
01:39:24 <Sgeo> Probably not enough time for it to work
01:39:27 <elliott> shitfucking
01:39:29 <elliott> um
01:40:45 <elliott> ("o","\ETX#@>. 1#@vv\"@.4\"@#<.>$#v5#.< #>3.#@$ .^@^ 0@# 4.2<v.6_5.@>7.")
01:40:45 <elliott> Wrote to mycotmp0.tmp with o.
01:40:46 <elliott> ok.
01:40:47 <elliott> that.
01:40:49 <elliott> does not look righ.
01:40:50 <elliott> *right.
01:40:53 <elliott> > ord '\ETX'
01:40:53 <lambdabot> 3
01:40:58 <elliott> what.
01:41:01 <elliott> fucking what?
01:41:07 <Sgeo> !bfjoust imprecise_tripwire_decoy >(+)*32>(+)*32>(+)*32
01:41:08 <elliott> ooh, for one i forget to write newlines
01:41:17 <EgoBot> Score for Sgeo_imprecise_tripwire_decoy: 2.1
01:41:31 -!- Sgeo has changed nick to Sgeo2dot1.
01:42:00 <elliott> GOOD: read written data to (-10, -10)
01:42:00 <elliott> GOOD: (-8, -9) is @
01:42:02 <elliott> FUCKING YES
01:42:04 <elliott> YES
01:42:06 <elliott> I JUST NEED BINARY MODE
01:42:07 <elliott> YES
01:42:09 <elliott> FUCKING
01:42:11 <elliott> YES
01:42:15 <elliott> HOTNESS
01:42:20 <elliott> woooooooooooooooooooooooooo
01:42:29 <elliott> and then it's just like
01:42:31 <elliott> concurrent funge
01:42:32 <elliott> and then fingerprints
01:42:35 <elliott> i am amazing
01:42:52 <elliott> i am the best, does everyone agree that i am the best
01:43:44 <Sgeo2dot1> Ignorers suck
01:44:25 <elliott> i don't know any of them
01:44:38 <Sgeo2dot1> ...
01:44:56 <pikhq> elliott: ... Funge-98?
01:44:57 <pikhq> elliott: Dang.
01:45:05 <elliott> pikhq: in two days, in Haskell
01:45:10 <elliott> ok, so I lack:
01:45:25 <elliott> - text (non-binary) mode in i and o (easy to fix for i, slightly harder for o)
01:45:29 <elliott> - concurrent funge (t support)
01:45:29 <elliott> and
01:45:35 <elliott> - any kind of fingerprint support at all
01:45:44 <pikhq> That's still pretty impressive.
01:45:45 <elliott> pikhq: but it passes mycology with no BADs if I tell it I don't support i and o
01:46:00 <elliott> also, it goes pretty fast, apart from when it shrinks the bounds, which I'm going to optimise
01:46:33 <elliott> SLOCDirectorySLOC-by-Language (Sorted)
01:46:33 <elliott> 541 shiro haskell=541
01:46:33 <elliott> yay
01:47:03 <pikhq> ... 541 lines of code‽
01:47:40 <elliott> pikhq: SLOCs.
01:47:45 <elliott> i.e. disregarding whitespace and comments.
01:47:50 <pikhq> Still.
01:48:16 <elliott> apparently it would take $14,174 to develop :-P
01:48:25 <elliott> Total Physical Source Lines of Code (SLOC) = 541
01:48:26 <elliott> Development Effort Estimate, Person-Years (Person-Months) = 0.10 (1.26)
01:48:26 <elliott> (Basic COCOMO model, Person-Months = 2.4 * (KSLOC**1.05))
01:48:26 <elliott> Schedule Estimate, Years (Months) = 0.23 (2.73)
01:48:26 <elliott> (Basic COCOMO model, Months = 2.5 * (person-months**0.38))
01:48:26 <elliott> Estimated Average Number of Developers (Effort/Schedule) = 0.46
01:48:28 <elliott> Total Estimated Cost to Develop = $ 14,174
01:48:30 <elliott> (average salary = $56,286/year, overhead = 2.40).
01:48:41 <elliott> pikhq: look at my beautiful hideous code
01:48:43 <elliott> mergeByteString :: Vector -> FungeSpace -> ByteString -> (Vector, FungeSpace)
01:48:43 <elliott> mergeByteString (ox,oy) fs s = ((bx,by),fs')
01:48:43 <elliott> where ((_,by),fs',_,bx) = B.foldl' byte ((ox,oy),fs,False,0) s
01:48:43 <elliott> byte (p@(x,y),fs,lastWasCR,biggestX) w
01:48:44 <elliott> | w == ff || (w == lf && lastWasCR) = (p, fs, False, biggestX)
01:48:46 <elliott> | w == cr || w == lf = ((ox,y+1), fs, w == cr, biggestX)
01:48:48 <elliott> | w == space = ((x+1,y), fs, False, max (x+1) biggestX)
01:48:50 <elliott> | otherwise = ((x+1,y), insertFS p (fromIntegral w) fs, False, max (x+1) biggestX)
01:52:10 <elliott> pikhq: MOST ELEGANT CODE?
01:52:21 <elliott> yay, binary reading now works
01:52:31 <elliott> o just needs text mode
01:53:19 <elliott> pikhq: You'd like my planned fingerprint implementation design. It involves typeclasses and type families.
01:55:13 <Sgeo2dot1> Wait, the Notion Ink Adam exists now? It's shipping?
01:55:58 <elliott> meh, tablets.
02:03:30 <elliott> ghc: panic! (the 'impossible' happened)
02:03:30 <elliott> (GHC version 6.12.3 for x86_64-unknown-linux):
02:03:30 <elliott> TcTyFuns.flattenType: synonym family in a rank-n type
02:03:32 <elliott> olsner: do i get a prize?
02:08:05 -!- Laugarhraun has quit (Read error: Connection reset by peer).
02:08:17 -!- Laugarhraun has joined.
02:10:38 -!- Laugarhraun has quit (Read error: Operation timed out).
02:14:39 <Lymia> Urg.
02:14:47 <Lymia> It seems that my evolver has hit a local maxima.
02:14:56 <Lymia> -.+-><-.-[.[(.)*2++]]
02:14:59 <Lymia> Completely conserved.
02:15:14 <Lymia> Between 50 generations
02:15:16 * Sgeo2dot1 wants to see the score
02:15:19 -!- Sgeo2dot1 has changed nick to Sgeo.
02:16:00 <Sgeo> !bfjoust Lymias_local_maxima -.+-><-.-[.[(.)*2++]]
02:16:09 <Sgeo> >.>
02:16:42 <Sgeo> RIP EgoBot?
02:16:50 <EgoBot> Score for Sgeo_Lymias_local_maxima: 18.8
02:17:13 <Sgeo> Oh, huh
02:19:04 <elliott> pikhq: OMG, it actually works.
02:20:23 <Lymia> elliott.
02:20:29 <Lymia> Make a call/cc opcode for Befunge.
02:20:36 <elliott> NO :P
02:20:42 <elliott> Lymia: That exists, basically.
02:20:45 <elliott> There's TRDS, which is complete time travel.
02:20:54 <Lymia> :V
02:21:08 <Lymia> Implement call/cc in C.
02:21:13 <elliott> @hoogle (a -> Bool) -> [a] -> Bool
02:21:13 <lambdabot> Prelude all :: (a -> Bool) -> [a] -> Bool
02:21:13 <lambdabot> Prelude any :: (a -> Bool) -> [a] -> Bool
02:21:14 <lambdabot> Data.List all :: (a -> Bool) -> [a] -> Bool
02:21:18 <elliott> @hoogle (a -> Bool) -> [a] -> a
02:21:18 <lambdabot> Data.List find :: (a -> Bool) -> [a] -> Maybe a
02:21:18 <lambdabot> Prelude dropWhile :: (a -> Bool) -> [a] -> [a]
02:21:18 <lambdabot> Prelude filter :: (a -> Bool) -> [a] -> [a]
02:29:58 <elliott> pikhq: haha, this is totally working except for one place where I need unsafeCoerce
02:30:00 <elliott> pikhq: but oh well, right?
02:30:05 <elliott> it'll only break if you break the invariants!
02:33:16 <elliott> pikhq: DO YOU WANT TO SEE MY AMAZING HACK
02:33:19 <pikhq> elliott: ?
02:33:20 <elliott> IT'S REALLY BEAUTIFUL
02:33:22 <elliott> {-# LANGUAGE RankNTypes, TypeFamilies, ExistentialQuantification, StandaloneDeriving, FlexibleContexts #-}
02:33:28 <elliott> And it *actually works!*
02:33:39 <elliott> pikhq: I figured out how to model Funge-98 fingerprints really elegantly in Haskell.
02:33:44 <elliott> No: I mean *really* elegantly.
02:33:47 <pikhq> elliott: Oh dear.
02:33:54 <elliott> It has exactly one use of unsafeCoerce (where GHC is too dumb to know that the types do match).
02:33:57 <pikhq> This hack is probably horrifying.
02:33:57 <elliott> But the rest is totally safe.
02:34:00 <elliott> It's not.
02:34:08 <pikhq> Huh.
02:34:27 <pikhq> So, one instance of unsafeCoerce to get the type system to comply, eh?
02:34:35 <elliott> pikhq: http://hpaste.org/43765/fingerprints Read it. You might want to run "test" in GHCi to see it working. Note that it executes SLLY's F instruction, meaning that once it gets to P, the state flipped to False, which is how it gets output.
02:36:39 <pikhq> elliott: Dang.
02:37:12 <elliott> pikhq: What I'm trying to say is: Jesus christ, I'm going to use unsafeCoerce in an actual program and I don't even feel _ashamed_.
02:37:23 <pikhq> elliott: That's genuinely impressive.
02:37:28 <elliott> Oh, and I plan to use some Template Haskell magic to sweeten the Fingerprint-writing deal.
02:37:40 <elliott> For instance, NULL will look more like:
02:38:13 <elliott> ...well.
02:38:17 <elliott> Point is you won't have to write fpName separately.
02:38:20 <elliott> And the data type will be done for you.
02:38:29 <elliott> And maybe I'll even derive the list of handled instructions.
02:48:31 -!- copumpkin has joined.
03:10:54 -!- Lymia_ has joined.
03:11:08 -!- Lymia has quit (Disconnected by services).
03:11:08 -!- Lymia_ has changed nick to Lymia.
03:11:10 -!- Lymia has quit (Changing host).
03:11:10 -!- Lymia has joined.
03:11:57 <elliott> pikhq: it isn't working with maps :(
03:12:04 <elliott> I don't want an O(n) scan for every fingerprint instruction
03:12:53 <pikhq> elliott: :(
03:13:33 <elliott> *Main> dmInsert NULL fpInitialState dmEmpty `dmAt` NULL
03:13:33 <elliott> NULLState
03:13:34 <elliott> fuck yeah
03:13:42 <Sgeo> elliott, there was an update to Atomo
03:13:48 <elliott> okay
03:15:03 <elliott> Cannot match a monotype with `StateT FungeState IO'
03:15:04 <elliott> wat
03:20:37 <pikhq> wut
03:20:55 <elliott> pikhq: my program has regressed from beauty to beautiful but inscrutable types.
03:46:29 <elliott> pikhq: FIXED IT
03:46:31 <elliott> It uses maps now.
03:48:07 <elliott> pikhq:
03:48:10 <elliott> pikhq: http://hpaste.org/43766/fingerprints_2
03:48:14 <elliott> pikhq: Now with Data.Dynamic.
03:48:20 <elliott> pikhq: Allow me to tell you how awesome this shit is: FUCKING AWESOME
03:48:29 <elliott> It's... just working.
03:50:00 <elliott> pikhq: EXCUSE ME LOOK AT THE AMAZING
03:53:52 -!- azaq23 has joined.
04:05:24 <quintopia> lymia: don't do snipping of dead code. sometimes introns get activated and do useful things. leave the garbage in the evolving code and only remove it from the code that gets /tested/ and /scored/
04:06:39 <Lymia> !bfjoust evo_wtf .++.++++><+-><>-(.[[([-])*2-]-.<.]>++[])*7+.[<.<<<>]+(.(+.-.<)*1.-.)*11[][]<+>.([]-<<[])*9-[+>[.[><.[]<+-><<.<[]+[(<)*8.>]--><(.[-<(-<<><)*12>++([<><][](-(>>>[]<)*2)*1[(>...[]<<([].[-].)*3+[>(+)*9[]])*20])*1+>->><]>[.+(.>.)*14-.<<]<><+.>[].->.+..[]+...>+<>--<[]-++-.+++->+>><.+-)*6>-<<[<<..-]<.(-<<->+)*10+.+>..<<<+.>].>>.-[]>]...>]>>(.+)*4>-+[].+(.+++[.<>]+)*4.<<><-->
04:07:22 <Lymia> quintopia, sometimes, that's easier said than done.
04:07:23 <Lymia> =p
04:08:09 <EgoBot> Score for Lymia_evo_wtf: 0.9
04:08:37 <quintopia> Lymia: then don't do anything about dead code
04:09:22 <elliott> pikhq: http://hpaste.org/43768/fingerprints_3
04:09:25 <elliott> pikhq: Look at testShow.
04:09:31 <elliott> pikhq: That's right, I can print the state of any fingerprint, generically.
04:09:43 <pikhq> Yay,
04:09:44 <elliott> Er. Nested liftIO, lol.
04:09:53 <elliott> pikhq: You don't realise. The states are *Dynamic*s.
04:11:13 <elliott> Having pretty much perfected existence, I'm going to sleep now.
04:11:19 -!- elliott has quit (Quit: Leaving).
04:13:55 <quintopia> it seems quite reasonable that he may actually produce the best funge98 interpreter to date...
04:22:48 <pikhq> At this rate?
04:22:50 <pikhq> Yeah.
04:23:11 <pikhq> Knowing him? ... Actually, still possible that he gets the best funge98 interpreter before he stops. :P
04:25:56 <quintopia> i wouldn't have thought so until tonight. but he's close enough now that the idea can't be discarded
04:26:22 <quintopia> he's a lot like me...i have scads of unfinished lost or broken projects lying around...
04:28:42 <pikhq> Most of us do.
04:30:21 <quintopia> is procrastination in the hacker nature?
04:30:38 <pikhq> Perhaps/
04:40:40 -!- azaq23 has quit (Read error: Operation timed out).
04:42:38 -!- azaq23 has joined.
04:43:59 <myndzi> quintopia: can i get back to you on that?
04:45:44 -!- Wamanuz4 has joined.
04:48:51 -!- Wamanuz3 has quit (Ping timeout: 240 seconds).
04:59:29 <quintopia> myndzi: no need. finding out the answer is a project i will have forgotten in a few days
05:00:35 -!- Zuu has quit (Read error: Connection reset by peer).
05:05:00 -!- Zuu has joined.
05:11:53 -!- myndzi\ has joined.
05:13:39 -!- augur has quit (Remote host closed the connection).
05:14:02 -!- myndzi has quit (Ping timeout: 245 seconds).
05:15:25 -!- amca has joined.
05:16:04 -!- augur has joined.
05:17:41 -!- augur has quit (Remote host closed the connection).
05:27:52 -!- augur has joined.
05:54:05 <Sgeo> Atomo tuples are.... bizarre
05:54:41 -!- zzo38 has joined.
05:56:13 <zzo38> Is it possible to make a printed orchestral score for Purple Motion's musics?
06:06:41 -!- Lymia_ has joined.
06:06:48 -!- Lymia has quit (Disconnected by services).
06:06:50 -!- Lymia_ has changed nick to Lymia.
06:06:52 -!- Lymia has quit (Changing host).
06:06:53 -!- Lymia has joined.
06:25:14 -!- aloril has quit (Read error: Operation timed out).
06:26:17 -!- calamari has quit (Quit: Leaving).
06:31:33 -!- oerjan has joined.
06:35:20 -!- Lymia_ has joined.
06:35:56 -!- Lymia has quit (Disconnected by services).
06:35:57 -!- Lymia_ has changed nick to Lymia.
06:35:58 -!- Lymia has quit (Changing host).
06:35:58 -!- Lymia has joined.
06:40:11 -!- aloril has joined.
06:41:07 -!- azaq23 has quit (Quit: Leaving.).
06:50:05 -!- Lymia_ has joined.
06:53:04 -!- Lymia has quit (Ping timeout: 240 seconds).
06:59:53 <zzo38> Whose idea was it anyways to make C comments start with /* even though / is a valid binary operator and * is a valid unary prefix operator?
07:00:54 <oerjan> fancy google logo...
07:01:08 <zzo38> At least with C++ comments (also valid in many C compilers) start with // which is an invalid syntax in C, so it is OK that the comment starts with //
07:01:26 <pikhq> zzo38: // comments are C99.
07:01:47 <pikhq> As for why /*? I dunno. The block comment syntax in C is a major misfeature.
07:01:49 <zzo38> pikhq: That is one of the good things they added in C99.
07:01:57 * oerjan vaguely recalls someone saying they removed =- for that reason
07:02:23 <oerjan> and i guess =+ and =* too
07:02:38 <pikhq> oerjan: More like "replaced with something saner".
07:02:49 <oerjan> oh the reverse didn't exist?
07:02:56 <pikhq> Nope.
07:03:28 <oerjan> are there any remaining such ambiguities other that /* ?
07:04:24 <pikhq> Probably, but not many, I'd imagine.
07:04:35 <zzo38> There are really strange things such as (x+++++y) which according to the order of the parser, will always cause it to resolve in an invalid way even though there is a way to split it in which is valid, but that is not quite the same kind of thing.
07:04:47 <pikhq> Unlike C++, where you need to evaluate lambda calculus in order to parse. :P
07:05:10 <oerjan> hm haskell has the same problem with things (although not - which would give a comment) followed by -
07:05:24 <fizzie> There's also plain <, which may be a comparison operator or a start of <<; same goes for - and ->.
07:05:25 <oerjan> which is probably the reason they consider unary - ugly
07:05:43 <pikhq> fizzie: Aaah yes.
07:05:45 <zzo38> fizzie: But in C, < is only a binary operator so < < is not a valid syntax.
07:05:52 <pikhq> zzo38: But << is.
07:06:04 <pikhq> << is also a binary operator. :)
07:06:12 <zzo38> Same with -> because - is not a unary suffix operator so - > is not a valid syntax.
07:06:20 <pikhq> -> is *also* a binary operator.
07:06:24 <zzo38> That is why things like << and -> and // are OK.
07:06:35 <fizzie> It is better in that sense than the /* thing.
07:06:36 <oerjan> zzo38: for +++++ i guess it's better to give an error than to mislead when it's ambiguous
07:06:48 <pikhq> True, it is much much better than /*.
07:06:58 <oerjan> although what about just +++ ?
07:07:00 <pikhq> Especially given the really odd rules for *ending* such a comment block.
07:07:16 <pikhq> oerjan: Ow.
07:07:33 <zzo38> oerjan: I think the specification actually says to treat it as (x ++ ++ + y) but that is wrong because x++ is not lvalue.
07:08:02 <zzo38> Such strange cases are not particularly important, though.
07:08:09 <fizzie> +++ is always ++, +; it's the longest token always.
07:08:33 <oerjan> hm
07:09:49 <oerjan> > let x =-3 in x -- >:|
07:09:50 <lambdabot> <no location info>: parse error on input `in'
07:10:08 <zzo38> However, unlike << and -> and // but -- is different because - is valid unary operator to make - - but in this case it is also OK because putting two negative signs cancel each other out and is redundant.
07:10:38 <pikhq> Unary minus in Haskell is very much a hack.
07:10:46 <oerjan> > let x =- y = -y in 2 =- 2 -- >:|
07:10:47 <lambdabot> -2
07:11:17 <zzo38> The more thing happened when the first - is binary operator and the second - is unary, but that also shouldn't matter.
07:11:31 <zzo38> It is only /* which is the worst one.
07:12:45 <zzo38> Do any processors have a command to bitshift a number of any length and use bitwise AND/OR/XOR on numbers of any length?
07:13:09 <oerjan> oh and of course -- does this in haskell too
07:13:25 <zzo38> What does -- do in Haskell?
07:13:30 <pikhq> zzo38: Comment.
07:13:34 <oerjan> > let x +-- y = x+y in 2 +-- 2 -- is a comment
07:13:35 <lambdabot> 4
07:14:01 <pikhq> But it's also an entirely valid string in an operator. :)
07:14:02 <oerjan> in this case putting -- directly after an operator makes it _not_ a comment
07:14:39 <oerjan> although honestly i don't see it as much of a problem because my intuition is already that operator characters fuse in haskell, and i like to use space
07:16:28 <oerjan> > do x <- Just $ 2 < - 2 in x
07:16:29 <lambdabot> <no location info>:
07:16:29 <lambdabot> The last statement in a 'do' construct must be an ...
07:16:31 <oerjan> er
07:16:34 <oerjan> > do x <- Just $ 2 < - 2; x
07:16:35 <lambdabot> Couldn't match expected type `Data.Maybe.Maybe b'
07:16:35 <lambdabot> against inferred ...
07:16:42 <oerjan> bah
07:16:45 <oerjan> > do x <- Just $ 2 < - 2; return x
07:16:46 <lambdabot> Just False
07:17:01 <zzo38> If whoever invented C decided that instead of /*...*/ that a comment is */.../* or {*...*} or (*...*) then you would not have that problem.
07:17:17 <oerjan> ...i guess that lambdabot response captures my attitude to this...
07:18:21 <oerjan> :t do x < - Just $ 2 < - 2; return x
07:18:22 <lambdabot> Couldn't match expected type `Expr'
07:18:22 <lambdabot> against inferred type `a -> Maybe a'
07:18:22 <lambdabot> In the expression: Just
07:18:29 <pikhq> zzo38: Heck, there'd be less of an issue if K&R just made them nest the sane way.
07:18:29 <oerjan> :t \x -> do x < - Just $ 2 < - 2; return x
07:18:31 <lambdabot> Couldn't match expected type `a -> b' against inferred type `Bool'
07:18:31 <lambdabot> In the first argument of `($)', namely `x < - Just'
07:18:31 <lambdabot> In a stmt of a 'do' expression: x < - Just $ 2 < - 2
07:18:41 <oerjan> hmph
07:19:03 <pikhq> zzo38: But, it kinda shows that they really designed around ridiculously simple parsers, as was reasonable back in the day.
07:19:05 <oerjan> oh wait
07:19:23 <zzo38> pikhq: These things has not to do with the nesting of comments, though.
07:19:34 <zzo38> I do not think the comments have to nest.
07:19:49 <pikhq> zzo38: /* /* /* /* */
07:19:56 <pikhq> The above is bloody confusing.
07:20:11 <zzo38> pikhq: It is confusing, but I do not consider it to be the problem.
07:20:17 <pikhq> Well, not *bloody* confusing.
07:20:32 <pikhq> Mix in preprocessor pain and agony and it gets to actually be that way.
07:21:01 <zzo38> The problem is dividing by something pointed from another value.
07:21:03 <pikhq> God damn the C preprocessor.
07:21:49 <zzo38> C preprocessor works for some things.... but some things it doesn't which is why I made things in Enhanced CWEB you can also use the prepreprocessor, and even the preprepreprocessor.
07:22:46 <oerjan> > let x = 1 in do x < - 2 *> Just True; return x
07:22:47 <lambdabot> Precedence parsing error
07:22:47 <lambdabot> cannot mix `GHC.Classes.<' [infix 4] and `Con...
07:23:10 <oerjan> ...they have the _same_ precedence?
07:23:28 <oerjan> > let x = 1 in do x < - 2 >> Just True; return x
07:23:29 <lambdabot> Couldn't match expected type `m a'
07:23:30 <lambdabot> against inferred type `GHC.Bool....
07:23:41 -!- impomatic has joined.
07:23:45 <oerjan> > (0$0 >>)
07:23:45 <lambdabot> The operator `GHC.Base.>>' [infixl 1] of a section
07:23:46 <lambdabot> must have lower pre...
07:24:04 <oerjan> > (0$0 <)
07:24:05 <lambdabot> The operator `GHC.Classes.<' [infix 4] of a section
07:24:05 <lambdabot> must have lower pr...
07:24:16 <oerjan> oh wait
07:24:20 <impomatic> !bfjoust timeout http://candlebags.co.uk/temp/5.txt
07:24:47 <EgoBot> Score for impomatic_timeout: 15.0
07:25:26 <Sgeo> ?
07:25:40 <oerjan> i'm sure there must be _some_ way to get a haskell expression to give two different valid results if you change a <- into < - , but i don't seem to get there with the common operators
07:26:27 <oerjan> hm...
07:26:47 <Sgeo> !bfjoust decoy_for_lazy_programs (>+)*5
07:26:57 <zzo38> However, with -> operator in C, it is not really necessary if they made . do both what . does now and what -> does now, but at least -> works because the individual - > in that sequence is bad, so -> is OK.
07:26:59 <EgoBot> Score for Sgeo_decoy_for_lazy_programs: 0.0
07:27:12 <Sgeo> Awesome, I suck.
07:27:59 <impomatic> !bfjoust timeout http://candlebags.co.uk/temp/5.txt
07:28:06 <EgoBot> Score for impomatic_timeout: 15.2
07:28:28 <Sgeo> !bfjoust nothing_to_see_here (-)*127
07:28:45 <EgoBot> Score for Sgeo_nothing_to_see_here: 8.1
07:30:59 <Sgeo> !bfjoust sine (-)*127[-+]
07:31:15 <EgoBot> Score for Sgeo_sine: 10.9
07:31:17 <zzo38> The C preprocessor is weak but what I think is adding a command to catch compiler errors would be useful.
07:31:20 <Sgeo> Hah
07:31:35 <impomatic> !bfjoust timeout http://candlebags.co.uk/temp/5.txt
07:31:43 <EgoBot> Score for impomatic_timeout: 14.4
07:32:17 -!- zzo38 has quit (Remote host closed the connection).
07:32:27 <impomatic> !bfjoust timeout http://candlebags.co.uk/temp/5.txt
07:32:34 <EgoBot> Score for impomatic_timeout: 15.3
07:36:10 <impomatic> !bfjoust timeout (>)*8(>[++++[-]])*21
07:36:19 <EgoBot> Score for impomatic_timeout: 13.8
07:36:50 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:48:15 -!- clog has joined.
09:48:15 -!- clog has joined.
09:50:48 -!- sixdej|sleep has quit (Ping timeout: 240 seconds).
10:40:53 -!- ais523 has joined.
10:46:25 -!- azaq23 has joined.
10:49:50 -!- FireFly has joined.
11:04:06 -!- hiato has joined.
11:04:06 -!- hiato has quit (Client Quit).
11:08:00 -!- poiuy_qwert has quit (Ping timeout: 240 seconds).
11:11:25 -!- poiuy_qwert has joined.
11:24:24 -!- FireFly has quit (Quit: swatted to death).
11:25:30 -!- ais523 has quit (Remote host closed the connection).
11:25:45 -!- ais523 has joined.
11:34:47 -!- ais523 has quit (Read error: Connection reset by peer).
11:40:03 -!- ais523 has joined.
11:41:32 <oerjan> > let (<$) = fmap . const; infixl 1 <$ in do x <- y <$ Just z ; return x
11:41:33 <lambdabot> Just y
11:41:44 <oerjan> > let (<$) = fmap . const; infixl 1 <$ in do x < - y <$ Just z ; return x
11:41:46 <lambdabot> Just x
11:44:24 <fizzie> Hooray.
11:44:53 <oerjan> there's still that pesky (<$) fixity
11:49:00 <oerjan> > bool
11:49:00 <lambdabot> Not in scope: `bool'
11:49:03 <oerjan> > if'
11:49:04 <lambdabot> Not in scope: `if''
11:50:14 -!- pikhq_ has joined.
11:50:16 -!- pikhq has quit (Ping timeout: 250 seconds).
11:50:48 <oerjan> > let f | x <- 2 = True in f
11:50:49 <lambdabot> True
11:50:54 <oerjan> > let f | x < - 2 = True in f
11:50:55 <lambdabot> *Exception: <interactive>:3:4-21: Non-exhaustive patterns in function f
11:51:08 <oerjan> hm
11:51:38 <oerjan> > let f | x < - 2 = True | otherwise = False in f
11:51:39 <lambdabot> False
11:51:43 <oerjan> > let f | x <- 2 = True | otherwise = False in f
11:51:43 <lambdabot> True
11:51:50 <oerjan> ok that one works
11:53:25 <fizzie> You win a point.
11:58:28 -!- pikhq_ has quit (Read error: Operation timed out).
12:00:50 -!- pikhq has joined.
12:10:10 -!- amca has quit (Quit: Farewell).
12:42:07 -!- azaq23 has quit (Ping timeout: 260 seconds).
12:43:30 -!- azaq23 has joined.
12:50:50 -!- azaq231 has joined.
12:51:27 -!- azaq231 has quit (Changing host).
12:51:27 -!- azaq231 has joined.
12:52:28 -!- azaq23 has quit (Ping timeout: 240 seconds).
12:53:01 -!- azaq231 has changed nick to derivector_azaq2.
12:53:16 -!- derivector_azaq2 has changed nick to derivector.
12:53:23 -!- derivector has changed nick to azaq23.
13:06:56 <ais523> curious: defend7 and chainmail beat the entire field of programs between them, and tend to do well against programs the other does badly against
13:06:59 <ais523> despite being almost identical
13:07:03 <ais523> I wonder what's happening there?
13:30:50 -!- FireFly has joined.
13:32:54 -!- yiyus_ has changed nick to yiyus.
13:34:55 -!- azaq23 has quit (Ping timeout: 240 seconds).
13:47:46 -!- azaq23 has joined.
14:05:44 <Vorpal> ais523, details of timing?
14:06:00 <Vorpal> just an idea
14:06:03 <ais523> Vorpal: that seems pretty likely to be involved, indeed
14:06:17 <ais523> but it's strange how they're so completely different in that respect
14:06:58 <Vorpal> ais523, apart from that I can only recommend the obvious method of trying various changes to make one of them more like the other and see which change makes what happen
14:09:40 <Vorpal> ais523, err, you might know the answer to this: I'm looking for a directed graph (may or may not be acyclic) data type in haskell, able to label nodes and edges. Where should I look? I don't really know the standard library of haskell very well yet but I presume it is there somewhere.
14:10:18 <ais523> I don't know Haskell's stdlib well at all
14:10:22 <ais523> @hoogle graph
14:10:22 <lambdabot> module Data.Graph
14:10:22 <lambdabot> module Data.Graph.Inductive.Graph
14:10:23 <lambdabot> Data.Graph type Graph = Table [Vertex]
14:10:26 <Vorpal> hm
14:10:30 <ais523> lambdabot does, though
14:10:38 <Vorpal> right. didn't know that command
14:10:44 <ais523> but that might not be what you want
14:10:57 <Vorpal> ais523, well hard to tell. guess I'll google it
14:11:39 <Vorpal> if it is the same as this http://www.haskell.org/ghc/docs/latest/html/libraries/containers- ?
14:14:23 -!- poiuy_qwert has quit (Read error: Operation timed out).
14:14:40 <ais523> looks like it
14:14:40 <Vorpal> indeed not
14:14:46 <Vorpal> ais523, doesn't label edges
14:14:59 <Vorpal> I need multiple differently labeled edges between the same node pair sometimes
14:15:24 <ais523> aha, I think I've identified a flaw in defend7, which is also potentially in chainmail but harder to trigger
14:16:28 <ais523> !bfjoust defend10 http://sprunge.us/ZXiO
14:16:31 <Vorpal> I admit ignorance. What is an inductive graph?
14:16:36 <ais523> I'm not sure either
14:16:43 <ais523> I'm hardly a Haskell expert
14:16:46 <Vorpal> because Data.Graph.Inductive.Graph has labeled edges
14:17:08 <Vorpal> type UEdge = LEdge () "Quasi-unlabeled edge" <--- heh
14:17:21 <ais523> haha
14:17:28 <EgoBot> Score for ais523_defend10: 39.0
14:17:42 <Vorpal> ais523, which is strange since it also has type Edge = (Node, Node) which is just "Unlabeled edge"
14:18:06 -!- pikhq has quit (Read error: Operation timed out).
14:18:38 <ais523> hmm, that just made things even more confusing
14:18:45 <ais523> it definitely depends on minor timing details
14:19:20 <ais523> !bfjoust defend10 http://sprunge.us/EZYj
14:19:36 <EgoBot> Score for ais523_defend10: 36.8
14:20:22 <Vorpal> now if I just could figure out what the hell an inductive graph was...
14:20:23 -!- pikhq has joined.
14:20:29 <Vorpal> google isn't very helpful
14:20:34 <Vorpal> who here is a haskell expert
14:20:34 -!- poiuy_qwert has joined.
14:21:47 <ais523> !bfjoust defend10 http://sprunge.us/MWQf
14:21:58 <ais523> that one works on a bit of a different mathematical formula
14:22:00 <EgoBot> Score for ais523_defend10: 0.0
14:22:06 <ais523> wait what?
14:22:17 -!- BeholdMyGlory has joined.
14:22:24 <Vorpal> ais523, must have an error
14:23:11 <Vorpal> !bfjoust test .
14:23:16 -!- poiuy_qwert has quit (Client Quit).
14:23:22 <EgoBot> Score for Vorpal_test: 8.6
14:23:31 <Vorpal> see. even that... so likely an error
14:23:50 <ais523> nope, I just got the maths wrong
14:24:02 <ais523> oh, haha, not that either
14:24:08 <ais523> or, yes, is that
14:24:59 <Vorpal> !bfjoust test >+<.
14:25:07 <EgoBot> Score for Vorpal_test: 0.0
14:25:12 <Vorpal> ah
14:26:07 <fizzie> There is that FGL thing.
14:26:22 <fizzie> I don't know if it's any good and/or maintained.
14:26:30 <fizzie> ("Functional Graph Library" or something.)
14:26:44 <fizzie> I just remember seeing a libghc6-blah package for it in Ubuntu.
14:27:38 <fizzie> It seems to be Data.Graph.Inductive.
14:27:46 <fizzie> Based on http://hackage.haskell.org/package/fgl
14:28:23 <Vorpal> fizzie, any idea what it means with "inductive graph"
14:28:36 <ais523> !bfjoust defend10 http://sprunge.us/EIJX
14:28:51 <EgoBot> Score for ais523_defend10: 10.7
14:28:57 <Vorpal> whops have to rush
14:28:59 <fizzie> I *think* it just means their way of doing a graph API, nothing specially particular.
14:29:04 <fizzie> But I could be worng there.
14:29:18 * Sgeo goes insane due to lack of accomplished homework
14:29:32 <fizzie> Graph-as-a-recursive-datatype sort of thing.
14:32:04 -!- Sgeo has quit (Quit: Need to accomplish a weekend's worth of homework in 10 minutes.).
14:35:20 <ais523> !bfjoust defend10 http://sprunge.us/CWIN
14:35:39 <EgoBot> Score for ais523_defend10: 55.1
14:36:00 <ais523> that's a genuinely different mathematical principle from defend7, now
14:37:12 <ais523> and straight to the top of the leaderboard
14:37:22 <ais523> not bad after the previous two versions scored 0 and 10.7
14:44:28 <oerjan> <ais523> but that might not be what you want <-- well if hoogle doesn't find it, i think the next step is to look in hackage...
14:47:00 <oerjan> mind you all i really recall about graphs in haskell is that there are packages but it's supposedly awkward to do functionally
14:47:15 <oerjan> also you seem to want multigraphs...
14:47:23 <oerjan> Vorpal: ^
14:47:35 <ais523> it seems that defend10 wins more convincingly than defend7 against many opponents where they both win, too
14:50:53 -!- azaq23 has quit (Quit: Leaving.).
15:00:07 * oerjan ponders if we should make an Esolang:Classics page for listing particularly interesting languages
15:00:57 <oerjan> hm i guess i should post this on the wiki
15:04:34 <ais523> that sounds like a POV nightmare, with everyone wanting their own langs there
15:04:43 <ais523> not that I'm opposed to the concept if it's workable
15:04:51 <ais523> hmm, whatever happened to the Essies?
15:05:02 <oerjan> ais523: ah but i had an idea for a sponsoring rule - and you cannot sponsor your own language
15:05:14 <oerjan> i.e. this page would _not_ be free for all
15:05:56 <ais523> perhaps the wiki isn't the best place for it, then
15:05:58 <oerjan> or would it still be a problem with sockpuppets...
15:06:16 <ais523> although I suppose it's the only even partially active esolangs forum other than #esoteric
15:06:28 <ais523> sockpuppets wouldn't necessarily be a problem, you could think up ways to exclude them
15:06:46 <oerjan> well the thing is there are _so_ many languages on the wiki that it's hard to find the good stuff
15:07:09 <oerjan> well there is the Special:Favorites page, or what it's called
15:07:18 <oerjan> and the Timeline
15:07:39 <oerjan> well i guess i'm really just asking for a bit better organization
15:07:42 <Vorpal> <fizzie> Graph-as-a-recursive-datatype sort of thing. <-- hm, can it handle cycles
15:07:49 <Vorpal> fizzie, I'm pretty sure I will have cycles
15:07:57 <fizzie> Sure.
15:08:02 * oerjan is having second thoughts
15:08:20 <Vorpal> <oerjan> also you seem to want multigraphs... <-- yes indeed
15:08:53 <oerjan> Vorpal: although in some ways you could do multigraphs with a label that was a set, maybe
15:09:14 <oerjan> although whether that fits the algorithms you need to use...
15:09:50 <Vorpal> oerjan, what I'm looking for I guess is something like erlang's digraph module, which can do various types of digraphs depending on what you request. In it's most general variant that would be directed multigraphs with cycles I guess
15:09:57 <fizzie> My initial assumption would be that in FGL graphs you could insert multiple differently-labeled edges between two nodes, but it doesn't seem to be very comprehensively documented.
15:10:08 <Vorpal> oerjan, well that seems somewhat awkward, though it could be done
15:10:51 <oerjan> Vorpal: hm will you have _loops_? (cycles from an edge to itself)
15:10:54 <oerjan> *vertex
15:11:50 <oerjan> Vorpal: i guess what you need depends on what you need to do with it - if it's just something simple you might just want to roll your own
15:12:00 <Vorpal> oerjan, I think the smallest cycle I will have would contain at least two nodes.
15:12:05 <oerjan> ok
15:12:21 <Vorpal> yep. I can't think of how I could get loops
15:12:40 <Vorpal> oerjan, anyway yes I could roll my own, but I don't like to reinvent the wheel
15:12:58 <Vorpal> not unless I have a reason to at least
15:13:46 <Vorpal> oerjan, anyway, I will very likely need to update the graph quite a bit. So it would be preferable if that wasn't a too expensive operation
15:13:56 <oerjan> hm
15:14:37 <oerjan> Vorpal: purely function might not be the best then, but i don't know how good those packages are. i guess you just have to read their documentation (if they have any)
15:14:43 <oerjan> *functional
15:14:51 <fizzie> FGL's source is short and (moderately) cryptic. :p
15:15:03 <fizzie> At least for the Data.Graph.Inductive.Graph module.
15:15:04 <Vorpal> oerjan, haskell would be nice for various other reasons for this thing, but I might go for another language if that would be less work.
15:15:13 <fizzie> insEdge :: DynGraph gr => LEdge b -> gr a b -> gr a b
15:15:13 <fizzie> insEdge (v,w,l) g = (pr,v,la,(l,w):su) & g'
15:15:13 <fizzie> where (Just (pr,_,la,su),g') = match v g
15:15:37 <fizzie> It's quite tuplestic.
15:15:40 <Vorpal> heh
15:15:41 <oerjan> Ledge is labeled edge, i presume
15:15:49 <Vorpal> oerjan, from the docs it seemed like that yes
15:15:53 <fizzie> Yes, LEdge b is (Node, Node, b).
15:15:55 <oerjan> *Ledge
15:15:57 <oerjan> er
15:16:01 <oerjan> *LEdge
15:16:12 * oerjan swats his left middle finger
15:16:27 <oerjan> oh wait it's the right pinky which needs swatting
15:17:01 <oerjan> well insEdge doesn't look bad at least
15:17:51 <ais523> Vorpal: writing an Eodermdrome interp? (although that probably wouldn't need labeled edges unless it would help for algorithmic purposes)
15:18:24 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
15:18:30 <Vorpal> oerjan, I expect this kind of workflow: insert lots of nodes and edges, then a longer period of removing with a handful of inserts only.
15:18:37 <Vorpal> ais523, alas no.
15:18:45 <oerjan> ais523: heh
15:18:57 <Vorpal> ais523, I shall check out that language though
15:18:59 <Vorpal> sounds interesting
15:19:06 <ais523> it is, but a pain to implement
15:19:07 <oerjan> it's a bitch to program ;D
15:19:10 <oerjan> *too
15:19:20 <Vorpal> oh that one
15:19:24 <ais523> yep, I think I wrote one (untested) program than gave up
15:19:26 <Vorpal> I seen the wiki page before
15:19:31 <ais523> *I saw?
15:19:39 <oerjan> well my program is also untested of course
15:19:40 <Vorpal> have seen*
15:19:40 <Vorpal> even
15:19:52 <ais523> hmm, indeed, although that's rather needlessly formal
15:20:09 <oerjan> or well "of course" i _think_ there's an interpreter floating around somewhere (by oklopol?) but maybe not online
15:20:38 <oerjan> *I've seen, maybe?
15:20:48 <ais523> I remember oklopol was writing one, but IIRC didn't see the finished product
15:20:53 <Vorpal> anyway, it is language implementation related, but I do not wish to reveal everything atm because it might just not work out at all, in which case I don't want elliott laughing at me. :P
15:20:59 <Vorpal> brb phone
15:22:10 <oerjan> ais523: when i thought about writing an eodermdrome interpreter i got this idea that there's a near endless amount of indexing you might want to do to make finding subgraphs reasonable efficient
15:22:34 <oerjan> like having a list of all single-edge vertices, etc.
15:22:41 <ais523> indeed, it's one of those esolangs where a clever caching strategy can make it run much faster
15:22:42 <oerjan> *reasonably
15:22:55 <ais523> like 1cnis or Feather, although just trying to get Feather to work at all is hard enough
15:23:30 <ais523> I think what I'll do is get an interp written in Scheme working first, and then write a Scheme interp designed to interpret Scheme programs interpreting Feather efficiently
15:23:37 <ais523> which is likely easier than trying to write a second Feather interp
15:33:13 <Vorpal> back
15:34:38 <Vorpal> hrrm. Data.Graph.Inductive.Graph lacks topsort (I expect my processing of it will remove all cycles, and then I want to topsort it)
15:36:23 <Vorpal> actually it seems that erlang has exactly the module I need. And well documented. And it is fast for updating (it is implemented in a non-pure way if you look deep enough)
15:36:51 <Vorpal> but other than this (main) structure of the program haskell would be so much nicer
15:37:09 <Vorpal> @hoogle digraph
15:37:09 <lambdabot> No results found
15:37:15 <Vorpal> well, worth a try
15:39:39 <fizzie> Vorpal: topsort's in Data.Graph.Inductive.Query.DFS.
15:39:44 <fizzie> Applicable to a Graph.
15:39:50 <Vorpal> fizzie, aha
15:40:00 <fizzie> (After all, DFS is how you topologically sort a DAG.)
15:40:46 <fizzie> (Okay, so it's a pretty poor justification.)
15:41:06 <ais523> `addquote <elliott_> "My real name is 4, but I go by fizzie3 on the Internet. I log in as 1."
15:41:52 <HackEgo> 300) <elliott_> "My real name is 4, but I go by fizzie3 on the Internet. I log in as 1."
15:42:03 <fizzie> Is that referring to something? It really sounds like it is.
15:43:04 <ais523> fizzie: it's when you logged in yesterday via USER 1 2 3 4
15:43:06 <Vorpal> fizzie, I have to say that library is very poorly documented though.
15:43:20 <ais523> I was `addquoting from logreading
15:43:24 <Vorpal> it doesn't even list complexity of functions like insertion and so on
15:43:27 <fizzie> ais523: Yes, but the actual thing. It sounds like a paraphrased quote from some fictional work.
15:43:54 <ais523> ah
15:44:19 <ais523> there's a bit near the end of Alice Through the Looking Glass that works a bit like that, but it's different enough that that isn't a paraphrased quote
15:45:19 -!- copumpkin has joined.
15:46:07 <ais523> hey, in Befunge-98, if you manage to completely delete every command from fungespace, leaving it with spaces everywhere, what does y return?
15:46:20 <ais523> (I'm wondering if that's an "if a tree falls..." question, or if there's some way to actually run y on a blank fungespace)
15:46:26 <ais523> in particular, for the fungespace bounds
15:47:00 <ais523> it's easy to see bounds update algos going into an infinite loop on empty fungespace; but then, the program goes into an infinite loop then anyway, so that behaviour can't be said to be incorrect
15:47:06 <Vorpal> ais523, I don't think you can. Unless you use some multiverse-style fingerprint. Even k trickery wouldn't be enough here
15:47:39 <ais523> not even t trickery, I think
15:47:44 <Vorpal> indeed
15:49:37 <fizzie> ais523: The EXEC fingerprint has X (cmd n --) "execute command on stack n times".
15:49:42 -!- MigoMipo has joined.
15:49:55 <ais523> that would work, I think
15:50:10 <fizzie> You'd need to execute the X itself, though.
15:50:10 <Vorpal> ais523, I can tell you what would happen when loading an empty file in cfunge, and that is that the boundsvalid variable would never be set to true. I don't know what effects that has. I never investigated the empty file case further than "yep, it seems to be an infinite loop, *hits ctrl-c*"
15:50:22 <ais523> you can use X containing X
15:50:30 <ais523> with the first copied X running p, and the second running y
15:50:40 <Vorpal> fizzie, k and X trickery could do it
15:50:54 <ais523> Vorpal: what about annihilator programs?
15:50:55 <fizzie> Yes, that sounds possible.
15:51:04 <ais523> yep, both kX and 'XX seem to work
15:51:10 <ais523> with suitable stack layouts
15:51:14 <Vorpal> ais523, well they end up with infinite loop. I never investigated where the loop was
15:51:22 <Vorpal> ais523, but cfunge updates bounds lazily.
15:51:34 -!- Phantom_Hoover has joined.
15:51:38 <ais523> even in slowdown.b98?
15:52:21 <fizzie> ais523: I'm not sure if EXEC implementations are typically tested against recursive X, though.
15:52:25 <Vorpal> ais523, the logic in the wrapping code goes something like: if not exact bounds, and maxbounds - minbounds > somelargeconstant: force a shrink
15:52:57 <ais523> ah, I see
15:52:59 <Vorpal> ais523, the constant is indeed a fudge factor that I arrived at with some testing on my sempron 3300+ system. Might vary between systems of course
15:53:00 <ais523> that makes sense
15:54:14 <Vorpal> ais523, same as I switch shrinking algorithm when the bound difference is large enough, by assuming we are dealing with a sparse rather than compact funge space (and thus shrinking by stepping borders inwards would be stupid).
15:54:56 <ais523> being stupidly micro-optimised is so eso in its own right
15:55:13 <Vorpal> hm does mycology test what happens if you kp and then ensures the stack is such that it overwrites the k in the middle of the loop?
15:56:08 <Vorpal> ais523, actually those two are not microoptimising. They are just switching to algorithms that don't take tens of seconds for slowdown.b98. No other program runs into this sort of huge bound shrinking in practice.
15:56:22 <ais523> indeed
15:57:24 <Vorpal> ais523, anyway, no one ever complained about stuff like BLAS generally needing to be tuned to the specific system!
15:57:40 <Vorpal> (okay that is quite different, but still)
16:08:41 -!- asiekierka has joined.
16:09:52 <ais523> uh-oh, heard in the office: "what's the point of [Apple keyboards]"
16:10:06 <ais523> this argument could last a while
16:10:09 <Vorpal> ais523, why [ ]? Did it replace some profanity?
16:10:16 <ais523> it replaced a pronoun
16:10:20 <Vorpal> ah
16:10:33 <Gregor> Namely, "him"
16:10:54 * oerjan facepalms and then swats Gregor -----###
16:10:54 <Vorpal> ais523, not a lot unless you have a mac, and even then just for key labels (cmd or whatever)
16:11:03 <ais523> Gregor: I forget which pronoun it was now (probably "that"), but "him" seems unlikely
16:11:10 <Gregor> :P
16:11:32 <ais523> TODO: censor all the pronouns in http://en.wikipedia.org/wiki/Special:Search?go=Go&search=Brainfuck
16:11:43 <Vorpal> ais523, besides aren't all apple keyboards ultra flat or something?
16:11:48 <ais523> actually, I think someone did something similar a while back
16:11:49 <Vorpal> or do they still make proper keyboards?
16:11:53 <ais523> Vorpal: I don't know, I'm not a keyboard maniac
16:17:25 <ais523> <Sgeo> !bfjoust attack_15 (>)*15[-] <--- that's a pretty specific program
16:17:38 <ais523> I suppose it beats pretty much anything on a program with tape length 16, and fails otherwise
16:18:00 <Gregor> Well, that's 1/21 tape lengths :P
16:18:31 <ais523> yep
16:18:42 <ais523> it didn't do very well
16:18:45 <ais523> but the concept is hilarious
16:19:09 <ais523> (tripstridewire does that on tape length 10, with the exception that it doesn't just give up on different lengths)
16:19:25 <ais523> (and uses an offset clear)
16:19:32 <Gregor> !bfjoust aaaaah_motherland (>++)*5(----<)*5[(>++++)*5(----<)*5]
16:19:53 <EgoBot> Score for Gregor_aaaaah_motherland: 0.0
16:19:58 <Gregor> lol
16:20:04 <ais523> <Sgeo> lolwhat at the [] <--- defend10, currently top of the leaderboard, doesn't just contain [] but [[]]
16:20:04 <Gregor> That is surprisingly bad :P
16:20:24 <Vorpal> Gregor, why that name
16:20:27 <ais523> Gregor: programs that set up decoys and then don't do anything else tend to do very terribly on the current hill
16:20:33 <Gregor> Vorpal: AAAAH MOTHERLAND
16:20:38 <ais523> and it's hard to see how they could do well on most others
16:20:48 <Vorpal> Gregor, yes why that. Is it a reference to something
16:20:49 <Vorpal> ?
16:20:55 <oerjan> ais523: um [[]] is entirely redundant, right?
16:20:56 <Gregor> Vorpal: AAAAH MOTHERLAND
16:21:02 <ais523> oerjan: no
16:21:10 <oerjan> i mean
16:21:15 <ais523> ]] checks to see that the opponent isn't interfering with the cell
16:21:16 <oerjan> equivalent to []
16:21:16 <Vorpal> Gregor, stop that. You are acting like elliott now
16:21:24 <oerjan> oh
16:21:28 <ais523> so you only leave the loop if it's zero two cycles in a row (the lose condition)
16:21:40 <Gregor> Vorpal: There is no reasoning behind the name :P
16:21:45 <ais523> several programs won't leave a cell until it's zeroed two cycles in a row, so you're detecting them detecting you
16:21:46 <Vorpal> Gregor, ah
16:21:52 <ais523> while not accidentally tripping on, say, an offset clear
16:22:00 <ais523> which takes the cell past 0 and then back to 0
16:22:58 <oerjan> Gregor: i got this soviet vibe from it
16:23:12 <Gregor> oerjan: That was the intended vibe :P
16:23:17 <Vorpal> ais523, but which cell does it do that [[]] on?
16:23:28 <ais523> second cell, which is set to 1
16:23:32 <Vorpal> ais523, ah
16:23:42 <ais523> any nonzero value will do, it's just checking to see when the opponent clears it
16:23:48 <Gregor> !bfjoust
16:23:48 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
16:23:51 <Vorpal> ais523, and then what. Tries to defend the real square?
16:23:54 <ais523> you could also check to see how, e.g. detecting offset clears, but defend10 doesn't do that
16:24:06 <ais523> and yep, it tries to lock the opponent in an infinite loop on that square
16:24:10 <Vorpal> ais523, have you considered defending cell 2 then cell 1 and then cell 0?
16:24:11 <Gregor> I am so, so bad at BFJoust :P
16:24:17 <ais523> while slowly looping all the other squares on the tape down to 0
16:24:36 <Vorpal> ais523, how does it avoid running off the remote end?
16:24:41 <ais523> Vorpal: I have, but there doesn't seem to be much of a point, unless maybe you defended them with different algos
16:24:54 <ais523> and by looping each square through 256 possible values before moving onto the next
16:25:15 <ais523> if it does that to a flag, the program ends before it runs off the end; if it does it to a non-flag, then it's safe to move forwards
16:25:22 <Vorpal> ais523, what is the tape length range now again?
16:25:26 <ais523> 10 to 30
16:25:29 <Vorpal> right
16:25:31 <ais523> inclusive
16:26:13 <ais523> as for which square to place the decoy on, that's the main difference between my defend7 and impomatic's chainmail
16:26:54 <Vorpal> ais523, has anyone invented any majorly different type of program the past few months?
16:26:56 <Gregor> !bfjoust nonsense (-)*127++[(----++++)*50]
16:27:00 <ais523> multiple defence only really makes sense if a) you can detect that your defence failed so as to move back (not too difficult, move back a few cycles early and check to see if it's 0 two cycles in a row); b) you have a different algo for the square before
16:27:06 <ais523> Vorpal: I'd say stridewires are a new program type
16:27:12 <Vorpal> ais523, how do they work
16:27:12 <EgoBot> Score for Gregor_nonsense: 14.3
16:27:31 <Gregor> That's the highest score I've ever gotten X-P
16:27:35 <ais523> by looking not at every tape element, but at alternate elements
16:27:56 <Vorpal> ais523, tripwire would pass defend7 by just jumping over it's decoy, right?
16:27:58 <ais523> so the idea is that opponents generally set several decoys, and half the time you skip the first
16:28:14 <ais523> Vorpal: and yes, except that defend7 has a second decoy just to trip tripwires
16:28:17 <Vorpal> ah
16:28:40 <Gregor> !bfjoust obvious (>)*9([[-]]..>)*21
16:28:48 <EgoBot> Score for Gregor_obvious: 9.5
16:29:01 * pikhq revels in a "Screw you guys, I'm not coming in" day
16:29:01 <ais523> Gregor: that's like my stupid defender clearer
16:29:05 <Vorpal> ais523, you could fool stridewires by spacing your decoys correctly. At least for about half of the runs
16:29:11 <Vorpal> ais523, have anyone tried this?
16:29:19 <ais523> so-called both because it clears stupid defenders, and because it stupidly clears defenders
16:29:38 <ais523> Vorpal: stridewires aren't very good, so it hasn't really been necessary
16:29:45 <ais523> and even then, they could randomise their spacing to counteract it
16:30:05 <ais523> the reason tripstridewire does as well as it does is because a) it tends to win on short tapes due to being so aggressive, and b) it wins a fraction of the longer ones
16:30:17 <Vorpal> mhm
16:30:20 <ais523> so although it tends to lose overall, most of them are close losses rather than losing on every length
16:30:38 <ais523> which lets its resounding wins counteract that to some extent
16:31:51 <ais523> Gregor: what would be nice would be if report.txt didn't just say +/-/0, but gave an indication of the extent of the win or loss; i.e. a different code for winning on all 42 runs, to winning 40 of them, to winning 22 of them
16:32:03 <Vorpal> ais523, how do programs counteract shudders. they make the "two turns in a row" bit quite hard to achieve
16:32:08 <ais523> the table at the bottom's a little misleading in that respect atm
16:32:19 <ais523> Vorpal: oh, you simply - while the enemy's doing + after zeroing it
16:32:32 <ais523> [-] against a typical shuddering program actually wins
16:32:38 <Vorpal> ais523, hm right. What about something like (-)*10000 then
16:32:47 <Vorpal> ais523, that won't do the plus bit
16:32:54 <ais523> that works better, but gives you no time for logic
16:33:02 <ais523> it's still counteracted by doing + at the right moment, though
16:33:05 <Vorpal> ais523, indeed. But it does worse than shudder
16:33:06 <Vorpal> iirc
16:33:09 <ais523> so it loses against [+]
16:33:15 <Vorpal> hm
16:33:16 <Vorpal> true
16:33:34 <ais523> defend10 does (-)*128 for timing purposes, on its own flag
16:33:55 <ais523> which doesn't run long enough to lose to anything but a no-op
16:34:01 <ais523> (and no-ops never trigger the tripwire)
16:34:19 <Vorpal> ais523, err is the starting value 127 or?
16:34:23 <ais523> it's 128
16:34:24 <Vorpal> I forgot
16:34:26 <Vorpal> ah
16:34:34 <ais523> but if the opponent changes it at all, you don't zero your own flag doing that
16:34:40 <ais523> and defend10 tries to make pretty sure the opponent will
16:34:58 <ais523> (that can be exploited to defeat defend10, but at the cost of losing to pretty much everything else, so I doubt people will try)
16:35:11 <ais523> (and there are better ways to counter defence programs)
16:35:21 <Vorpal> ais523, such as?
16:35:56 <ais523> mostly doing a lot of random + and - instructions to zero flags
16:36:19 <ais523> which fails against attack programs, but you can try to detect defense programs and react accordingly
16:36:28 <Vorpal> mhm
16:36:46 <ais523> by putting another loop immediately after your zeroing loop, as in [-][+.++.---.-+----]
16:37:08 <Vorpal> right
16:37:34 <ais523> that is, if the defence program doesn't lock you in the initial [-]
16:38:10 <Vorpal> ah
16:38:11 <Vorpal> ais523, figured out the defend7 - chainsaw result differences btw?
16:38:26 <ais523> I think it's to do with odd/even polarity on the decoy
16:38:35 <ais523> vs. odd/even timing differences in the programs they're beating
16:38:41 <Vorpal> ah
16:39:07 <ais523> locking the flag at always odd numbers means it never hits 0, locking it at always even numbers lets the opponent escape from a lock
16:40:30 <Vorpal> !bfjoust test (>)*9([-][+--.-+]>)*30
16:40:34 <EgoBot> Score for Vorpal_test: 14.2
16:40:37 <pikhq> Huh. Debian *might* in the future be going back to Firefox.
16:40:55 <ais523> !bfjoust counterdefence (>)*8(>(+)*128)*21
16:40:58 <EgoBot> Score for ais523_counterdefence: 1.6
16:41:03 <ais523> not surprising
16:41:11 <ais523> because several defence programs aren't simplistic enough to fall for it
16:41:28 <pikhq> Apparently the Firefox copyright policy on the full-and-proper Firefox logo changed, making it so that Debian can reasonably comply with the trademark policy.
16:41:30 <ais523> in fact, none of the current ones are :)
16:41:34 <Vorpal> ais523, that table in the results. Which way do you read it
16:41:45 <ais523> row is the program that gets +, 0, -
16:41:49 <ais523> column is the program it was playing against
16:41:52 <Vorpal> aha
16:42:12 <pikhq> So, Debian is currently filing for a trademark license from Mozilla.
16:42:21 <Gregor> So I'm told.
16:42:47 <Gregor> I won't want to be running Firefox instead of Iceweasel though :(
16:42:49 <Vorpal> pikhq, why
16:43:33 <Gregor> I figured out yesterday that Fluidsynth reliably puts 120 extra samples at the end of every track (between tracks + at the end) and 64 more extra samples at the end.
16:43:35 <Vorpal> !bfjoust test >->+(>)*9([-][+--.-+]>)*30
16:43:39 <EgoBot> Score for Vorpal_test: 5.2
16:43:41 <pikhq> Vorpal: The main holdup on them branding the package as Firefox was that the Firefox logo's *copyright* license wasn't DFSG, apparently.
16:43:42 <Gregor> I had to figure this out to get exactly-perfect seamless looping.
16:43:44 <Vorpal> !bfjoust test >->+(>)*7([-][+--.-+]>)*30
16:43:52 <EgoBot> Score for Vorpal_test: 7.2
16:43:58 <Vorpal> !bfjoust test (>)*9([-][+--.-+]>)*30
16:44:01 <pikhq> Vorpal: And you couldn't get a trademark license for the Firefox name without using the Firefox logo.
16:44:09 <EgoBot> Score for Vorpal_test: 14.2
16:44:15 <pikhq> Vorpal: Now, the copyright license is DFSG.
16:44:16 <Vorpal> pikhq, heh
16:44:33 <Gregor> pikhq: That was the original reason, then there was this bulge of other reasons, then those sort of mostly went away, but left the original reason.
16:44:42 <pikhq> Gregor: Ah, right, yes.
16:44:49 <Vorpal> ais523, it seems that if a program sucks in general removing decoys will help
16:44:56 <pikhq> Gregor: It's the *relevant* reason. :)
16:44:59 <Vorpal> due to all those tripwires
16:45:08 <ais523> Vorpal: heh, yes
16:45:27 <ais523> actually, there's only two tripwires on the hill atm (tripstridewire, and shade)
16:45:42 <Vorpal> ais523, you should compare good attackers with and without decoys
16:46:15 <ais523> two good attackers vs. each other, effective decoys (i.e. decoys that are zeroed in the wrong direction) tend to make or break the game
16:46:36 <ais523> tripstridewire vs. mirage is an amazing match to watch in a debugger
16:47:09 <ais523> for some tape lengths, the opposing flag is less than 10 or so when a program loses
16:47:13 * Vorpal imagines BFJoust world cup
16:50:31 <Vorpal> ais523, what does mirage do?
16:50:56 <ais523> it's just a slow rush program
16:51:01 <Vorpal> which means?
16:51:03 <ais523> large decoys, a few tweaks against defenders
16:51:09 <Vorpal> ah
16:51:27 <ais523> it attacks, but slowly, trying to spend time to make the opponent spend more, and so reach the flag first
16:51:41 <coppro> !bfjoust bad (+>->)*40(>[+])*1000
16:51:43 <EgoBot> Score for coppro_bad: 0.0
16:51:47 <coppro> O_o
16:51:59 <coppro> !bfjoust bad (+>->)*10(>[+])*1000
16:52:02 <Vorpal> coppro, it goes off the end of the tape yah
16:52:03 <Vorpal> yeah*
16:52:04 <EgoBot> Score for coppro_bad: 0.0
16:52:25 <Vorpal> try *5
16:52:33 <coppro> !bfjoust bad (+>->)*5(>[+])*1000
16:52:40 <EgoBot> Score for coppro_bad: 10.4
16:52:44 -!- elliott has joined.
16:52:53 <coppro> !bfjoust silly ([[]+])*100
16:53:07 <EgoBot> Score for coppro_silly: 8.2
16:53:20 <Vorpal> coppro, try 10000 or such
16:53:23 <elliott> hi
16:53:26 <coppro> !bfjoust silly ([[]+])*1000000
16:53:28 <Vorpal> elliott, hello
16:53:40 <coppro> Vorpal: happy?
16:53:41 <EgoBot> Score for coppro_silly: 8.2
16:53:45 <coppro> ^
16:53:50 <coppro> made no difference, as expected
16:53:54 <Vorpal> coppro, indeed
16:54:01 <Vorpal> thought it would
16:54:02 <Vorpal> meh
16:54:04 <elliott> Vorpal: I figured out how to do fingerprints nicely
16:54:09 <Vorpal> elliott, mhm
16:54:11 <coppro> !bfjoust silly ([[]------>+<])*100
16:54:14 <Vorpal> elliott, tell
16:54:24 <ais523> I didn't, by the time it's passed the first ] it's generally already lost
16:54:26 <EgoBot> Score for coppro_silly: 8.2
16:54:31 <coppro> huh, interesting
16:54:41 <elliott> Vorpal: http://hpaste.org/43784/fingerprints_4
16:54:44 <coppro> anyway, time to clean up
16:54:53 <elliott> ais523 may also be interested, just for insane Haskell existential typing
16:55:02 <elliott> and type families
16:55:09 <elliott> Vorpal: the example FPsare lower down
16:55:11 <elliott> *FPs are
16:55:42 <Vorpal> elliott, a lot of fingerprints have per-thread state instead
16:56:11 <elliott> Vorpal: that's what FPIPState is for
16:56:19 <elliott> this is a proof of concept so it's commented out
16:56:38 <Vorpal> elliott, do MODU too, so you can test the multiple-fingerprint stuff
16:56:50 <elliott> Vorpal: this doesn't actually work in shiro yet, it's just how to do it from the haskell-side
16:57:19 <ais523> elliott: is "io" in Shiro a function that makes an IO action into a Shiro action?
16:57:20 <elliott> and it only requires five type-system extensions!
16:57:35 <elliott> ais523: er, yes; been reading the interpreter code I pasted?
16:57:38 <elliott> ais523: It's just an alias for liftIO
16:57:47 <ais523> yes, I have
16:57:49 <ais523> :t liftIO
16:57:50 <lambdabot> Ambiguous occurrence `liftIO'
16:57:50 <lambdabot> It could refer to either `Control.Monad.Error.liftIO', imported from Control.Monad.Error
16:57:50 <lambdabot> or `Control.Monad.Logic.liftIO', imported from Control.Monad.Logic
16:57:59 <ais523> :t Control.Monad.Logic.liftIO
16:58:00 <elliott> ais523: liftIO basically amounts to lift . lift . lift for some number of .s
16:58:00 <lambdabot> forall a (m :: * -> *). (Control.Monad.Logic.MonadIO m) => IO a -> m a
16:58:05 <elliott> it's for easy access to the IO monad way under you
16:58:11 <elliott> except in Shiro it's right under you, but whatever
16:58:29 <ais523> and what happens if there isn't one? runtime error?
16:58:36 <elliott> ais523: err, then there's no MonadIO instance
16:58:41 <elliott> so it wouldn't type
16:58:43 <ais523> aha
16:59:10 <ais523> MonadIO is any monad that has IO or involved somewhere? (I take it there isn't an IOT?)
16:59:12 <Vorpal> elliott, do you do mycouser btw?
16:59:14 <ais523> :t IOT
16:59:15 <Vorpal> elliott, for input
16:59:15 <lambdabot> Not in scope: data constructor `IOT'
16:59:18 <ais523> indeed
16:59:22 <elliott> ais523: (1) :t on types doesn't work
16:59:24 <elliott> try :k
16:59:28 <Vorpal> elliott, remember that EOF on stdin is defined to reflect
16:59:29 <ais523> :k IOT
16:59:30 <lambdabot> Not in scope: type constructor or class `IOT'
16:59:30 <Vorpal> not to exit
16:59:33 <elliott> ais523: (2) indeed there isn't, IOT would allow for TwoDucks
16:59:39 <elliott> Vorpal: indeed, I pass mycouser
16:59:50 <ais523> elliott: I forgot that types didn't necessarily have the same name as their constructors
16:59:54 <Vorpal> elliott, even for non-trivial cases such as invalid integer input?
16:59:56 <elliott> doIns i =
16:59:56 <elliott> (doCharIns . chr . fromIntegral $ i)
16:59:56 <elliott> `catchShiro` \(e::IOException) -> do io $ hPutStrLn stderr ("Note: Reflecting on IO exception " ++ show e) -- TODO: remove this
16:59:56 <elliott> reflect
16:59:59 <elliott> so I do handle IO errors
17:00:00 <Vorpal> elliott, like foo instead of an integer?
17:00:00 <elliott> Vorpal: yep
17:00:01 <elliott> Vorpal: I reflect
17:00:10 <Vorpal> elliott, and for ctrl-d too? Good
17:00:20 <elliott> Vorpal: there's one maybe-bug: if you read a character, and you input newline, you have to press newline again to get it accepted
17:00:21 <elliott> not sure why
17:00:24 <elliott> not the highest-priority bug ever
17:00:32 <Vorpal> elliott, yeah it's a bug
17:00:44 <Vorpal> elliott, what do you do on overflow?
17:00:46 <elliott> & does read a whole line, right?
17:00:51 <elliott> Vorpal: erm, good question
17:00:54 <elliott> > show (2^64)
17:00:54 <lambdabot> "18446744073709551616"
17:00:57 <ais523> I thought it was just one char
17:00:58 <Vorpal> elliott, it does if 1y says it is line buffered!
17:01:02 <elliott> I'll try that
17:01:05 <elliott> ais523: it reads a number, so no
17:01:13 <elliott> Vorpal: no, but I mean
17:01:13 <ais523> oh, muddled number and char input
17:01:15 <elliott> if you type
17:01:17 <elliott> 234abc\n
17:01:20 <elliott> it chops out the abc\n
17:01:21 <elliott> right?
17:01:28 <elliott> pretty sure it does
17:01:28 <Vorpal> elliott, it leaves abc\n in the buffer yes
17:01:29 <elliott> otherwise
17:01:31 <elliott> Vorpal: erm
17:01:32 <elliott> no
17:01:35 <elliott> mine just discards it
17:01:35 <Vorpal> elliott, yes it does
17:01:39 <elliott> Vorpal: no, because otherwise,
17:01:39 <Vorpal> elliott, then it is wrong
17:01:43 <elliott> Vorpal: the \n at the end of your line
17:01:49 <elliott> would be given to mycouser's character read
17:01:51 <Vorpal> elliott, \n after integer is special
17:01:55 <elliott> >_<
17:01:58 <elliott> says who
17:01:58 <Vorpal> elliott, ask Deewiant
17:02:00 <elliott> I did
17:02:02 <ais523> Vorpal: does the spec say that?
17:02:04 <elliott> He said my behaviour was probably fine
17:02:05 <elliott> ais523: no
17:02:17 <Vorpal> elliott, well if you check what he implements himself
17:02:20 <elliott> Anyway, I pass all of Mycology including =, i, and o apart from one thing
17:02:24 <Deewiant> elliott: http://iki.fi/deewiant/befunge/mycology-output/input/expected.txt
17:02:25 <Vorpal> ais523, no it doesn't
17:02:26 <elliott> Specifically o can't do text output yet
17:02:44 <elliott> Deewiant: Ah, okay.
17:03:00 <Vorpal> elliott, "Decimal input reads and discards characters until it encounters decimal digit characters, at which point it reads a decimal number from those digits, up until (but not including) the point at which input characters stop being digits, or the point where the next digit would cause a cell overflow, whichever comes first. "
17:03:06 <Vorpal> elliott, please read that carefully
17:03:08 <elliott> Anyway, plans for today: Clean up the code a bit, get Concurrent Funge working, add text output to o.
17:03:13 <elliott> Maybe start integrating the fingerprint system.
17:03:15 -!- iamcal has quit (Ping timeout: 276 seconds).
17:03:16 <Vorpal> elliott, it describes that it *should* leave data. And also how it handles overflow
17:03:21 <elliott> Vorpal: So the \n doesn't get handled specially.
17:03:29 <Vorpal> elliott, so \n should be left I guess yeah
17:03:40 <elliott> So if you enter 17<RET> into mycouser, you never get asked for a character.
17:03:43 <elliott> Discuss.
17:03:47 <Deewiant> Correct.
17:03:53 <elliott> And since terminals are line-buffered usually, there is no real way to do mycouser as a user.
17:03:57 <elliott> Discuss: irony.
17:04:11 <elliott> Well.
17:04:14 <ais523> <Anonymous Coward> Do you have to struggle to resist the urge to plug in more than one vacuum from the same outlet? I'm trying to picture the situation where I'd be tempted to do that, and all I can come up with is defense against a horde of oncoming zombie cats.
17:04:14 <elliott> You could type 123x<RET>.
17:04:29 <Vorpal> Deewiant, hm. but there is nothing in the specs that forbids eating \n in that specific case. I'm pretty sure ccbi (used to?) do it
17:04:29 <ais523> elliott: control-D not at the start of a line flushes the buffer
17:04:36 <Deewiant> Yes, it used to
17:04:45 <elliott> Vorpal: Nothing in the spec forbids you from shaking the terminal window every 5 seconds.
17:04:55 <elliott> Or, when the user enters "x", giving "y".
17:04:57 <Vorpal> elliott, indeed. DO IT!
17:04:59 <elliott> But it's obviously not compliant behaviour.
17:05:04 <Vorpal> Deewiant, besides not doing it breaks a lot of programs.
17:05:09 <elliott> ais523: True :P
17:05:10 <ais523> well, t obviously isn't a forkbomb
17:05:18 <elliott> Vorpal: Breaks a lot of broken programs.
17:05:26 <Vorpal> elliott, like every program then
17:05:32 <Deewiant> There's no such thing as "a lot of programs" when speaking of Befunge-98
17:05:56 <elliott> Incidentally, Shiro:
17:05:58 <elliott> Please input a character: æ
17:05:58 <elliott> UNDEF: got 195 'Ã' which is hopefully correct.
17:05:59 <elliott> :D
17:06:00 <elliott> UNICODE READY
17:06:11 <elliott> (All input and output is treated as Latin-1.)
17:06:20 <elliott> (That's what Haskell calls "binary mode" because you can input and output anything like that.)
17:06:38 <Vorpal> efunge does proper unicode. It expects UTF-8 iirc and converts it to unicode code point internally.
17:06:40 <elliott> Deewiant: What happens on "o" with a cell in the area greater than 255?
17:07:21 <Deewiant> Should match how you do I/O in general
17:07:28 <Deewiant> IMO, just %256 it
17:07:51 <ais523> use an encoding that lets you output it as-is
17:07:55 <ais523> bignum UTF-8 or whatever
17:08:10 <Vorpal> Deewiant, hm. what if there is no "I/O in general". As in you do byte IO for files and utf-8<->unicode conversion for stdio? :D
17:08:28 <Deewiant> IMO, don't do that :-P
17:08:42 <elliott> Deewiant: 99fff**p009900"oof"o
17:08:48 <Vorpal> Deewiant, well I'm not sure the latter is valid for the initial program loading
17:08:49 <elliott> Deewiant: Anything wrong with that test program?
17:08:52 <ais523> what if you take a bitfield on the command line that specifies what to use Unicode for? </perl>
17:09:03 <Deewiant> elliott: Just compare to ccbi :-P
17:09:07 <Vorpal> ais523, it does that?
17:09:21 <ais523> Vorpal: can do, there's an option that does that
17:09:21 <elliott> I think ais523 is insufficiently amazed at my fingerprints stuff, maybe because he has no soul. Or just can't understand how much I'm abusing the type system.
17:09:24 <elliott> Deewiant: I need a test program to do that.
17:09:29 <ais523> elliott: or didn't read it
17:09:30 <elliott> Deewiant: I'm not so good at Befunge. Is that program any good?
17:09:40 <elliott> ais523: I ruled out that option because it's LAME
17:10:11 <Deewiant> elliott: Like said, just run it through ccbi and see if it does something you want it to do
17:10:50 <Vorpal> Deewiant, anyway you should update mycouser to show the prompts so that the element of irony is no longer there
17:10:59 <elliott> Deewiant: Seems to create an empty file :-P
17:11:04 <ais523> hmm, does anyone here know how to write Firefox extensions?
17:11:29 <elliott> Yay, I have a file "foo??" I can't remove.
17:11:38 <Deewiant> rm foo*
17:12:05 <Deewiant> elliott: You probably wanted fff**99p?
17:12:16 <elliott> Deewiant: Seems to output the invalid character as a space.
17:12:21 <elliott> Deewiant: Oh.
17:12:22 <Deewiant> And you don't have a flags cell
17:12:25 <elliott> thx :P
17:12:26 <elliott> Deewiant: I do now.
17:12:37 <elliott> fff**88p990000"oof"o@
17:12:51 <elliott> Deewiant: Outputs as /, so I guess it's mod 256 for CCBI and I'll test it with shiro.
17:13:31 <elliott> Deewiant: Sweet, Shiro does the same :P
17:13:35 <Vorpal> elliott, do you do input truncation correctly for overflow
17:13:36 <elliott> Probably because of Word8 overflow.
17:13:42 <elliott> Vorpal: Uh. What?
17:14:11 <Vorpal> elliott, for &: "[...] at which point it reads a decimal number from those digits, up until (but not including) the point at which input characters stop being digits, or the point where the next digit would cause a cell overflow, whichever comes first."
17:14:20 <pikhq> elliott: I must say, it's genuinely impressive how freaking quickly you got a Befunge-98 interpreter running.
17:14:25 <pikhq> elliott: Just, dang.
17:14:39 <Vorpal> elliott, saturation or wrapping are not valid thus.
17:14:47 <elliott> pikhq: It was mostly me implementing the insane, insane things Deewiant told me.
17:14:54 <pikhq> elliott: Heheheh.
17:14:57 <Vorpal> elliott, so, do you do that correctly?
17:15:02 <elliott> Vorpal: No. No I don't.
17:15:07 <elliott> TODO: Fix.
17:15:07 <Vorpal> elliott, bug! :P
17:15:10 <Vorpal> yeah
17:15:19 <elliott> Does _anyone_ actually use &?
17:15:23 <Deewiant> And yes, I know Mycology doesn't test that.
17:15:25 <Vorpal> Deewiant, does ccbi do it correctly? iirc you don't test it in your mycology rankings
17:15:31 <elliott> Deewiant: Does if you give it enough digits.
17:15:44 <elliott> Vorpal: Uh, yes he does?
17:15:49 <Deewiant> Yes, but my rankings should probably test it
17:15:51 <Vorpal> elliott, not this behaviour of &
17:16:13 <Vorpal> elliott, in the rankings if that is what you meant
17:16:16 <elliott> Oh, I thought you meant CCBI.
17:16:18 <elliott> :t unGetChar
17:16:19 <lambdabot> Not in scope: `unGetChar'
17:16:20 <elliott> Please exist.
17:16:22 <elliott> Fuck.
17:16:23 <elliott> @hoogle ungetc
17:16:24 <lambdabot> Control.Concurrent.Chan unGetChan :: Chan a -> a -> IO ()
17:16:27 <elliott> @hoogle getc
17:16:28 <lambdabot> Network.CGI.Protocol getCGIVars :: MonadIO m => m [(String, String)]
17:16:28 <lambdabot> Control.Concurrent.Chan getChanContents :: Chan a -> IO [a]
17:16:28 <lambdabot> Prelude getChar :: IO Char
17:17:00 <Deewiant> elliott: CCBI implements unget manually too, FWIW
17:17:02 <Vorpal> elliott, I solve it by keeping a line buffer in the program anyway. Even though C has ungetc
17:17:14 <Deewiant> Why don't you use ungetc?
17:17:15 <Vorpal> since it is more practical for various fingerprints
17:17:16 <elliott> Deewiant: I really don't want to keep track of even more state :P
17:17:20 <elliott> But I might.
17:17:27 <elliott> It'll be nicer once I have the accessors going nicely.
17:17:31 <elliott> Probably going to use data-accessors.
17:18:04 <elliott> *Main> testShow
17:18:04 <Vorpal> Deewiant, it is more practical for stuff like STRN's I. And it means my algorithm can just work on an array of chars rather than having to getc in various places. So less confusing code my way too.
17:18:04 <elliott> NULL -- ()
17:18:04 <elliott> ROMA -- ()
17:18:04 <elliott> SLLY -- True
17:18:10 <elliott> I love how I can print all the fingerprints' state out dynamically.
17:18:15 <elliott> That's going in the debugger. :p
17:18:16 <Deewiant> Fair enough
17:19:36 <elliott> I should pirate Mathematica sometime, W|A is really irritating.
17:19:51 <Vorpal> elliott, I thought you done that in the past?
17:19:56 <pikhq> elliott: Yeah, and Maxima is not the easiest thing to use.
17:19:59 <elliott> Yeah, but not on here.
17:20:40 <elliott> Wait a second. That wrapping loops seems hideously inefficient. I'm sure you could make it O(1) by ... oh, that's probably what CCBI does. Deewiant? :P
17:20:44 <Vorpal> pikhq, it is not that much harder given that wxwidgets frontend
17:21:08 <Vorpal> elliott, get everything working first. Then worry about efficiency.
17:21:18 <Deewiant> elliott: It's not O(1) in CCBI.
17:21:21 <Vorpal> elliott, premature optimisation and so on
17:21:30 <elliott> Vorpal: It just irks me to have a loop for something that I'm pretty sure doesn't need to loop.
17:21:45 <Deewiant> I can't remember what it is but there's a pathological case where the delta is 2^cellsize - 1, or something.
17:21:58 <elliott> Vorpal: But, uh, I plan to do that population count thing sometime soon.
17:22:22 <elliott> Deewiant: Hell, my interpreter will crash and burn if your Haskell's Ints are less than 32 bit (they only have to store up to 2^29 inclusive).
17:22:25 <elliott> > maxBound :: Int
17:22:26 <lambdabot> 9223372036854775807
17:22:27 <elliott> > maxBound :: Int64
17:22:28 <lambdabot> 9223372036854775807
17:22:31 <Vorpal> Deewiant, shouldn't you be able to solve it as a linear equation system hm. Wait two different ones. Depending on which edge it might hit
17:22:45 <Vorpal> and hm you need to follow the line backwards to detect ... right
17:22:48 <Deewiant> My situation is more complicated than just moving into one bounding box :-P
17:23:01 <Deewiant> I need to find the first of N bounding boxes that gets hit
17:23:09 <Vorpal> Deewiant, you still need to get integer coords on that line after solving the equation system
17:23:22 <Vorpal> which does complicate stuff
17:23:43 <oerjan> @hoogle unget
17:23:43 <lambdabot> Control.Concurrent.Chan unGetChan :: Chan a -> a -> IO ()
17:23:44 <lambdabot> Control.Concurrent.STM.TChan unGetTChan :: TChan a -> a -> STM ()
17:23:55 <oerjan> @hoogle unget :: Handle -> IO ()
17:23:56 <lambdabot> Control.Concurrent.Chan unGetChan :: Chan a -> a -> IO ()
17:24:14 <Zuu> i smell haskell
17:24:16 <oerjan> i'm pretty sure it _does_ exist
17:24:41 <Vorpal> oerjan, you could easily implement it in terms of IOT right? :P
17:24:41 <Deewiant> I'm pretty sure it doesn't
17:24:50 <oerjan> MAYBE
17:25:14 <elliott> Deewiant: YOU haven't even gawped over my abuse of the type system
17:25:14 <elliott> wait
17:25:15 <elliott> oerjan
17:25:16 <elliott> the perfect prey
17:25:41 <elliott> oerjan: http://hpaste.org/43785/fingerprints_5
17:25:46 <elliott> oerjan: {-# LANGUAGE TypeFamilies, ExistentialQuantification, FlexibleContexts, DeriveDataTypeable, StandaloneDeriving #-}
17:26:08 <Vorpal> elliott, the easy way to do it is like an ordered set of stacks of lambdas
17:26:23 <elliott> Vorpal: Yes, that's still how it'll work in my system.
17:26:31 <oerjan> elliott: i looked at your existentialism previously, pretty neat
17:26:33 <elliott> Vorpal: Wait, ordered set of stacks? Not just a stack?
17:26:34 <Vorpal> elliott, so why do you need all that abuse
17:26:41 <elliott> oerjan: More like pretty horrifying.
17:26:43 <Deewiant> elliott: One stack per instruction
17:26:43 <Vorpal> elliott, you need a stack per instruction
17:26:46 <elliott> Right.
17:26:49 <elliott> Vorpal: This is just how it works from the Haskell end.
17:26:58 <elliott> Vorpal: It allows me to define new fingerprints with minimal fuss.
17:27:02 <elliott> Very minimal fuss.
17:27:17 <Vorpal> elliott, couldn't you just do what I said from the haskell side easily?
17:27:19 <elliott> Vorpal: And it allows any random person to add a fingerprint with its own per-IP and global state without having to change the Shiro internal state record.
17:27:28 <elliott> Vorpal: Yes, if I was willing to hardcore every fingerprint into the core.
17:27:35 <elliott> Which I'm not, that's just retarded.
17:27:38 <Vorpal> elliott, uh why would you need that :P
17:27:44 <elliott> Vorpal: Or if I was willing to completely sacrifice any sort of safety, I guess.
17:27:52 <elliott> But this is by far the nicest way.
17:28:31 <Vorpal> elliott, how so? wouldn't the type of the *lambda* be: f ip -> stack -> (ip, stack) or such?
17:28:36 <elliott> *sigh*
17:28:40 <Vorpal> unless your stack is in your ip
17:28:49 <Vorpal> in which case it is trivial
17:28:50 <oerjan> @hoogle hunget
17:28:50 <lambdabot> No results found
17:28:53 <elliott> Firstly, I have a monad.
17:28:58 <elliott> Secondly, just no.
17:29:00 <Vorpal> elliott, oh right
17:29:29 <Vorpal> elliott, well okay, my solution is 1) pure 2) only allows a handful of feral fingerprints
17:29:38 <Vorpal> actually I forgot fungespace there
17:29:52 <Vorpal> f ip -> fungespace -> (ip,fungespace) would be better
17:30:02 <elliott> Vorpal: IMPLEMENTING A FINGERPRINT WITHOUT THIS SYSTEM: Edit the state definition, manually add in your new piece of state. Edit the IP record, manually add in your own piece of state. Write a bunch of implementations using and modifying that state directly (semi-awkward). Manually edit the place where fingerprints are looked up. Blah blah blah.
17:30:19 <Gregor> "We start with specially-selected farm-grown potatoes" Is the definition of "farm" so restrictive that this gains anything by adding it? I mean, huge corporate metafarms are still farms...
17:30:25 <elliott> Create a module. Add an identifier type. Write a Fingerprint instance.
17:30:32 <elliott> Edit Fingerprints.hs, add yours to the list of available fingerprints.
17:30:34 <elliott> Recompile.
17:30:49 <elliott> Vorpal: Also, monads are just as pure as that, you dolt.
17:30:54 <elliott> What do you think the State monad is?
17:31:01 <pikhq> Gregor: I'm pretty sure that anywhere that produce is intentionally grown for consumption can count as a "farm".
17:31:04 <elliott> It's exactly "state -> (result, state)".
17:31:09 <elliott> The reason we use the state monad is that using that is a bitch.
17:31:15 <elliott> But that's exactly how it's implemented.
17:31:19 <Gregor> pikhq: Right, hence why "farm-grown" is totally meaningless here.
17:31:24 <Vorpal> elliott, actually this can be trivially solved if the ip has some fingerintdata member that implements a key,value storage. Anyway who would need to store more than a single type! ;P
17:31:33 <Gregor> pikhq: I guess "grown" isn't meaningless, it means they didn't replicate the potatoes :P
17:31:37 <elliott> Vorpal: Yes, but then the state would not be type-safe.
17:31:39 <elliott> Or typed at all.
17:31:44 <Vorpal> elliott, true :P
17:31:47 <pikhq> Gregor: Wrong.
17:31:47 <elliott> Which is "retarded", technical term.
17:31:54 <pikhq> Gregor: You generally clone potatoes.
17:32:16 <Gregor> *brain axplote*
17:32:18 <pikhq> (cut the eyes from a potato and plant it? Congrats, you're CLONING!)
17:32:20 <elliott> oerjan: http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html I don't see any ungetc.
17:32:30 <pikhq> It's really fucking easy to clone plants. :)
17:32:38 <Vorpal> elliott, indeed. Unless you made that type auto generated from a handful of fingerprint definition files so it ends up as a list of "tagged types" in effect. Though that would be ugly.
17:32:52 <elliott> Vorpal: That would be what I do now, except requiring a preprocessor and being hideous.
17:32:56 <oerjan> elliott: i couldn't find it either
17:32:57 <elliott> Well, "do now" = in that proof of concept.
17:33:16 <oerjan> wth do i feel i _have_ seen such a thing
17:33:22 <elliott> oerjan: Hugs-specific maybe?
17:33:35 <Vorpal> elliott, anyway you still need to tell ( and ) about the list of possible fingerprints somewhere. Unless you do some sort of crazy reflection or similar.
17:33:44 <Vorpal> (can haskell even do that?)
17:33:49 <elliott> Vorpal: Yes, yes it can, and that's what I'm doing.
17:33:50 <elliott> Vorpal: Well.
17:33:55 <Vorpal> elliott, haha XD
17:33:57 <elliott> Vorpal: There is exactly one list of available fingerprints.
17:34:07 <elliott> Vorpal: I *could* use Template Haskell to generate it from the list of files in Shiro/Fingerprints/ at compile time.
17:34:09 <Vorpal> elliott, yep.
17:34:10 <elliott> Vorpal: But that sounds Super Ugly.
17:34:15 <elliott> I'd prefer to maintain a manual list.
17:34:17 <elliott> More robust.
17:34:22 <Vorpal> elliott, for C it is the best solution (auto generating the list)
17:34:29 <Vorpal> which is why cfunge has a shell script to do that
17:34:32 <elliott> Yeah, because in C it'd be complicated :P
17:34:38 <elliott> With this, it's basically...
17:34:41 <elliott> <insert new line>
17:34:44 <elliott> , FP MKRY
17:34:49 <elliott> <C-x C-s>
17:34:58 <elliott> Oh, I forgot; at the top of the file:
17:34:59 <Vorpal> elliott, yeah reflection in C is... likely impossible unless you use -g and basically implement 1/3rd of a debugger
17:35:04 <elliott> import Shiro.Fingerprints.MKRY (MKRY)
17:35:29 <Vorpal> elliott, wait you still need to edit some list file?
17:35:36 <elliott> Vorpal: Yes. As I said,
17:35:42 <elliott> <elliott> Vorpal: I *could* use Template Haskell to generate it from the list of files in Shiro/Fingerprints/ at compile time.<elliott> Vorpal: But that sounds Super Ugly.
17:35:43 <elliott> <elliott> I'd prefer to maintain a manual list.
17:35:49 <elliott> Vorpal: I'd *prefer* to; I don't *have* to.
17:36:05 <Vorpal> elliott, for cfunge it is completely automagic. Run a shell script. Force Makefile to be re-generated. Build. Run.
17:36:10 <elliott> Vorpal: For instance, if I make a module called Shiro.Fingerprints.Helpers, like helper functions for fingerprints or something, having that be treat as a fingerprint automatically would be irritating.
17:36:20 <elliott> Also, I don't really care. It's manual because I want it to be.
17:36:23 <Vorpal> elliott, yeah true
17:36:40 <elliott> If Haskell had better dynamic loading capabilities, I'd let you load a fingerprint from an .so :P
17:36:43 -!- cal153 has joined.
17:36:48 <elliott> But I don't think you can make that work with types and the like.
17:36:57 <Vorpal> elliott, I think ccbi does some crazy completely runtime thingy for it
17:37:04 <Vorpal> I forgot what it did
17:37:05 <elliott> It would basically be like using a C FFI, I think.
17:37:10 <Vorpal> elliott, some D-magic iirc
17:37:10 <elliott> Except calling Haskell functions. With C types.
17:37:16 <oerjan> elliott: hm, there _is_ hLookAhead though
17:37:21 <elliott> oerjan: aha
17:37:23 <elliott> :t hLookAhead
17:37:24 <lambdabot> Not in scope: `hLookAhead'
17:37:37 <elliott> :t System.IO.hLookAhead
17:37:38 <lambdabot> GHC.IO.Handle.Types.Handle -> IO Char
17:37:42 <Vorpal> <elliott> Except calling Haskell functions. With C types. <-- DO IT!
17:37:43 <elliott> excellent
17:37:46 <elliott> hmm
17:38:00 <Vorpal> elliott, also: I'm sure someone written some sort of plugin system for haskell by now
17:38:05 <Vorpal> checked hackage?
17:38:14 <elliott> *** Exception: <stdout>: hLookAhead: illegal operation (handle is not open for reading)
17:38:15 <elliott> mrf
17:38:22 <elliott> Vorpal: well probably, it's just that I couldn't do it the way I want.
17:38:24 <elliott> which is important :)
17:38:34 <Vorpal> elliott, right
17:38:52 <elliott> OK, first thing's first: I'm going to implement Num Vector.
17:38:56 <pikhq> Calling Haskell functions with C types is entirely possible. :P
17:39:02 <elliott> Because I've had enough of pattern-matching two tuples and adding their components manually.
17:39:03 <Vorpal> elliott, Num Vector?
17:39:06 <Vorpal> ah
17:39:09 <elliott> Vorpal: So I can do vector + vector and the like.
17:39:48 <Vorpal> elliott, most of the time you only need to add two specific vectors I find: storage offset and whatever it is that you need to be relative it
17:40:05 <pikhq> Gah... Screw Num so much.
17:40:07 <elliott> Hmm...
17:40:12 <elliott> What's fromInteger :: Integer -> (Value,Value)
17:40:13 <elliott> :-P
17:40:22 <Vorpal> elliott, a type?
17:40:25 <Deewiant> join (,)
17:40:29 <elliott> I mean, how can I implement that sanely.
17:40:31 <elliott> Deewiant: Yeah, probably.
17:40:32 <Vorpal> ah
17:40:32 <elliott> Ugly, but whatever.
17:40:47 <elliott> Deewiant: Also, you forgot fromInteger on the elements.
17:40:47 <Vorpal> :t join
17:40:47 <Deewiant> error "wtf"
17:40:48 <lambdabot> forall (m :: * -> *) a. (Monad m) => m (m a) -> m a
17:40:50 <elliott> fromInteger a = (fromInteger a, fromInteger a)
17:40:56 <Deewiant> elliott: No, you forgot to make Value an Integer
17:41:02 <elliott> Does |(x,y)| even make sense.
17:41:03 <elliott> Deewiant: Hur hur
17:41:20 <elliott> Shiro/Value.hs:8:9:
17:41:20 <elliott> Warning: No explicit method nor default method for `signum'
17:41:25 <elliott> YOU'RE STUPID
17:41:35 <Vorpal> :t signum
17:41:36 <lambdabot> forall a. (Num a) => a -> a
17:41:38 <elliott> Oh wait.
17:41:41 <elliott> Just do signum on each component X-P
17:41:50 <Vorpal> elliott, and if they differ?
17:41:51 <elliott> Then it also becomes a make-flying-into-cardinal function.
17:41:59 <elliott> Vorpal: It's Vector -> Vector.
17:42:09 <Vorpal> elliott, why does it need signum though?
17:42:20 <Vorpal> elliott, oh because of Num?
17:42:25 <Deewiant> (1,1) ain't cardinal
17:42:27 <elliott> Because when the designers of Haskell decided to make the numeric typeclass, they decided to be really stupid about us.
17:42:31 <elliott> Because they hate us.
17:42:35 <Vorpal> and yeah what Deewiant said
17:42:35 <elliott> Deewiant: Err, right. It's a "slow down" function then. :p
17:42:58 -!- asiekierka has quit (Ping timeout: 260 seconds).
17:43:11 <Vorpal> elliott, "slow down and align to cardinal or straight diagonals" even
17:44:01 <Vorpal> elliott, signum seems sensible to have for Num
17:44:11 <Vorpal> but Num Vector doesn't seem as sensible to me
17:44:36 <elliott> Vorpal: (a,b) + (c,d) is perfectly well-defined.
17:44:43 <Vorpal> elliott, yes indeed
17:44:51 <elliott> Num is just stupid :P
17:45:01 <Vorpal> elliott, but abs Vector -> Vector is nonsense
17:45:08 <elliott> abs (a,b) = (abs a, abs b)
17:45:14 <Vorpal> elliott, abs Vector -> Cardinal is a lot more sensible
17:45:14 <elliott> Close enough.
17:45:24 <Phantom_Hoover> What's wrong with Num?
17:45:28 <Phantom_Hoover> :i Num
17:45:30 <Vorpal> err Saclar
17:45:33 <Vorpal> Scalar*
17:45:38 <Vorpal> how did I typo that as Cardinal XD
17:45:54 <Vorpal> elliott, abs on a vector is mathematically a scalar unless I completely misremember stuff
17:46:42 <Phantom_Hoover> elliott, I DEMAND YOU TELL ME WHAT IS WRONG WITH Num
17:47:25 <Vorpal> elliott, also what the heck do you define Vector * Vector as. Cross product makes no sense in two dimensions
17:47:27 <Deewiant> CCBI's fingerprint system is all compile time except for the way you can freely enable and disable them at runtime
17:47:37 <elliott> Vorpal: (a,b) * (c,d) = (a*c, b*d). Problem? :trollface:
17:47:46 <Vorpal> elliott, YES!
17:47:56 <Vorpal> elliott, this is mathematical nosense!
17:48:23 <elliott> Patches welcome.
17:48:24 <Vorpal> elliott, and while that may be okay in C it feels so out of place in haskell
17:48:37 <Phantom_Hoover> elliott, presumably (a,b)+(c,d) = (bd(a+c),bd).
17:48:41 <Deewiant> ((a,b,1) * (c,d,1))[0,1] = (b-d, c-a)
17:48:44 <elliott> Phantom_Hoover: No, (a+c,b+d).
17:48:50 <Phantom_Hoover> -_-
17:48:51 <Vorpal> elliott, why do you need Num. Can't you just do the operators anyway. Or make your own saner typeclass?
17:49:02 <elliott> Vorpal: I wouldn't be able to call it (+) then.
17:49:11 <elliott> (+) is defined over Num:
17:49:13 <elliott> :t (+)
17:49:14 <lambdabot> forall a. (Num a) => a -> a -> a
17:49:23 <Vorpal> <Phantom_Hoover> elliott, presumably (a,b)+(c,d) = (bd(a+c),bd). <-- what...
17:49:30 <Deewiant> And of course there are no other operator characters available
17:49:34 <Vorpal> that isn't how you do vector addition
17:49:38 <elliott> Deewiant: Well, none as pretty as +.
17:49:40 <elliott> instance (Num a, Num b) => Num (a,b) where
17:49:40 <Phantom_Hoover> Vorpal, by analogy.
17:49:40 <elliott> (a,b) + (c,d) = (a+c, b+d)
17:49:40 <elliott> (a,b) - (c,d) = (a-c, b-d)
17:49:42 <Vorpal> elliott, ah
17:49:42 <elliott> -- These don't really make any sense
17:49:44 <elliott> (a,b) * (c,d) = (a*c, b*d)
17:49:46 <elliott> abs (a,b) = (abs a, abs b)
17:49:48 <elliott> signum (a,b) = (signum a, signum b)
17:49:50 <elliott> fromInteger a = (fromInteger a, fromInteger a)
17:49:51 <Phantom_Hoover> With fractions.
17:49:53 <elliott> I could define ^+^ or whatever, but ew.
17:49:55 <elliott> :t (^+^)
17:49:56 <Deewiant> Gah, use combinators
17:49:56 <lambdabot> forall v. (AdditiveGroup v) => v -> v -> v
17:49:59 <Vorpal> Phantom_Hoover, hah
17:50:01 <Deewiant> abs = both abs
17:50:03 <Deewiant> signum = both signum
17:50:08 <Deewiant> fromInteger = join (,) . fromInteger
17:50:09 <elliott> Deewiant: Haha, I feel how it hurts you.
17:50:24 <elliott> I don't really want to pull in Data.Arrow for the "satisfy the compiler" functions, dude.
17:50:34 <elliott> *Control.Arrow
17:50:36 <Deewiant> Control.Arrow is in base.
17:50:44 <elliott> And?
17:50:46 <Deewiant> It's not much of a dependency :-P
17:50:53 <elliott> I didn't say that
17:51:01 <Deewiant> There's nothing you're "pulling in" as such
17:51:11 <elliott> I'm pulling in the Arrow typeclass
17:51:19 <Deewiant> ... ohnoes?
17:52:01 <elliott> Ohnoes.
17:52:12 <Deewiant> Also those definitions aren't lazy enough
17:52:15 <Vorpal> haskell (or at least ghc) really does tuples quite messily
17:52:20 <Deewiant> abs ~(a,b) = (abs a, abs b)
17:52:21 <Vorpal> just check :i Ord
17:52:46 <Vorpal> Deewiant, uh what?
17:52:58 <Deewiant> What what
17:53:04 <oerjan> :t both
17:53:05 <lambdabot> Not in scope: `both'
17:53:11 <Deewiant> both = join (***)
17:53:25 <Deewiant> (Not available anywhere AFAIK but I almost always end up defining it in my code)
17:53:28 <Vorpal> Deewiant, what does that ~ do now again
17:53:38 <oerjan> Deewiant: i just wondered if they'd added it or something
17:53:49 <Deewiant> The ~ makes the pattern lazy
17:54:48 <oerjan> Phantom_Hoover: the basic thing wrong with Num is that hit cobbles together many functions that it sometimes makes mathematical sense to define only _some_ of for a type. + for vectors being an obvious example.
17:54:53 <oerjan> *it
17:55:15 <Vorpal> Deewiant, hm how does it do that
17:55:31 <elliott> Lazily
17:55:41 <oerjan> abs and signum being others that frequently aren't needed
17:55:42 <Deewiant> The pattern always matches and it's a runtime error if it doesn't actually match when the value is actually used
17:55:43 -!- asiekierka has joined.
17:55:53 <Vorpal> Deewiant, aha
17:56:17 <elliott> oerjan: also it forbids the naturals...
17:56:36 <oerjan> and abs should be defined in the type family sense too, because often you want the absolute value to belong to a different type
17:57:14 <oerjan> *associate type sense
17:57:17 <oerjan> *d
17:57:45 <oerjan> elliott: yeah that too...
17:58:25 <Vorpal> elliott, how so? abs is identity for naturals. signum has a co-domain {0,1} for them.
17:58:29 <Vorpal> oh wait, it has negate
17:58:30 <Vorpal> right
17:58:37 <elliott> Vorpal: indeed.
17:58:52 <Vorpal> elliott, well like 5-9 is _|_ in the Naturals, wouldn't negate also just be _|_ ?
17:59:11 <elliott> Yes, but that's fugly.
17:59:17 <Vorpal> elliott, well yeah
17:59:35 <Vorpal> elliott, anyway what is fromIneger :: Integer -> Vector for you?
17:59:42 <elliott> fromInteger a = (fromInteger a, fromInteger a)
17:59:53 -!- sixdej|sleep has joined.
17:59:56 <Vorpal> elliott, it should be the reverse of the INTERCAL mingle operator
18:00:01 <elliott> It makes 0 into origin, so that's good enough for me
18:00:11 <Vorpal> which still works for 0
18:01:13 <ais523> does anyone here know how to view dotfiles on Windows 7?
18:01:21 <ais523> as in, my Linux and Windows homedir are mapped into the same directory
18:01:30 <ais523> and I want to look at a dotfile crated on the Linux system from windows
18:01:43 <elliott> ais523: just open it
18:01:45 <ais523> I assume they map to Windows hidden files, somehow; but am not sure how to turn display of hidden files on
18:01:48 <ais523> elliott: it's not visible
18:01:50 <elliott> nope, it doesn't afaik
18:01:57 <oerjan> ais523: folder options?
18:01:57 <elliott> ais523: open it in notepad, or go into folder settings of some kind
18:01:58 <Vorpal> ais523, is this some network thingy?
18:02:01 <elliott> i.e. C:\foo\.blah in notepad
18:02:08 <ais523> Vorpal: yes
18:02:18 <Vorpal> ais523, could do some crazy magic of it's own then
18:02:21 <ais523> oerjan: that's what I'd normally do, but I can't find the menu option, or indeed the menu
18:02:26 <Vorpal> elliott, hm you can't even make vector multiplication do scalar product :(
18:02:26 <oerjan> huh
18:02:28 <ais523> aha, pressing F10 worked
18:02:32 <ais523> the menu was there, just hiding
18:02:50 <oerjan> ais523: it self-applied
18:02:52 <ais523> and there are the dotfiles
18:03:02 * elliott reads http://hackage.haskell.org/packages/archive/data-accessor/
18:03:23 <copumpkin> meh, not a fan
18:03:33 <elliott> copumpkin: Better than what I have now.
18:03:38 <copumpkin> I prefer fclabels
18:03:38 <elliott> Haskell's record system is fucking terrible.
18:03:39 <Vorpal> copumpkin, indeed you are not a fan. You are a copumpkin!
18:03:41 <ais523> I don't know how anyone's meant to know that without having memorised it from a previous version of Windows
18:03:42 <copumpkin> less henning'd
18:03:54 <elliott> "Henning'd".
18:03:55 <elliott> What :-P
18:04:02 <Vorpal> herring*
18:04:19 <copumpkin> C a b => T a -> T b -> T a b -> T (a, b)
18:04:21 <copumpkin> that's henning'd
18:04:35 <elliott> copumpkin: That's nice.
18:04:36 <Deewiant> Everything is called C and T
18:04:37 <copumpkin> (note that the Ts are different)
18:04:39 <oerjan> who is henning
18:04:39 <elliott> I like genericity :P
18:04:49 <Deewiant> Henning is the guy who calls everything C and T
18:04:50 <elliott> oerjan: thielieileieeman
18:04:53 <copumpkin> oerjan: the source of that wonderful convention
18:04:56 <copumpkin> and the only adopter of it
18:04:57 <oerjan> (it's a norwegian name)
18:05:02 <Vorpal> ais523, presumably you could try right clicking toolbars and have some option for it? Or just locate the folder options from the control panel
18:05:13 <Deewiant> Thielemann
18:05:21 <elliott> copumpkin: Yeah well, fclabels is... less... Luke Palmer!
18:05:25 <copumpkin> lol
18:05:27 <oerjan> hm i guess it's also german
18:05:27 <elliott> Also edwardk likes data-accessors.
18:05:30 <copumpkin> fclabels is fairly nice
18:05:31 <elliott> WHAT NOW
18:05:34 <copumpkin> no he doesn't
18:05:37 <elliott> Well.
18:05:40 <elliott> He said he did yesterday.
18:05:44 <copumpkin> he hates henning's naming
18:05:44 <elliott> Because it doesn't pull in mtl :-P
18:05:49 <elliott> <elliott> Because it doesn't pull in mtl :-P
18:05:53 <copumpkin> yeah, whatever
18:06:07 <elliott> I prefer data-accessors' syntax *shrug*
18:06:31 <elliott> copumpkin: I was going to just write my own.
18:06:35 <elliott> But that seems silly.
18:06:47 <copumpkin> neither data-accessor nor fclabels support one thing I want
18:06:51 <elliott> which is
18:06:58 <copumpkin> a native "modify" method
18:07:01 <copumpkin> that doesn't involve setting and getting
18:07:16 -!- zzo38 has joined.
18:07:18 <copumpkin> I don't care about it being atomic, but I want it
18:07:22 <elliott> copumpkin: The way I was doing mine, it was just get and modify. But why do you want it?
18:07:31 <elliott> Surely GHC can optimise that out. :p
18:07:33 <copumpkin> no
18:07:39 <copumpkin> because you can easily make any Map-like thing into a lens
18:07:49 <copumpkin> and it's silly to traverse the whole map twice
18:07:55 <copumpkin> once to find, the other to update it
18:08:01 <Vorpal> copumpkin, lens in what sense?
18:08:02 <copumpkin> that's why maps have specialized update methods
18:08:09 <copumpkin> lens in the data-accessor/fclabel sense :P
18:08:19 <Vorpal> eh *goes to look*
18:08:29 <copumpkin> basically a boxed-up getter/setter
18:08:57 <copumpkin> it's somewhat equivalent to (a -> b -> b, b -> a)
18:09:01 <Vorpal> ah
18:09:07 <copumpkin> or b -> (a -> b, a)
18:09:08 <elliott> copumpkin: type Accessor a t = (a -> t, (a -> a) -> t -> t)
18:09:17 <copumpkin> oh
18:09:20 <copumpkin> that's nice then
18:09:25 <elliott> copumpkin: that's what i would do, I mean
18:09:26 <elliott> copumpkin: PERFECTED: type Accessor a t = (a -> a) -> t -> (a, t)
18:09:47 <elliott> get a = fst . a id
18:10:00 <elliott> put a x = snd . a (const x)
18:10:07 <elliott> modify a f = snd . a f
18:10:09 <elliott> copumpkin: PERFECTED
18:10:15 <elliott> copumpkin: lol, convince me not to implement this
18:10:23 <copumpkin> put another package up on hackage that does that
18:10:25 <copumpkin> I'd use it
18:10:29 <copumpkin> if it isn't dumb
18:10:40 <elliott> first = \f (a,b) -> (a, (f a, b))
18:10:48 <elliott> second = \f (a,b) -> (b, (a, f b))
18:11:31 <elliott> mapElem k = \f m -> (m Map.! k, Map.adjust f k m)
18:11:37 <elliott> copumpkin: haha this is actually a really good idea
18:11:48 <copumpkin> do it
18:11:58 <elliott> copumpkin: I'm not going to do it in a separate package first, it'll just be Shiro.Accessor
18:12:01 <copumpkin> talk to roconnor and edwardk about it
18:12:03 <elliott> I _don't_ want to lose track of this project
18:12:15 <elliott> I'll get it implemented into the Shiro codebase first, and copy it out later :P
18:12:48 <copumpkin> fair enough :)
18:12:49 <elliott> copumpkin: hm should it be
18:12:53 <elliott> (a -> a) -> t -> (a, t)
18:12:53 <elliott> or
18:12:53 <copumpkin> I don't need it too urgently
18:12:55 <elliott> (a -> a) -> t -> (t, a)
18:12:55 <copumpkin> @hackage lenses
18:12:56 <lambdabot> http://hackage.haskell.org/package/lenses
18:12:57 <elliott> I think the former
18:13:13 <ais523> hmm, you remember how a while ago, I emailed a bunch of people via using evolution over ssh -X?
18:13:17 <elliott> ais523: haha
18:13:26 <copumpkin> elliott: I dunno, which do you typically want to fmap?
18:13:31 <ais523> I just did it again, because I forgot to email myself, and that version of the program had the "sent" folder containing the email
18:13:37 <elliott> copumpkin: I dunno; a is the structure, t is the element
18:13:39 <ais523> and I couldn't figure out how it was stored any other way
18:13:53 -!- zzo38 has quit (Quit: .).
18:14:05 <ais523> it's because I wanted to attach a file to the email I didn't have locally
18:14:12 <oerjan> @hackage fnordly
18:14:12 <lambdabot> http://hackage.haskell.org/package/fnordly
18:14:14 <elliott> tos f (x:xs) = (x, f x : xs)
18:14:14 <elliott> tos f [] = (0, [f 0])
18:14:18 <elliott> this is nice
18:15:50 <elliott> wait
18:15:51 <elliott> t is the type
18:15:54 <elliott> a is the accessed field
18:16:02 <elliott> copumpkin:
18:16:03 <elliott> type Accessor t a = (a -> a) -> t -> (a, t)
18:16:05 <elliott> type Accessor t a = (a -> a) -> t -> (t, a)
18:16:07 <elliott> hmm
18:16:17 <copumpkin> paint the shed whatever color you want it
18:16:17 <elliott> latter has a nice symmetry with the ordering of the arguments but i dunno
18:16:18 <copumpkin> :)
18:16:31 <elliott> copumpkin: WHIIIIICH
18:17:15 <copumpkin> @dice 1d2
18:17:15 <lambdabot> 1d2 => 2
18:17:18 <copumpkin> the second one
18:17:40 <oerjan> :t State
18:17:41 <lambdabot> Not in scope: data constructor `State'
18:17:44 <oerjan> argh
18:17:54 <oerjan> :t M.State
18:17:55 <lambdabot> Couldn't find qualified module.
18:17:57 * copumpkin comforts oerjan
18:17:59 <Phantom_Hoover> Deewiant, incidentally, the Wonders of the World need updated for 1.2.
18:18:03 <elliott> *needs
18:18:07 <elliott> *updating
18:18:21 <elliott> copumpkin: he's having a rather traumatic time
18:18:23 <oerjan> copumpkin: i have this feeling they've removed a number of imports from lambdabot
18:18:28 <elliott> copumpkin: just switched from the warm, comforting, old arms of Hugs
18:18:39 <elliott> plunged into the deep, practical, noisy world of GHC and the Haskell Platform
18:18:39 <oerjan> :t Control.Monad.State.State
18:18:40 <lambdabot> Not in scope: data constructor `Control.Monad.State.State'
18:18:45 <elliott> and I think it's taken its toll on his poor, fragile, old soul
18:18:54 <oerjan> now _that_ is just awful
18:19:11 <oerjan> > State
18:19:12 <lambdabot> Not in scope: data constructor `State'
18:19:19 <ais523> hmm, there's a great sense of freedom in testing these kernel-mode keyloggers
18:19:19 <elliott> copumpkin: hm should I wrap it up in a newtype :D
18:19:20 <oerjan> > Control.Monad.State.State
18:19:21 <lambdabot> Not in scope: data constructor `Control.Monad.State.State'
18:19:31 <ais523> because I /know/ they're malicious, I can safely run them without having to check the source for malware first
18:19:34 <Phantom_Hoover> Deewiant, will you do it, or will I?
18:19:36 -!- hagb4rd has joined.
18:19:38 <copumpkin> elliott: always wrap it before you use it
18:19:38 <elliott> ais523: :D
18:19:46 <elliott> copumpkin: but I like type aliases
18:19:51 <elliott> copumpkin: they make things simpler :(
18:19:57 <Deewiant> Phantom_Hoover: Feel free
18:20:04 <elliott> Phantom_Hoover: Update the TNT room
18:20:05 <copumpkin> what's easier isn't always best. wrap it!
18:20:07 <elliott> You might have to empty it first
18:20:08 <ais523> gah, why does this ls highlight non-executable .sh files in green?
18:20:11 <elliott> copumpkin: you suck
18:20:19 <copumpkin> elliott: not until it's wrapped
18:20:42 <ais523> elliott: I'm even logged in as root and everything! (it wouldn't work very well otherwise, but I'm normally terrified to do stuff in a root shell)
18:20:53 <Phantom_Hoover> Wait, that requires well over a hundred lapis blocks.
18:21:08 <elliott> Phantom_Hoover: :D
18:21:11 * copumpkin finally manages to silence elliott
18:21:13 <Gregor> Dood, I do everything logged in as root.
18:21:15 <elliott> Phantom_Hoover: *ore, presumably
18:21:16 <Gregor> Users are for pussies.
18:21:17 <elliott> copumpkin: NOPE
18:21:24 <Phantom_Hoover> elliott, OK YES
18:21:31 <Gregor> Everything HackEgo runs is run as root with no security countermeasures.
18:21:37 <Deewiant> "... increased the drop rate to 4-8 in the 1.2_02 update. However, due to a bug SMP servers still only drop one dye. "
18:21:43 <elliott> Gregor: Yes, you're so trustworthy.
18:21:45 <elliott> Deewiant: It's not a bug.
18:21:47 <Deewiant> I see MC is still all Notch Engineering®
18:21:50 <elliott> Deewiant: It's just that there was no 1.2_02 server version.
18:21:50 <Gregor> elliott: *trusting
18:21:54 <elliott> Gregor: SHUT UP
18:21:58 <ais523> how do you pipe stdout and stderr in bash? it doesn't seem to be |& like I thought it was
18:21:58 <elliott> Deewiant: because it was just a "bugfix".
18:22:07 <elliott> Deewiant: A bugfix that changed game mechanics, anyway, this belongs in #esoteric-minecraft
18:22:12 <elliott> ais523: 2>&1 :P
18:22:14 <Deewiant> elliott: And why release two executables for a bugfix when you can release one
18:22:15 <ais523> must be 2>&1
18:22:16 <elliott> Unless you don't mean that.
18:22:20 <elliott> Deewiant: Precisely!
18:22:27 <elliott> Deewiant: It was a client-only bug, I think, but clearly another change got in.
18:22:31 -!- nescience has joined.
18:22:38 <elliott> But seriously, -minecraft, otherwise the lynching will start again.
18:22:43 <elliott> THE LYNCHING
18:22:58 <Deewiant> I have nothing more to say, I've facepalmed enough
18:23:53 * Gregor gets his lynchin' pipe wrench.
18:24:23 <elliott> Accessor a b -> Accessor t a -> Accessor t b
18:25:42 <elliott> Err, copumpkin, what's the Category instance for this
18:26:12 <copumpkin> id should be obvious
18:26:42 <elliott> copumpkin: Yes
18:26:45 <elliott> (.) is slightly trickier
18:26:50 <copumpkin> not much worse
18:26:52 <elliott> Accessor a . Accessor b =
18:26:52 <elliott> \f x -> let (elem, x') = b id x
18:26:52 <elliott> (elem2, elem') = a f x
18:26:52 <elliott> in (f elem2, I think I'm going about this all wrong
18:26:59 <elliott> (Yes, I typed that into Emacs.)
18:27:34 <copumpkin> :)
18:28:22 <elliott> @hoogle (a -> a) -> a -> (a, a)
18:28:22 <lambdabot> Data.Graph.Inductive.Query.Monad applyWith' :: Monad m => (a -> b) -> GT m g a -> g -> m (b, g)
18:28:23 <lambdabot> Data.Graph.Inductive.Query.Monad applyWith :: Monad m => (a -> b) -> GT m g a -> m g -> m (b, g)
18:28:23 <lambdabot> Control.Monad.Writer.Class listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)
18:28:27 <elliott> @hoogle (a -> b) -> a -> (a, b)
18:28:27 <lambdabot> Control.Monad.Writer.Class listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)
18:28:27 <lambdabot> Network.BufferType buf_span :: BufferOp a -> (Char -> Bool) -> a -> (a, a)
18:28:28 <lambdabot> Data.Graph.Inductive.Query.Monad applyWith' :: Monad m => (a -> b) -> GT m g a -> g -> m (b, g)
18:28:30 <elliott> Meh
18:30:38 <elliott> @djinn ((b -> b) -> a -> (b, a)) -> ((a -> a) -> t -> (a, t)) -> ((b -> b) -> t -> (b, t))
18:30:38 <lambdabot> f a b _ c =
18:30:38 <lambdabot> (case b (\ d -> d) c of
18:30:38 <lambdabot> (e, _) -> case a (\ f -> f) e of
18:30:38 <lambdabot> (g, _) -> g,
18:30:38 <lambdabot> c)
18:30:43 <elliott> copumpkin: Woo
18:30:54 <elliott> Wait, what?
18:30:57 <elliott> It's cheating.
18:31:13 <Deewiant> Your types are too specific
18:31:15 <Deewiant> Presumably
18:32:01 <elliott> :-P
18:32:28 <elliott> a . b = Accessor $ \f x -> (getA a (getA b x), modifyA b (modifyA a f) x)
18:32:30 <elliott> There.
18:32:41 <Deewiant> @djinn (x -> a -> (b, a)) -> ((a -> a) -> t -> (a, t)) -> (x -> t -> (b, t))
18:32:41 <lambdabot> f a b c d =
18:32:41 <lambdabot> (case b (\ e -> e) d of
18:32:42 <lambdabot> (f, _) -> case a c f of
18:32:42 <lambdabot> (g, _) -> g,
18:32:42 <lambdabot> d)
18:32:48 <elliott> copumpkin: Accessor feels to specific a name I think I'm going to call it Field or something. Component?
18:33:23 -!- azaq23 has joined.
18:34:12 <copumpkin> Lens
18:34:13 <copumpkin> :P
18:34:42 <elliott> @pl p (f (g x)) x
18:34:43 <lambdabot> p (f (g x)) x
18:35:42 <Deewiant> @pl \p f g x -> p (f (g x)) x
18:35:42 <lambdabot> flip flip id . ((flip . (ap .)) .) . (. (.)) . (.) . (.)
18:35:50 <elliott> @pl \g p -> accessor (\f x -> (g x, p (f (g x)) x))
18:35:51 <lambdabot> (accessor .) . ap ((.) . (.) . liftM2 (,)) (flip flip id . ((flip . (ap .)) .) . flip ((.) . (.)) . flip (.))
18:35:56 <elliott> I prefer my version
18:35:57 <Deewiant> @pl \x -> p (f (g x)) x
18:35:57 <lambdabot> p =<< f . g
18:36:14 <elliott> Hmm
18:36:32 <elliott> @pl \f x -> p (f (g x)) x
18:36:32 <lambdabot> join . (p .) . (. g)
18:36:32 <Phantom_Hoover> Who is messing with @pl an d why.
18:36:35 <Deewiant> @pl \x -> (g x, p (f (g x)) x)
18:36:36 <lambdabot> liftM2 (,) g (p =<< f . g)
18:36:36 <Phantom_Hoover> *and
18:36:42 <Deewiant> @pl \f x -> (g x, p (f (g x)) x)
18:36:43 <lambdabot> liftM2 (,) g . join . (p .) . (. g)
18:38:23 <oerjan> @pl \g f x -> (g x, p (f (g x)) x)
18:38:24 <lambdabot> ap ((.) . liftM2 (,)) (flip flip id . (liftM2 p .) . flip (.))
18:38:38 <oerjan> @pl \p f x -> (g x, p (f (g x)) x)
18:38:39 <lambdabot> (liftM2 (,) g .) . flip flip id . (ap .) . (. (. g)) . (.)
18:39:19 <Deewiant> I got lost at the \f x one already
18:39:29 <oerjan> um what order of arguments do you _actually_ want?
18:39:58 <oerjan> is it that p f g x above?
18:40:38 <Deewiant> Looking at elliott's accessor-line, \f x
18:41:14 <oerjan> o k
18:43:20 <Deewiant> @pl \f -> g &&& (p =<< f . g)
18:43:20 <lambdabot> (g &&&) . (p =<<) . (. g)
18:44:01 -!- sebbu2 has joined.
18:45:54 -!- sebbu has quit (Ping timeout: 240 seconds).
18:47:45 <elliott> copumpkin: *Shiro.Accessor> (fstA ^= 2) (1,2)
18:47:46 <elliott> (2,2)
18:48:07 <Deewiant> > first (const 2) (1,2)
18:48:08 <lambdabot> (2,2)
18:48:42 <elliott> *Shiro.Accessor> [1,2,3] ^$ tos
18:48:42 <elliott> 1
18:48:42 <elliott> *Shiro.Accessor> [] ^$ tos
18:48:42 <elliott> 0
18:48:42 <elliott> Woot
18:49:06 <Deewiant> > headDef 0 [1,2,3]
18:49:06 <lambdabot> Not in scope: `headDef'
18:49:09 <Deewiant> Bah
18:49:15 <elliott> Deewiant: Yes, the point is that they're accessors.
18:49:24 <Deewiant> I know :-P
18:49:27 <elliott> Deewiant: So I don't need "modifyStack" and all that :P
18:49:53 <ais523> haha, jix_wiggle3 is actually detecting defend7 in particular (by counting small decoys) and using a slower kill algo in order to beat it
18:50:19 <Gregor> Bleh, this is why we need MetaBFJoust
18:50:39 <Gregor> I could set up MetaBFJoust to just run the hill once every ten minutes plus once every time you ask for it :P
18:50:50 <Gregor> So it would change ON ITS OWN!
18:52:02 <oerjan> um the result between two bfjoust programs is deterministic, right? so no need to run the actual fights more than once?
18:52:19 <ais523> oerjan: indeed
18:52:32 <Gregor> The output of a MetaBFJoust program is based on the programs in the last run of the hill (they are the input)
18:52:51 <Gregor> So potentially it changes every hill even if all the MBFJ programs are the same.
18:52:54 <nescience> metabfjoust what?
18:53:26 <nescience> also has wiggle even been updated since forever?
18:53:30 <Gregor> nescience: I had an idea to make a new hill where instead of writing BFJoust programs, you write programs in "any" language which /output/ BFJoust programs, given the previous hill's BFJoust programs as input.
18:53:38 <ais523> nescience: no, it hasn't
18:53:47 -!- yiyus has quit (Ping timeout: 255 seconds).
18:53:49 <ais523> but defend10 and defend7 both use a similar decoy structure
18:53:51 <nescience> gregor: lol
18:54:03 <ais523> so they're both detected and use the same counter-defend strategy
18:54:13 <nescience> ais: he pretty much just messed with the numbers until they beat everything
18:54:16 <elliott> > (-2) `rem` (-2)
18:54:16 <Gregor> nescience: Mainly because everybody talks about how their programs are optimized to other programs on the hill, and doing MBJS would make it possible to break that OR use it even more skillfully.
18:54:17 <lambdabot> 0
18:54:28 <elliott> > (-2) `rem` (-2) == 0
18:54:29 <lambdabot> True
18:54:35 <nescience> gregor: interesting
18:54:43 <ais523> Gregor: mine are rarely deliberately aimed at particular enemies
18:54:55 <Gregor> s/their /some /
18:54:59 <ais523> actually, a bigger hill would mostly avoid the issue
18:55:07 <nescience> I don't think most are written "against" certain enemies
18:55:08 <Gregor> What size wouldja like?
18:55:11 <nescience> it's more like
18:55:13 <ais523> because aiming for the leaders would leave you doing suboptimal things that made you vulnerable to riff-raff
18:55:16 -!- yiyus has joined.
18:55:26 <ais523> 20's beginning to get there at the moment
18:55:32 <nescience> people enter things and then fiddle with them until they succeed more
18:55:37 <ais523> nescience: indeed
18:56:05 <ais523> if you look at wiggle3, though, it has a pretty explicit "use a slow clear algo upon encountering an enemy with exactly two decoys"
18:56:36 <nescience> I'll have to read again
18:56:41 <ais523> on the other hand, it turns out that even without that detection, wiggle3 beats defend10 on most tape lengths
18:56:44 <nescience> unfamiliar with all the programs
18:57:05 <ais523> for unrelated reasons
18:57:14 <ais523> so that particular bit of targeting is actually unnecessary, at least in that case
18:57:51 <nescience> I don't see the detect-two-decoys thing immediately
18:58:32 <ais523> it first detects the first nonzero cell; then uses a different algo for clearing each of the next five
18:58:47 <nescience> I see five slightly different attacks
18:59:00 <nescience> that trigger on the first nonzero one after the next
18:59:03 <nescience> right
18:59:27 -!- nescience has quit (Remote host closed the connection).
19:00:07 <elliott> Vorpal: I have an O(1) wrapping function here you might like to use.
19:00:12 <elliott> For rectangle bounds.
19:00:45 <ais523> elliott: is that possible?
19:00:49 <elliott> ais523: Yes.
19:01:04 <elliott> ais523: The standard loop is just "Subtract delta, then subtract delta while in bounds, then add delta".
19:01:18 <elliott> This reduces to a rather simple equation.
19:01:18 -!- nescience has joined.
19:01:23 <ais523> oh, you mean for wrapping round the bounds, rather than calculating what the bounds are
19:01:28 <elliott> Yes, indeed.
19:01:31 <nescience> getting a little tired of phone crashing
19:01:57 <Vorpal> elliott, hm what is the algorithm
19:02:00 <ais523> nescience: a 3-cycle clear defeats defend10 and defend7, that's what's used on the third element
19:02:06 <nescience> anyway I think there were like 3 or 4 defend programs on the hill at the time
19:02:13 <elliott> Vorpal: It'll be easier for you to translate my Haskell than for me to explain it. It's very simple.
19:02:17 <nescience> so I'm not surprised
19:02:27 <elliott> Vorpal: http://hpaste.org/43786/wrapping
19:02:40 <nescience> it's a more complicated version of what I was moving towards with slowrush
19:02:40 <elliott> Vorpal: div is integer division.
19:02:46 <Vorpal> elliott, raw link? df + browser = slow
19:02:51 <elliott> Vorpal: http://hpaste.org/raw/43786/wrapping
19:02:54 <Vorpal> thanks
19:03:21 <nescience> it was more to target the strategy than a specific revision
19:04:02 <Vorpal> > :t frac
19:04:03 <lambdabot> <no location info>: parse error on input `:'
19:04:05 <Vorpal> what
19:04:11 <elliott> Vorpal: I define it right there...
19:04:14 <Vorpal> oh right
19:04:16 <elliott> Also, it's ":t frac", not "> :t frac".
19:04:36 <Vorpal> elliott, I find reading bottom to top a bit confusing still :P
19:04:46 <Vorpal> elliott, does it pass mycology?
19:04:54 <elliott> Vorpal: Yes.
19:04:59 <ais523> chainmail beats wiggle3 because it only has one decoy (the tripwire) in front of the cell it locks the opponent on, and uses a 128-cycle rather than 256-cycle lock which is resistant to defense-detecting infinite loops like wiggle3 uses (probably accidentally)
19:05:01 <elliott> Well, all the wrapping parts, yes :P
19:05:06 <elliott> It doesn't pass because of o.
19:05:08 <elliott> But that's my bug :P
19:05:12 <Vorpal> elliott, where does it define the Ray type?
19:05:17 <ais523> o doesn't need to be implemented, does it?
19:05:21 <elliott> Vorpal: It doesn't, but it doesn't need to.
19:05:26 <elliott> Vorpal: (x,y) is the current position, (dx,dy) is the current delta.
19:05:32 <Vorpal> <elliott> Vorpal: It doesn't, but it doesn't need to. <--
19:05:33 <Vorpal> what
19:05:36 <Vorpal> was that to ais?
19:05:40 <elliott> No.
19:05:43 <elliott> It doesn't define the Ray type there.
19:05:46 <Vorpal> ah
19:05:48 <elliott> Because you don't need to see it to make sense of the algorithm :P
19:05:53 <elliott> I just pass around rays because that's what I use.
19:05:57 <elliott> ais523: no, but I do implement it
19:06:01 <elliott> ais523: I just don't implement text mode output yet
19:06:11 <Vorpal> elliott, and a ray is just x,y,dx,dy?
19:06:20 -!- asiekierka has quit (Ping timeout: 260 seconds).
19:06:22 <elliott> Yes.
19:06:23 <ais523> anyway, I think the reason wiggle3 does so well is that it has a sort of enhanced offset clear that detects multiple decoy sizes
19:07:03 <elliott> copumpkin: hmm, I don't think I can implement Arrow Accessor
19:07:09 <ais523> that works well against programs that are just adjusting their decoys to beat each other
19:07:09 <elliott> (b -> c) -> Accessor b c
19:07:14 <elliott> no way to modify
19:07:31 <nescience> yeah. I wanted to do something similar but it was too late!
19:07:37 <nescience> oh right
19:07:44 <nescience> I remember now
19:07:54 <nescience> it's less about attacking Defend decoys
19:08:06 <nescience> and more about clearing common decoy patterns efficiently
19:08:14 <ais523> yep
19:08:21 <nescience> the numbers chosen worked best for the hill makeup at the time
19:08:41 <nescience> but they are kind of specific
19:10:26 <ais523> !bfjoust decoybooster (>)*8(+)*128(<(+)*128)*7(>)*7([(+)*30[-]]>)*21
19:10:49 <EgoBot> Score for ais523_decoybooster: 8.4
19:10:57 <ais523> hmm, I wonder why that did so badly?
19:11:22 <elliott> Vorpal: Implemented it yet? :-P
19:12:00 <Deewiant> elliott: If you're interested in CCBI's wrapping it's basically Dimension.rayIntersects in ccbi.space.utils
19:12:51 <elliott> Deewiant: I'll take a look at it. How does slowdown.b98 slow down cfunge, btw? By making it iterate over tons of cells before it gets to the end of the line and wraps?
19:13:22 <Deewiant> That's the main reason cfunge is noticeably slow there, yes
19:13:55 <elliott> Deewiant: I was thinking I would store the bounds of each line and column, but then slowdown2.b98 could just fly instead.
19:14:07 <elliott> So I guess I need your hideously complicated stuff at some point :P
19:14:29 <Deewiant> If you insist :-P
19:14:39 <Vorpal> elliott, no. Still playing df
19:14:46 <elliott> Deewiant: Well, writing anything that falls down on flying things sucks.
19:14:47 <Vorpal> elliott, I'm not in any hurry
19:15:01 <elliott> Vorpal: OK, I'll just release Shiro 1.0: "Totally Better Than cfunge".
19:15:07 <elliott> Deewiant: I hate special cases :P
19:15:11 <elliott> (i.e. cardinality)
19:15:33 <Deewiant> Fair warning: rayIntersects is 250 lines long, more than half of that being comments
19:15:42 <Vorpal> elliott, well you are free to code name them whatever you want. Besides cfunge was 0.99 or such last I checked. Meaning it never claimed to be as stable as a 1,0
19:15:45 <Vorpal> 1.0*
19:16:20 <Vorpal> or as good even
19:18:13 <elliott> Deewiant: I'm reading this and my mind has basically turned off.
19:18:20 <Deewiant> :-)
19:18:28 <ais523> !bfjoust decoybooster (>)*8(+)*128(<(+)*128)*7(>)*7([(+)*5[-]]>)*21
19:18:32 <elliott> Deewiant: Kudos, though :P
19:18:39 <EgoBot> Score for ais523_decoybooster: 9.6
19:18:40 <Deewiant> Cheers :-P
19:18:40 <ais523> aha, the offset clear was just /too/ offset
19:18:48 <ais523> to beat even simple programs
19:18:50 <Deewiant> elliott: If you can O(1) that too I'd appreciate it
19:18:59 <elliott> Deewiant: Gee, that sounds like fun.
19:19:13 <elliott> copumpkin: Ha, Data.Lenses doesn't wrap Accessor.
19:19:42 <elliott> Deewiant: I think yours might be inherently >O(1).
19:19:48 <elliott> Deewiant: Because of your multiple-bounding-box stuff.
19:20:02 <Deewiant> rayIntersects only works on one box
19:20:33 <ais523> !bfjoust decoybooster (>)*8(+)*64<(-)*64(<(-)*64<(+)*64)*3(>)*7([(+)*5[-]]>)*21
19:20:49 <Deewiant> But it's O(width of box) or something in the pathological case
19:20:57 <elliott> Deewiant: Couldn't you use my wrap, then?
19:21:05 <elliott> Or at least a modified version of it.
19:21:06 <EgoBot> Score for ais523_decoybooster: 10.0
19:21:17 <Deewiant> Your wrap solves a different problem
19:21:28 <elliott> Yes, it does.
19:21:33 <elliott> But it might be vaguely applicable :P
19:21:46 <Deewiant> Again, I'd appreciate it if you can figure it out ;-)
19:21:59 <elliott> Deewiant: I think you're vastly more qualified than me.
19:22:13 <ais523> !bfjoust decoybooster (>)*7<(-)*64(<(-)*64<(+)*64)*3(>)*7([(+)*5[-]]>)*21
19:22:21 <EgoBot> Score for ais523_decoybooster: 13.7
19:22:43 <ais523> !bfjoust decoybooster (>)*7(-)*64(<(-)*64<(+)*64)*3(>)*7([(+)*5[-]]>)*21
19:22:53 <EgoBot> Score for ais523_decoybooster: 15.9
19:23:35 <ais523> decoybooster's beating more than it's losing to, but it's still last :)
19:23:40 -!- augur has quit (Remote host closed the connection).
19:23:43 <ais523> !bfjoust decoybooster (>)*7(-)*64(<(-)*64<(+)*64)*3(>)*7([(+)*5[-.]]>)*21
19:23:51 <EgoBot> Score for ais523_decoybooster: 30.6
19:24:47 <ais523> whereas that made it beat fewer programs, but better programs, as I put a counter-defence offset clear in there
19:24:48 <Gregor> http://codu.org/eso/bfjoust/breakdown.txt <-- for your viewing pleasure, the breakdown for the latest program submitted.
19:24:56 <ais523> yay, thanks
19:25:23 <ais523> the < and > refer to the winner with each length?
19:25:29 <Deewiant> And X is a tie?
19:25:45 <Gregor> The confusotron is divided by polarities then tape lengths (space separates polarities), < is left won, > is right won, X is tie
19:25:47 <Gregor> Yeah
19:26:13 <ais523> I suppose you could break it down further by win reason, but that might be a little ridiculous
19:26:25 <elliott> decoybooster won against EVERYTHING?
19:26:26 <Gregor> Donwanna :P
19:26:32 <elliott> oh, no
19:26:37 <ais523> no, not everything
19:26:41 <elliott> !bfjoust talisman <
19:26:44 <EgoBot> Score for elliott_talisman: 0.0
19:26:48 <elliott> http://codu.org/eso/bfjoust/breakdown.txt :D
19:26:52 <ais523> I could tweak it slightly to beat rushpolarity if I wanted to, but that feals like cheating
19:27:12 <Deewiant> Gregor: Want to print the counts of <>X?
19:27:21 <Gregor> Deewiant: Nopw.
19:27:23 <Gregor> *Nope
19:27:23 <elliott> Gregor: Err, why do you do four polarities?
19:27:25 <elliott> It should only take two.
19:27:29 <Deewiant> elliott: -- -+ +- ++
19:27:36 <elliott> Yes, but +- -+ should be enough.
19:27:37 <Gregor> elliott: To quote "SCORES" "for, uhh, completeness?"
19:27:41 <elliott> :-D
19:28:02 <elliott> Deewiant: Holy shit cfunge is slow at fungicide.
19:28:05 <nescience> tweak it :P may as well!
19:28:31 <Deewiant> elliott: Lookup tables are :-P
19:28:32 <elliott> Deewiant: BTW, the graphs show in little tiny windows for me.
19:28:49 <elliott> Little tiny scrollable windows.
19:29:07 <elliott> :D @ mebioctets
19:29:51 <Deewiant> If your browser can't handle <object type="image/svg+xml"> then I weep for it
19:31:04 <Gregor> Heywait, the flag is always 127, right? Regardless of polarity? (I should be telling this, not asking it :P )
19:31:16 <ais523> Gregor: 128
19:31:23 <Gregor> Oh :P
19:31:27 <Gregor> Well that makes more sense X-P
19:31:30 <ais523> which == -128, ofc
19:31:36 <Gregor> Yuh
19:31:45 <Gregor> You see where I was going with my totally-wrong thought though :P
19:31:51 <ais523> tape[0] = tape[tapelen-1] = 128;
19:32:57 <ais523> I'll leave decoybooster there, I think
19:32:59 <coppro> !bfjoust dumdum (>(+)*254)*100
19:33:05 <EgoBot> Score for coppro_dumdum: 0.0
19:33:07 <Deewiant> elliott: cfunge mostly loses total time due to fork.b98 though, which has since been fixed AFAIK
19:33:08 <coppro> :(
19:33:10 <Gregor> lol
19:33:15 <ais523> coppro: two-cycle rules
19:33:19 <elliott> <Deewiant> If your browser can't handle <object type="image/svg+xml"> then I weep for it
19:33:19 <elliott> It does
19:33:23 <elliott> It just doesn't make them the right size
19:33:24 <elliott> (Chrome)
19:33:27 <coppro> ais523:
19:33:30 <Vorpal> Deewiant, indeed it has been fixed
19:33:33 <Gregor> pooppy: It tied against defend7 :P
19:33:35 <coppro> err, d'oh
19:33:41 <coppro> !bfjoust dumdum (>(+<>)*254)*100
19:33:41 <ais523> it's a tactic that hasn't been used much yet (the only other program I've seen do something remoately similar is myndzi/nescience's 3pass, which is not really the same)
19:33:46 <EgoBot> Score for coppro_dumdum: 18.9
19:33:49 <coppro> O_o
19:33:51 <ais523> also, you can use . to wait a cycle
19:34:00 <coppro> !bfjoust dumdumwait (>(+.)*254)*100
19:34:05 <EgoBot> Score for coppro_dumdumwait: 11.6
19:34:13 <coppro> dumdum is a champ
19:34:14 <ais523> strange how being slower and stupider worked better
19:34:19 <ais523> I recommend .. over <>, anyway
19:34:23 <Gregor> ais523_tripstridewire.bfjoust vs coppro_dumdumwait.bfjoust:
19:34:24 <Gregor> <<><><><><><><><><><< <<><><><><><><><><><< <<><><><><><><><><><< <<><><><><><><><><><<
19:34:25 <Gregor> lol
19:34:28 <coppro> !bfjoust dumdum (>(+..)*254)*100
19:34:34 <ais523> Gregor: tripstridewire's like that
19:34:34 <EgoBot> Score for coppro_dumdum: 18.9
19:34:44 <coppro> I am amazed such a dumb program does so well
19:34:56 <ais523> it tends to win just over or just under 50%; it's an exploit on the scoring system, really
19:35:20 <Gregor> Getting 18.9 does not count as an exploit in anything :P
19:35:39 <ais523> Gregor: tripstridewire has 28.4
19:35:48 <ais523> despite not actually being very good
19:35:59 <Gregor> Oh, I thought you were talking about dumdum :P
19:36:14 <Gregor> lol, it has negative points and a decent score X-D
19:36:33 <ais523> coppro: aha, the difference between .. and . is that .. is the simplest timing that defeats my defence programs
19:36:34 <elliott> copumpkin: I think I regret rolling my own :P
19:36:47 <quintopia> Gregor: let us make awesome things by making sure that ] happens after cells get updated on the current cycle >_>
19:36:48 <ais523> I should come up with a defend11 that can beat a three-cycle clear, somehow
19:37:07 <elliott> quintopia: That's a bug that was fixed.
19:37:07 <ais523> that would be an actual substantive rules change; I'm not sure what to do about those on an old hill
19:37:11 <Gregor> quintopia: I'm not changing the rules ...
19:37:18 <elliott> CHANGE
19:37:18 <elliott> EVERY
19:37:19 <elliott> RULE
19:37:20 <quintopia> Gregor: twas a joke, dogg
19:37:21 <ais523> elliott: quintopia wants to exploit it
19:37:25 <elliott> ais523: obviously
19:37:41 <ais523> oh right, the []++++++ programs were /too/ good, weren't they?
19:37:51 <ais523> and crowded out all the competition
19:37:58 <Gregor> !bfjoust wtf_do_I_think_Im_doing +[[(++.)*100]+]
19:38:14 <EgoBot> Score for Gregor_wtf_do_I_think_Im_doing: 8.8
19:38:24 <Deewiant> !bfjoust monorail (>+>-)*1>++>([(-)*9[+]]>)*20
19:38:29 <Gregor> Hah, I love defend v defend scores :P
19:38:30 <EgoBot> Score for Deewiant_monorail: 2.9
19:38:40 <Deewiant> !bfjoust monorail (>+>-)*4>++>([(-)*9[+]]>)*20
19:38:52 <EgoBot> Score for Deewiant_monorail: 24.3
19:39:01 <ais523> wow what happened to monorail
19:39:04 <ais523> oh, Deewiant changed it
19:39:13 <Deewiant> And back again
19:39:18 <ais523> I was wondering how it suddenly dropped right down the rankings after being there for years
19:39:38 <elliott> @hoogle Int -> a -> [a] -> [a]
19:39:38 <lambdabot> Network.CGI.Protocol replace :: Eq a => a -> a -> [a] -> [a]
19:39:39 <lambdabot> Prelude enumFromThenTo :: Enum a => a -> a -> a -> [a]
19:39:39 <lambdabot> Data.IntMap findWithDefault :: a -> Key -> IntMap a -> a
19:39:41 <Deewiant> Oh, woops
19:39:42 <quintopia> oh that's what monorail does. how very simple.
19:39:46 <elliott> hmph
19:39:56 <Deewiant> !bfjoust monorail (>+>-)*1>++>([(-)*9[+]]>)*26
19:40:03 <ais523> quintopia: it is /just/ decoy, offset clear, defense detector
19:40:07 <EgoBot> Score for Deewiant_monorail: 6.3
19:40:09 <ais523> nice to see a program that simple do reasonably well
19:40:11 <Deewiant> Oh well
19:40:15 <Deewiant> !bfjoust monorail (>+>-)*4>++>([(-)*9[+]]>)*20
19:40:20 <EgoBot> Score for Deewiant_monorail: 24.3
19:40:56 <ais523> I'm beginning to think that all programs should use defence detectors
19:41:02 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-.)*9[+...]]>)*20
19:41:05 <EgoBot> Score for Deewiant_steamroller: 17.4
19:41:18 <Gregor> !bfjoust defend_enemy_turf (>)*10(+)*128[[](+)*128]
19:41:18 <ais523> because they hardly cost anything and can really help
19:41:25 <quintopia> !bfjoust slowmonorail (>+>-)*4>++>([(..-)*20[+]]>)*20
19:41:33 <Gregor> Yowza
19:41:49 <Deewiant> Heh, steamroller beat only defend7, defend10, and chainmail, all of which beat monorail
19:42:01 <EgoBot> Score for Gregor_defend_enemy_turf: 1.8
19:42:01 <EgoBot> Score for quintopia_slowmonorail: 19.9
19:42:06 <quintopia> hmm
19:42:10 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*9[+...]]>)*20
19:42:15 <EgoBot> Score for Deewiant_steamroller: 17.4
19:42:20 <elliott> @hoogle MonadState
19:42:20 <lambdabot> No results found
19:42:36 <quintopia> Deewiant: did it beat slowmonorail?
19:42:42 <Deewiant> Didn't check
19:42:44 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*9[+..]]>)*20
19:42:48 <EgoBot> Score for Deewiant_steamroller: 6.6
19:42:51 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*9[+.]]>)*20
19:42:59 <EgoBot> Score for Deewiant_steamroller: 19.7
19:43:02 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*9[+....]]>)*20
19:43:10 <Gregor> BFJoust really ought to have threads.
19:43:17 <EgoBot> Score for Deewiant_steamroller: 0.0
19:43:20 <Deewiant> heh
19:43:24 <quintopia> Gregor: bf multi joust!
19:43:30 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*9[...+]]>)*20
19:43:33 <EgoBot> Score for Deewiant_steamroller: 18.1
19:43:37 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*9[.+]]>)*20
19:43:41 <EgoBot> Score for Deewiant_steamroller: 18.1
19:44:03 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(.-)*9[+]]>)*20
19:44:09 <EgoBot> Score for Deewiant_steamroller: 16.2
19:44:11 <ais523> I think we're getting a genuine stone-paper-scissors in BF Joust
19:44:20 <ais523> fast attack beats slow attack beats defence beats fast attack
19:44:34 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-+-)*9[.+]]>)*20
19:44:37 <EgoBot> Score for Deewiant_steamroller: 18.1
19:44:44 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-+-)*9[+.]]>)*20
19:44:49 <EgoBot> Score for Deewiant_steamroller: 18.1
19:44:57 <quintopia> ais523: is it possible to combine slow attack and defense?
19:44:58 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*9[+.]]>)*20
19:45:07 <EgoBot> Score for Deewiant_steamroller: 18.1
19:45:08 <ais523> quintopia: nescience was discussing that earlier
19:45:10 <Deewiant> Oh well
19:45:11 <ais523> the answer is, I'm not sure
19:45:28 <ais523> although decoybooster was inspired by the conversation, it uses a different principle
19:45:35 <ais523> (that of using decoys to set up bigger decoys)
19:45:37 <elliott> This is ridiculous, I'm just reinventing data-accessor
19:45:46 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*3[+.]]>)*20
19:45:48 <EgoBot> Score for Deewiant_steamroller: 18.8
19:46:00 -!- kar8nga has joined.
19:46:08 <Deewiant> !bfjoust monorail (>+>-)*4>++>([(-)*3[+]]>)*20
19:46:19 <EgoBot> Score for Deewiant_monorail: 18.4
19:46:27 <Deewiant> !bfjoust monorail (>+>-)*4>++>([(-)*10[+]]>)*20
19:46:33 <EgoBot> Score for Deewiant_monorail: 21.6
19:46:37 <Gregor> !bfjoust specifically_defeat_defend10_and_in_only_one_polarity (>)*9-[>-]>>[-]
19:46:46 <EgoBot> Score for Gregor_specifically_defeat_defend10_and_in_only_one_polarity: 0.2
19:46:50 <quintopia> lul
19:46:50 <Gregor> lol
19:47:12 <Deewiant> !bfjoust monorail (>+>-)*4>++>([(-)*11[+]]>)*20
19:47:18 <EgoBot> Score for Deewiant_monorail: 19.0
19:47:24 <Gregor> !bfjoust specifically_defeat_defend10_and_in_only_one_polarity (>)*7-[>-]>>[-]
19:47:30 <EgoBot> Score for Gregor_specifically_defeat_defend10_and_in_only_one_polarity: 0.0
19:47:38 <Deewiant> !bfjoust monorail (>+>-)*4>++>([(-)*9[+]]>)*20
19:47:42 <Gregor> YESSS
19:47:45 <EgoBot> Score for Deewiant_monorail: 22.2
19:47:50 <nescience> if you make the hill bigger we should go back and fetch some variety
19:47:52 <Gregor> Gregor_specifically_defeat_defend10_and_in_only_one_polarity.bfjoust vs ais523_defend10.bfjoust:
19:47:52 <Gregor> <<<<<<<<<<<<<<<<<<<<< >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> <<<<<<<<<<<<<<<<<<<<<
19:47:55 <Gregor> Can you say PERFECTION?
19:48:02 <nescience> lol
19:48:03 <Deewiant> !bfjoust steamroller (>+>-)*4>++>([(-)*4[+.]]>)*20
19:48:05 <nescience> nice
19:48:06 <EgoBot> Score for Deewiant_steamroller: 18.1
19:48:12 <ais523> Gregor: haha
19:48:16 <Gregor> nescience, ais523: How big would you like the hill?
19:48:17 <ais523> did it beat anything /else/?
19:48:34 <ais523> Gregor: I'd say 30 or maybe 40
19:48:44 <Gregor> ais523: Why no, it defeated nothing else :P
19:48:50 <nescience> no idea.. big enough that interesting programs have a chance to stay on when people screw around
19:48:54 <Gregor> And it didn't beat defend10 either, it tied since it's polarity-specific :P
19:49:12 <nescience> and or maybe change the scoring to not be dependent on the score of the program that lost?
19:49:16 <quintopia> !bfjoust slowmonorail (>+>-)*4>++>([(..-)*20[..+]]>)*20
19:49:20 <EgoBot> Score for quintopia_slowmonorail: 7.1
19:49:21 <nescience> didn't we try that before though?
19:49:27 <ais523> nescience: THE SCORING IS PERFECT, DO NOT QUESTION IT
19:49:27 <quintopia> !bfjoust slowmonorail (>+>-)*4>++>([(..-)*20[+]]>)*20
19:49:31 <EgoBot> Score for quintopia_slowmonorail: 19.3
19:49:39 <Gregor> nescience: ... what does that mean?
19:49:43 <ais523> (and actually I rather like the way the scoring atm works, it makes abuse quite difficult)
19:49:50 <quintopia> !bfjoust slowmonorail (>+>-)*4>++>([(..-)*9[+]]>)*20
19:49:54 <EgoBot> Score for quintopia_slowmonorail: 10.1
19:49:59 <nescience> lol
19:50:03 <quintopia> !bfjoust slowmonorail (>+>-)*4>++>([(..-)*3[+]]>)*20
19:50:07 <EgoBot> Score for quintopia_slowmonorail: 16.2
19:50:09 <Phantom_Hoover> Back.
19:50:16 <quintopia> !bfjoust slowmonorail (>+>-)*4>++>([(..-)*20[+]]>)*20
19:50:19 <nescience> weren't you talking about getting o.n the hill just by targeting specific programs?
19:50:20 <quintopia> that's so weird
19:50:20 <EgoBot> Score for quintopia_slowmonorail: 19.3
19:50:20 <Phantom_Hoover> Still at the BF Joust‽
19:50:34 <ais523> nescience: and Gregor's program didn't get on the hill
19:50:36 <elliott> copumpkin: I'm travelling to Henningland
19:50:49 <tswett> _o_
19:50:52 <quintopia> ais523: you got any idea why slowmonorail works best with that particular timing
19:50:54 <elliott> tswett: o_o
19:50:55 <quintopia> ?
19:51:04 <nescience> well it was a little too specific :P
19:51:26 <tswett> myndzi\: _o_. :P
19:51:26 <myndzi\> |
19:51:26 <myndzi\> /|
19:51:32 <tswett> Oh, I see.
19:51:40 <tswett> I was too close to the left edge.
19:51:57 <Gregor> !bfjoust specifically_defeat_defend10_and_in_only_one_polarity (>)*7-[>-]>>[-]
19:52:00 <EgoBot> Score for Gregor_specifically_defeat_defend10_and_in_only_one_polarity: 0.0
19:52:24 <Gregor> !bfjoust lets_fill_the_newly_resized_hill_with_stupid_garbage <
19:52:27 <EgoBot> Score for Gregor_lets_fill_the_newly_resized_hill_with_stupid_garbage: 0.0
19:52:38 <quintopia> the hill is bigger?
19:52:41 <tswett> Anyway, _o_ is the pose one of the disciples in Caravaggio's "The Supper at Emmaus" makes when he realizes he's sitting next to Jesus.
19:52:41 <myndzi\> |
19:52:41 <myndzi\> /<
19:52:42 <quintopia> how much?
19:52:49 <Gregor> You'll just have to find out :P
19:52:51 <tswett> He goes "Holy crap!" and sticks his arms out.
19:52:59 <ais523> I'll submit some of my old ones
19:53:07 <ais523> !bfjoust tripwire_sensor >+>+++>+<[]<(.)*48[<(+)*100000]<(-)*100000
19:53:12 <elliott> tswett: Who's Jesus.
19:53:26 <quintopia> !bfjoust nop .
19:53:27 <tswett> elliott: a character in European mythology.
19:53:34 <EgoBot> Score for ais523_tripwire_sensor: 5.2
19:53:37 <ais523> !bfjoust defend9 http://sprunge.us/TjjN
19:53:40 <elliott> Why'd you make the jesus-look
19:53:46 <EgoBot> Score for quintopia_nop: 9.5
19:53:54 <tswett> To show what the jesus-look looks like.
19:54:01 <tswett> Gregor: what are your rates as a pianist?
19:54:10 <quintopia> he can't piano!
19:54:11 <Gregor> Depends on what I'm asked to play.
19:54:12 <quintopia> :P
19:54:20 <quintopia> Gregor: chopsticks?
19:54:36 <Gregor> quintopia: $16,000 for a low-quality MIDI with no inflection.
19:54:56 <quintopia> reasonable
19:55:08 <ais523> Gregor: Gregor_specifically_defeat_defend10_and_in_only_one_polarity.bfjoust seems to beat defend10 overall; does it draw the other polarity?
19:55:19 <ais523> also, I probably shouldn't have put defend9 on the hill, I forgot how evilly CPU-intensive it was
19:55:24 <Gregor> ais523: No, it wanders off the end and loses :P
19:55:32 <ais523> so how does it win overall?
19:55:41 <Gregor> ais523: It doesn't.
19:55:50 <ais523> (I'm checking an old report while the current one generates, perhaps it was a buggy version of the program)
19:56:03 <Gregor> Oh, yeah, the one where it got a 0.2 did stupid stuff.
19:56:15 <tswett> Gregor: it's about as simple as Mozart's Minuet in F, K. 2.
19:56:16 <Gregor> The "correct" version gets 0.0 X-P
19:56:17 <tswett> Yes, two.
19:56:40 <EgoBot> Score for ais523_defend9: 30.1
19:56:52 <Gregor> Crap sandwiches man, that's a good score too.
19:57:02 <Gregor> (In principle it shouldn't be so bad in the future since it caches :P )
19:57:13 <ais523> Gregor: it was on the hill for ages, it only fell off recently
19:57:22 <ais523> and I wanted to see how it did in the current environment
19:57:33 <ais523> it was ahead of defend7 for quite a while until people started exploiting it
19:57:46 -!- augur has joined.
19:58:12 <ais523> and it's way behind the other defenders, so obviously it's not smart eno
19:58:24 <ais523> *so obviously it's not smart enough to survive in the current environment
19:58:28 <ais523> I blame the rise of offset clears
19:58:41 <tswett> Gregor: about as simple, half as short, and probably worse.
19:58:52 <Gregor> "half as short", so twice the length?
19:58:57 <Gregor> <trollface />
19:59:18 <quintopia> that's actually the way i read it
19:59:32 <quintopia> ambiguity of language: don't do it
19:59:36 <tswett> Yes, if you play it a quarter times as slowly.
19:59:48 <quintopia> AGH
19:59:54 <quintopia> STOP IT :P
19:59:59 <Gregor> So, it's double as long if you play it four times faster than it ought to be played?
20:00:16 <Gregor> Good lord, are you asking me to play Handel's Messiah?
20:00:20 <Gregor> (for Piano)
20:00:26 <olsner> Gregor: yes, if it takes half the time
20:00:33 <quintopia> so length increase at normal speeds is 8x?
20:00:35 -!- sixdej|sleep has changed nick to sixdej.
20:00:37 <quintopia> or is that 16x?
20:00:45 <Gregor> quintopia: 8x
20:00:55 <tswett> Gregor: well, that's only true if you stretch it out by a factor of one sixteenth.
20:01:20 <quintopia> oh god
20:01:26 <quintopia> now it's 48x
20:01:31 <Gregor> http://codu.org/tmp/jungle-2011-02-08-1.ogg More music going into the dustbin :P
20:01:41 <quintopia> which is ... somewhere between messiah and carmina burana?
20:01:50 <tswett> 32x, isn't it?
20:02:17 <nescience> oh you resized it eh
20:02:18 <quintopia> Gregor: this is awful
20:02:24 <quintopia> link me to superturing :P
20:02:25 <Gregor> lol
20:02:32 <nescience> inb4 people lagging it to hell with submissions
20:02:33 <Gregor> So you can complain about it too :P
20:02:44 <quintopia> superturing was awesome
20:02:47 <Gregor> nescience: ais523 already lagged it to hell.
20:03:01 <nescience> lol
20:03:04 <ais523> I didn't feel so guilty back when defend9 was the best program on the hill
20:03:05 <nescience> damn
20:03:06 <Gregor> quintopia: http://codu.org/tmp/cave-2011-02-07-2.ogg I link you to this instead.
20:03:16 <nescience> I want to fetch some of my old ones too :)
20:03:29 -!- Sgeo has joined.
20:03:32 <Gregor> nescience: Nobody's stopping you.
20:03:33 <quintopia> are these for levels in SuperTuring?
20:03:43 <Gregor> quintopia: SuperTuring is not a game :P
20:03:52 <quintopia> yes it is
20:04:01 <ais523> nescience: here's myndzi_keke2: ->>>>>>>>>(>[(-.+(-.)*256(+.)*256>)*20])*20
20:04:03 <Gregor> (But they are to be background music in a game, though jungle isn't)
20:04:03 <quintopia> it's the world's most computable platformer
20:04:10 <ais523> it's the only one by you I have handy that isn't on the current hill
20:04:20 <Gregor> quintopia: It's SUPERTuring
20:04:24 <tswett> Anyway. 48 beats, andante.
20:04:27 <quintopia> Gregor: FINE
20:04:57 <Deewiant> !bfjoust maglev (>(-)*10)*4(>(+)*10)*4>>-([([-])*2([+])*2>]+)*30
20:05:16 <Gregor> tswett: Send me the score later and I'll judge.
20:05:59 <ais523> Gregor: we'll have to wait for Lymia to come back and fill the hill with evoprograms
20:06:04 <quintopia> !bfjoust slowmonorail (>+>-)*4>++>([(..-)*20[+]]>)*20
20:06:09 <nescience> ha, later I'll dig through the history and see what got knocked off recentlyish
20:06:19 <tswett> http://www.cis.gvsu.edu/~swettt/music/opl1.pdf
20:06:23 <elliott> Deewiant: I swear I'll get Concurrent Funge done today.
20:06:26 <tswett> Gregor: does this count as sending it to you later? :P
20:06:38 <Gregor> tswett: No.
20:06:44 <Gregor> I'm at schwork.
20:06:46 <quintopia> !bfjoust one_o_them_shudder_thangs (--+)*384000
20:06:49 <tswett> Ah.
20:07:16 <tswett> So, how does bfjoust work? Is there a page explaining it?
20:07:19 <Gregor> Wait for something to finish first X-D
20:07:23 <Deewiant> ais523: defend9 is making this a pain :-P
20:07:28 <quintopia> Gregor: WAT GAME IS FOR
20:07:30 <Gregor> tswett: "BF Joust" on the wiki.
20:07:33 * tswett nods.
20:07:40 <Gregor> quintopia: 's in development.
20:07:40 <ais523> http://esolangs.org/wiki/BF_Joust
20:07:47 <ais523> (I have an esolangs.org shortcut in my IRC client)
20:07:51 <quintopia> Gregor: plaformer? has name?
20:08:20 <ais523> quintopia: clearly, the null string, based on Gregor's last comment
20:08:26 -!- Sgeo has quit (Ping timeout: 255 seconds).
20:08:31 <ais523> and that's a great name for a game, and probably a unique one too
20:08:32 <Gregor> quintopia: Platform/adventure. No enemies per se. No name yet. 's not my game.
20:08:48 <ais523> I suppose you could call it ": the Game" if you wanted to make it clearer
20:08:55 <quintopia> Gregor: 2d or 3d?
20:09:18 <EgoBot> Score for Deewiant_maglev: 11.6
20:09:19 <EgoBot> Score for quintopia_one_o_them_shudder_thangs: 16.2
20:09:22 <EgoBot> Score for quintopia_slowmonorail: 24.1
20:09:22 <quintopia> ais523: how about "The Best Game Named You've Ever Played"
20:09:24 <Gregor> quintopia: 2D movement in a 3D-rendered environment
20:09:35 <Gregor> ais523: But it would actually be "\0: the Game\0", so most languages wouldn't be able to display the name.
20:09:47 <Deewiant> Meh, maglev used to be good
20:09:48 <nescience> next project: distributed hill!
20:09:53 <quintopia> Gregor: null character != null string
20:10:01 <Vorpal> Deewiant, I found a way to place chests on top of each other
20:10:06 <Gregor> quintopia: Piffle
20:10:09 <Vorpal> Deewiant, if you want for your "wonders of the world"
20:10:15 <Deewiant> Feel free :-P
20:10:17 <ais523> let's name it (game)^
20:10:22 <ais523> i.e. minus the string "game"
20:10:28 -!- augur has quit (Remote host closed the connection).
20:10:38 <ais523> antitext is something I invented for Cyclexa, but perhaps it has applications elsewhere
20:10:42 <Gregor> OK, maybe defend9 IS too slow X-D
20:10:55 <ais523> Gregor: I don't mind massively if you remove it from the hill
20:11:17 <ais523> although there isn't currently a program pending
20:11:25 <quintopia> does defend9 always use up the entire 384000 cycles?
20:11:32 <ais523> no
20:11:33 <Gregor> Oh, there's not? I didn't see the scores go by :P
20:11:58 <ais523> !bfjoust scoreboard_interpreted_as_program http://codu.org/eso/bfjoust/in_egobot/report.txt
20:12:14 <Deewiant> ais523: How about !bfjoust defend9 <
20:12:15 <elliott> ais523: mingle all the program sources together and submit that
20:12:17 <quintopia> so lots of + - and .
20:12:17 <elliott> with code to balance []s
20:12:28 <EgoBot> Score for ais523_scoreboard_interpreted_as_program: 7.6
20:12:31 <ais523> Deewiant: I'll remove it if it becomes a problem
20:12:36 <ais523> but that ran quickly enough
20:12:45 <Deewiant> Hmm, true
20:12:47 <quintopia> because it sucked
20:12:58 <ais523> it beat nop
20:13:02 <Gregor> ais523: lol
20:13:04 <Vorpal> Deewiant, have you upgraded your railway for new less speedy boosters?
20:13:06 <ais523> in score, taht is
20:13:07 <ais523> *that is
20:13:12 <tswett> Gregor: the scoreboard is better than both of your programs combined.
20:13:17 * ais523 looks at the breakdown
20:13:18 <Gregor> tswett: :(
20:13:19 <tswett> Which is not saying much, since both of your programs have a negative score.
20:13:21 <Gregor> tswett: :'(
20:13:27 <Deewiant> Vorpal: I pretty much haven't touched the boosters since they were built
20:14:04 <Gregor> quintopia: There's also http://codu.org/tmp/cave-tense-2011-02-07-2.ogg , which is cave with a "tension track" added, to be faded in during tense/dangerous moments as a cue.
20:14:11 <tswett> It's better than the harmonic sum of your programs. How's that.
20:14:18 <Gregor> tswett: :'(
20:14:28 <ais523> ais523_large_decoy_attack.bfjoust vs ais523_scoreboard_interpreted_as_program.bfjoust: ><>><><<<<>><<<<>>><< >><<><<<<><<><>><<<>< >><<><<<<><<><>><<<>< ><>><><<<<>><<<<>>><< ais523_large_decoy_attack.bfjoust wins
20:14:34 <ais523> I think that's the reason
20:14:35 <Gregor> Of course, one of them loses against literally everything since its very first cycle is to step off the tape :P
20:14:46 <Deewiant> !bfjoust farmer1 [>(+)*128>(+)*128<[-]>[-]<<]
20:14:54 <ais523> the scoreboard gets intermittent wins against a program that's actually decent
20:14:59 <ais523> in fact, that's a really crazy pattern of < and >
20:15:22 <Vorpal> Deewiant, ah they still work
20:15:27 <ais523> in fact, wtf?
20:15:40 <ais523> large_decoy_attack vs. the scoreboard makes no sense at all
20:15:42 <EgoBot> Score for Deewiant_farmer1: 1.0
20:15:49 <Gregor> !bfjoust breakdown_interpreted_as_program http://codu.org/eso/bfjoust/breakdown.txt
20:15:51 <Gregor> 0.0
20:15:55 -!- augur has joined.
20:15:57 <EgoBot> Score for Gregor_breakdown_interpreted_as_program: 0.1
20:15:58 <ais523> Gregor: it probably starts with <
20:16:03 <Gregor> ais523: Yup ;)
20:16:06 <ais523> hmm, perhaps not
20:16:23 <ais523> but it goes left near the start, just late enough to beat suiciders
20:16:59 <Gregor> lol
20:17:37 <Gregor> !bfjoust log_interpreted_as_program http://tunes.org/~nef/logs/esoteric/11.02.07
20:17:39 <ais523> the scoreboard will be insane for a while until all the joke programs are pushed off
20:17:42 <tswett> Gregor: so it loses against itself?
20:17:53 <EgoBot> Score for Gregor_log_interpreted_as_program: 0.0
20:17:56 <ais523> Gregor: doesn't clog use <nick> in order to specify nicks?
20:17:58 <Gregor> Yessssssssssss
20:18:03 <Gregor> ais523: Yes :P
20:18:08 <ais523> Herobrine's logs would work better for that
20:18:18 <nescience> !bfjoust google_interpreted_as_program http://www.google.com/
20:18:29 <Deewiant> HTML tends to start with <
20:18:31 <ais523> !bfjoust herobrine_log_interpreted_as_program
20:18:34 <EgoBot> Score for nescience_google_interpreted_as_program: 0.0
20:18:42 <EgoBot> Score for ais523_herobrine_log_interpreted_as_program: 0.0
20:18:42 <nescience> ya still
20:18:46 <Gregor> !bfjoust ogg_interpreted_as_program http://codu.org/tmp/cave-tense-2011-02-07-2.ogg
20:18:59 <ais523> oh no, I've started a meme!
20:19:01 <Gregor> This one's gonna get big points.
20:19:02 <EgoBot> Score for Gregor_ogg_interpreted_as_program: 0.0
20:19:03 <tswett> !bfjoust opulus_1_interpreted_as_program http://www.cis.gvsu.edu/~swettt/music/opl1.pdf
20:19:07 <Gregor> D'AWWWW
20:19:16 <EgoBot> Score for tswett_opulus_1_interpreted_as_program: 0.0
20:19:31 <Gregor> OK, I'm done interpreting stupid crap as programs :P
20:19:53 <ais523> !bfjoust parseerror (])*1000000
20:19:57 <tswett> Okay, let's see what wiggle3 looks like.
20:20:14 <ais523> Gregor: the stupid crap tends to shunt defense progams down the leaderboard, incidentally
20:20:18 <ais523> as they draw with it rather than beat it
20:20:26 <Gregor> ais523: Hyuk
20:20:27 <EgoBot> Score for ais523_parseerror: 10.9
20:20:32 <ais523> wait /what/?
20:20:37 <tswett> ais523: good job!
20:20:51 <Deewiant> ais523: You beat all the self-killers
20:20:53 <quintopia> i guess a program that errors out
20:20:54 <quintopia> is a nop
20:21:05 <ais523> yep, it's interpreted as a nop, it seems
20:21:35 <ais523> Gregor: how does specifically_beat_defend10_and_in_only_one_polarity work? tricking it into suiciding?
20:21:38 <Gregor> I think it only actually fails the parser if the metacommands don't match.
20:21:40 -!- Sgeo has joined.
20:21:59 <Gregor> ais523: No, it just looks for the first decoy, skips the second that you're watching, then depletes the flag.
20:22:06 <ais523> ah
20:22:13 <ais523> why does that only work in one polarity?
20:22:24 <Gregor> Because I'm using -[>-] to look for the decoy
20:23:58 <ais523> you obviously put a lot of thought into that program!
20:24:09 -!- impomatic has joined.
20:24:17 <ais523> hi impomatic
20:24:23 <ais523> quite a lot of BF Joust motion today too
20:24:26 <Sgeo> Yay eating on the computer in public
20:24:45 <impomatic> Hi :-)
20:25:17 <ais523> and a larger hill, in order to avoid certain hill effects and cause others
20:25:20 <Sgeo> Gregor, so it assumes there are 2 decoys, or am I misreading you?
20:25:25 <ais523> we could do with some good old programs submitted
20:25:35 <ais523> Sgeo: there are two decoys in defend10
20:25:38 <Gregor> Sgeo: It assumes there are two decoys because that's how defend10 works :P
20:25:45 <ais523> did you not notice the program name?
20:25:49 <impomatic> ais523: I was playing with this >(-)*8>(+)*8>>>+[<-[>>]<]<< which is supposed to was for a cell to be set to zero but only for a limited time.
20:25:57 <Sgeo> ais523, does this mean my crappy programs might get lower scores?
20:26:07 <ais523> score can't go below 0
20:26:09 <impomatic> Doesn't work very well though :-(
20:26:22 <Sgeo> ais523, I've gotten positive scores for jun
20:26:29 <nescience> what's the length range again?
20:26:32 <ais523> I submitted a new defence program (defend10) that works on a different principle to 7 and 9, it was at the top of the leaderboard for a while
20:26:34 <Sgeo> And in one case, a resubmitted program got a wildly diffrent score
20:26:34 <Gregor> 10-30
20:26:34 <ais523> and 10-30 inclusive
20:26:44 <Sgeo> 0 -> non0
20:28:06 <nescience> oh right, that idea wouldn't work whoops
20:28:29 <Gregor> !bfjoust mind_bogglingly_slow_rush [[>(+)*128..>(-)*128..]+]
20:28:40 <EgoBot> Score for Gregor_mind_bogglingly_slow_rush: 21.6
20:28:45 <Gregor> 8-D
20:29:15 <ais523> the scoring algo gives everything generically higher scores on a larger hill
20:29:27 <ais523> so that's not as impressive as 21.6 would be this morning
20:29:33 <Gregor> Ohyeah X-P
20:29:43 <Sgeo> !bfjoust noop .
20:29:45 <ais523> but wow, is that rush slow
20:29:54 <ais523> Sgeo: quintopia submitted that already
20:29:56 <Sgeo> Oh
20:30:09 <Sgeo> What was the score?
20:30:14 <EgoBot> Score for Sgeo_noop: 10.0
20:30:21 <impomatic> Just reading http://codu.org/eso/bfjoust/in_egobot/ais523_defend10.bfjoust :-)
20:30:59 <ais523> hmm, the hill's still growing
20:31:01 <ais523> I /hope/ it isn't infinite
20:31:15 <Gregor> !bfjoust mind_bogglingly_slow_rush_with_benefits (>)*9-[[+>(+)*128..>(-)*128..-]+]
20:31:21 <impomatic> Why is the hill so big?
20:31:24 <EgoBot> Score for Gregor_mind_bogglingly_slow_rush_with_benefits: 24.7
20:31:27 <Gregor> ais523: It's not, but it's more than double what it was :P
20:31:36 <ais523> so probably 50, then
20:31:41 <ais523> impomatic: we thought it would be more interesting
20:31:50 <Gregor> It will be once there's less garbage on the hill.
20:31:50 <ais523> although it needs to fill with sane programs for that to be a reason
20:32:10 <ais523> !bfjoust attack1 [>[-]+]
20:32:13 <ais523> my first program
20:32:22 <EgoBot> Score for ais523_attack1: 15.3
20:32:31 <Sgeo> ais523, so I should stop participating?
20:32:44 <ais523> Sgeo: nah, the good programs push off the bad ones
20:32:46 <ais523> so insane programs don't hurt
20:32:51 <elliott> !bfjoust x <
20:32:58 <elliott> !bfjoust x [.]
20:32:59 <EgoBot> Score for elliott_x:
20:33:15 <ais523> haha, the defend programs have fallen miles because of all the stupid programs
20:33:17 <quintopia> You got a !
20:33:22 <quintopia> is a good score i think
20:33:24 <ais523> that they draw with rather than beat
20:33:33 <EgoBot> Score for elliott_x: 8.8
20:33:47 <ais523> !bfjoust attack6 (>)*9+[>[-]+]
20:33:50 <Sgeo> Why is that different from noop?
20:33:58 <quintopia> Sgeo: it uses more cpu
20:34:00 <EgoBot> Score for ais523_attack6: 18.7
20:34:05 <ais523> I should make a defend program that gives up waiting after a while and does a mindbogglingly slow rush or something like that
20:34:20 <quintopia> so it can beat other defends?
20:34:23 <quintopia> and stupids?
20:34:25 <ais523> yep
20:35:12 <ais523> on the basis that the opposing program is a defend or a nop if it still hasn't turned up by cycle 100000 or whatever
20:35:23 <elliott> link to hill?
20:35:39 <ais523> http://codu.org/eso/bfjoust/in_egobot/
20:36:10 <impomatic> ais523: tried giving up waiting this morning but it didn't work too well :-(
20:36:13 <nescience> you should make a defend that pushes out as far as it can to trap for faster winnage
20:36:19 <ais523> impomatic: ?
20:36:27 <ais523> nescience: why would winning faster matter?
20:36:36 <nescience> just for fun!
20:36:50 <nescience> and a slight advantage against programs that beat you
20:36:50 <ais523> you could modify chainmail like that pretty easily, but that isn't mine
20:37:23 <ais523> defend7/9/10 wouldn't benefit from that because they use the preinitialised-to-128 cell for its value of 128
20:37:39 <impomatic> ais523: I had a defend-style program that gave up waiting after a while
20:37:43 <nescience> true enough, but you could fix that
20:37:52 <Sgeo> "Left warrior failed to parse, right warrior wins!"
20:37:59 <Sgeo> !bfjoust error [
20:38:01 <ais523> Sgeo: that's some of the junk interpreted as program programs
20:38:10 <Sgeo> Ah
20:38:24 <ais523> [ isn't a parse failure in egojoust, but a nop
20:38:37 <EgoBot> Score for Sgeo_error: 8.1
20:39:07 <Gregor> !bfjoust mind_bogglingly_slow_rush_with_benefits (>)*8-[[+>(+)*128..>(-)*128..-]+]
20:39:18 <EgoBot> Score for Gregor_mind_bogglingly_slow_rush_with_benefits: 27.6
20:39:37 <ais523> Gregor: glad to see you making serious programs
20:39:45 <Deewiant> What's the hill's maximum size now?
20:39:48 <ais523> impomatic: hmm, what about resubmitting shortsword?
20:39:56 <ais523> Deewiant: not stated, but I'm guessing 50
20:40:11 <Gregor> ais523: I can only be bitter about FYB for so long :P
20:40:26 <ais523> $ cat impomatic_shortsword.bj (>++>--)*2(>)*6([-[+]]>)*20
20:40:57 <ais523> (I deleted a newline)
20:41:05 <elliott> <ais523> Sgeo: that's some of the junk interpreted as program programs
20:41:07 <Deewiant> !bfjoust sloth (+)*12((++-)*1024-(--+)*1024)*100(>)*8+([>[-]+])*100
20:41:07 <elliott> program programs?
20:41:18 <Gregor> "junk-interpreted-as-program programs"
20:41:24 <impomatic> !bfjoust shortsword (>++>--)*2(>)*6([-[+]]>)*20
20:41:24 <ais523> elliott: some of the (junk interpreted as program) programs
20:41:31 <elliott> ah
20:41:38 <ais523> impomatic: hmm, was that the first offset clear ever?
20:41:41 <quintopia> ais523: so you'd use ([)*100000 instead of [] as a tripwire?
20:41:50 <Sgeo> !bfjoust nonstop_attack >+[[>+][-]+]
20:41:50 <ais523> quintopia: pretty much
20:41:52 <Deewiant> !bfjoust train2 (>(-)*10)*4(>(+)*10)*4>>+([[-][-]>+])*27
20:41:53 <EgoBot> Score for Deewiant_sloth: 20.6
20:42:00 <ais523> you need to duplicate the bit inside the brackets 100000 times too, though
20:42:04 <ais523> which might annoy the interp
20:42:16 <quintopia> yeah
20:42:32 <ais523> limiting the square bracket nesting depth sounds like it may be a good way to avoid non-BF-like abuses
20:42:34 <ais523> perhaps to 16 or so
20:42:52 <EgoBot> Score for Deewiant_train2: 23.3
20:42:52 <EgoBot> Score for Sgeo_nonstop_attack: 2.3
20:42:53 <EgoBot> Score for impomatic_shortsword: 34.5
20:43:16 <impomatic> ais523: not sure... apparently it was top of the hill with 100% wins on 22 May 2009 though :-)
20:43:29 <Sgeo> Did my program at least do what I intended it to do, even if it was a bad idea?
20:43:54 <quintopia> Sgeo: looks like a suicide to me
20:44:02 <ais523> Sgeo: I doubt it, the [>+] looks very dubious
20:44:04 <elliott> Deewiant: At least I pass Mycology!
20:44:10 * elliott is regretting this code overhaul
20:44:14 <ais523> you basically have to hit a -1 valued decoy to avoid suiciding
20:44:18 <Deewiant> elliott: What, did you do concurrency?
20:44:18 <quintopia> ^
20:44:19 <Sgeo> ooh
20:44:25 <elliott> Deewiant: No.
20:44:26 <Deewiant> DIDN'T THINK SO
20:44:29 <Gregor> !bfjoust glacially_slow_rush (>->+)*4-[[+>(+)*128..>(-)*128..-]+]
20:44:37 <elliott> Deewiant: I tried to move everything over to data-accessor and it's turning into a great big gob of mud.
20:44:42 <Sgeo> What I wanted was to keep going and assume everything's a decoy
20:44:44 <Sgeo> :/
20:44:46 <elliott> Deewiant: Solution: DON'T CLEAN UP UNTIL IT PASSES MYCOLOGY ENTIRELY
20:44:52 <ais523> elliott: you have a backup from before, though, right?
20:44:56 <elliott> ais523: thankfully, yes.
20:45:10 <Sgeo> What about version control
20:45:24 <elliott> Sgeo: What, do you have a scapegoat implementation?
20:45:34 <Sgeo> What?
20:45:36 <Sgeo> Oh
20:45:40 <elliott> No? Then I'm not interested.
20:45:45 <ais523> elliott: you know you can use other VCSes until sg is finished, right?
20:45:53 <elliott> ais523: But they're all irritating.
20:45:58 <ais523> indeed
20:46:00 <Sgeo> You... won't use Version Control unless it's God's own version control? (Where you're God, apparently)
20:46:06 <elliott> Deewiant: So is t totally easy?
20:46:09 <elliott> Sgeo: *ais523's God
20:46:13 <ais523> Sgeo: hey, /I/ invented sg, elliott just thought it was a good idea
20:46:18 <Sgeo> oh, sorry
20:46:18 <ais523> but I don't consider myself God as a result
20:46:26 <Deewiant> Not "totally" the way stuff like + is
20:46:32 <Gregor> (elliott does though)
20:46:39 <Deewiant> (I'd've said v but you managed to get that wrong)
20:46:44 <Gregor> And I'm still mad that your data dir isn't .(unicode goat)
20:46:45 <elliott> [[Creating additional IP's is done with the t "Split" instruction, available in Concurrent Funge-98 only. It causes the current IP to be duplicated, and this duplicate is added to the IP list such that it is executed for the first time before the parent IP is next executed.]]
20:46:48 <elliott> Deewiant: :-D
20:47:05 <elliott> [[When a child IP is borne unto Funge-Space thus, its location, storage offset, and stack are all copied verbatim from the parent IP's. The child IP's delta is reversed (a la r) from its parent's, though.]]
20:47:11 <elliott> Deewiant: It actually advances when created, right?
20:47:15 <ais523> elliott: err, no
20:47:20 <ais523> although everyone interprets it as yes
20:47:39 <ais523> it is actually possible to use non-advancing t without a forkbomb loop, though, although difficult
20:47:42 <impomatic> !bfjoust why_is_this_broken http://pastebin.com/raw.php?i=nq4khGar
20:47:47 <Deewiant> !bfjoust draw >+[]<[+]
20:47:51 <Deewiant> !bfjoust farmhand (+-)*25000(-+)*25000
20:48:07 <elliott> ais523: I'm asking for the common interpretation.
20:48:12 <ais523> impomatic: wow, that's weird; also, [>>]?
20:48:13 <Gregor> Oh nose
20:48:23 <ais523> elliott: it's commonly interpreted as advancing, even though the spec doesn't say that
20:49:00 <elliott> Deewiant: Hmm, is having a "current IP" state sane, or would you pass the IP around everywhere?
20:49:16 <ais523> elliott: the IP list should be a queue
20:49:21 <ais523> and the current IP would be the head of the queue
20:49:22 <quintopia> why is report empty?
20:49:31 <ais523> quintopia: because it's currently running programs
20:49:37 <elliott> ais523: err, I don't see why I should mutate the IP list all the time
20:49:38 <ais523> it only generates when the running programs have finished
20:49:43 <EgoBot> Score for Gregor_glacially_slow_rush: 3.9
20:49:43 <EgoBot> Score for Deewiant_draw: 4.2
20:49:54 <EgoBot> Score for impomatic_why_is_this_broken: 0.4
20:49:55 <ais523> elliott: semantics, I suppose
20:49:58 <EgoBot> Score for Deewiant_farmhand: 9.1
20:50:01 <nescience> !bfjoust test >+>->>>>>>>((-)*384(+)*384)*21
20:50:08 <quintopia> the report generator runs programs...it could wait til it has a new report to clear the old report, couldn't it?
20:50:13 <elliott> ais523: for instance
20:50:22 <impomatic> ais523: it suppose to have 4 cells, zero / count / watch / zero. If decrements count and watches watch and attack when either reaches zero.
20:50:24 <elliott> 1 cell containing a unique ID for the current IP (ip)
20:50:25 <elliott> Only significant for Concurrent Funge. This ID differentiates this IP from all others currently in the IP list.
20:50:29 <elliott> ais523: that would always be 0, if i did it that way
20:50:40 <elliott> ais523: which would make it useless
20:50:50 <impomatic> ais523: dumb idea though :-)
20:50:55 <EgoBot> Score for nescience_test: 1.8
20:51:00 <nescience> lol
20:51:18 <ais523> impomatic: it has merit, but probably not implemented that way
20:51:23 <nescience> !bfjoust test >+>->>>>>>>((-)*384)*21
20:51:29 <nescience> oh crap
20:51:32 <ais523> haha
20:51:33 <nescience> I forgot >
20:51:36 <nescience> no wonder
20:51:40 <Deewiant> elliott: Please don't use list indices: even though it's not specced as such, everybody expects that old IDs don't change when you start a new thread with t :-P
20:51:43 <impomatic> ais523: reimplementing :-)
20:51:46 <nescience> !bfjoust test >+>->>>>>>>(>(-)*384(+)*384)*21
20:51:57 <nescience> also hey, distributed processing guise
20:52:02 <nescience> I'll donate cycles
20:52:06 <EgoBot> Score for nescience_test: 4.3
20:52:06 <EgoBot> Score for nescience_test: 4.3
20:53:23 -!- elliott_ has joined.
20:53:30 <elliott_> <Deewiant> elliott: Please don't use list indices: even though it's not specced as such, everybody expects that old IDs don't change when you start a new thread with t :-P
20:53:35 <elliott_> <elliott> Deewiant: Right
20:53:37 <elliott_> <elliott> So ais523's idea won't work.
20:53:39 <elliott_> <elliott> Deewiant: I'll probably just use list indices and do (length list - index).
20:53:52 <ais523> !bfjoust I_thought_the_scoreboard_had_more_programs_earlier >>>>>>>>(>[>[-]])*21
20:54:02 <EgoBot> Score for ais523_I_thought_the_scoreboard_had_more_programs_earlier: 7.9
20:54:03 <ais523> elliott_: would a thread be removed from the list when it executed @?
20:54:11 <Deewiant> elliott: I don't see how that'll work
20:54:32 <Deewiant> elliott: And ais523's idea works fine if you store the ID in the IP, which is kind of what I hinted at
20:54:35 <nescience> !bfjoust test >+>->>>>>>>(>(-)*384)*21
20:54:39 <elliott_> Deewiant: Oh, fine.
20:54:44 <elliott_> @hoogle Queue
20:54:45 <lambdabot> module Data.Graph.Inductive.Internal.Queue
20:54:45 <lambdabot> Data.Graph.Inductive.Internal.Queue data Queue a
20:54:45 <lambdabot> Data.Graph.Inductive.Internal.Queue queueEmpty :: Queue a -> Bool
20:54:48 <elliott_> >_<
20:54:54 <EgoBot> Score for nescience_test: 1.4
20:54:56 <elliott_> I'LL USE A LIST
20:54:59 <Deewiant> elliott_: Zippers
20:55:02 <nescience> worser lol
20:55:10 <nescience> !bfjoust test <
20:55:15 <elliott_> Deewiant: Wouldn't a list work? Well, I guess I'd need to append every tick, which would be slow.
20:55:18 <nescience> should just be syntax for kill
20:55:19 <oerjan> elliott_: Seq is nice for queues
20:55:30 <elliott_> Deewiant: I'm still vaguely scared of zippers though, although I know they're the derivatives of types.
20:55:34 <ais523> ais523_I_thought_the_scoreboard_had_more_programs_earlier.bfjoust vs nescience_shade.bfjoust: ><<<<<<<<<<<<<<<<<<<> ><<<>>>>>>>>>>>XX<<<> ><<<>>>>>>>>>>>XX<<<> ><<<<<<<<<<<<<<<<<<<>
20:55:34 <Deewiant> It'd work, a zipper just seems natural for something you move through
20:55:40 <ais523> that's nicely polarity-dependent
20:55:42 <elliott_> oerjan: seq from where?
20:55:47 <EgoBot> Score for nescience_test: 0.0
20:55:52 <Deewiant> elliott_: Data.Sequence
20:55:53 <oerjan> @hoogle Seq
20:55:53 <lambdabot> Data.Sequence data Seq a
20:55:53 <lambdabot> Prelude seq :: a -> b -> b
20:55:53 <lambdabot> Control.Parallel.Strategies seqArr :: Ix b => Strategy a -> Strategy (Array b a)
20:56:00 -!- elliott has quit (Ping timeout: 250 seconds).
20:56:19 <ais523> Gregor: scoreboard's at 45?
20:56:33 <quintopia> !bfjoust hmm (>[>>>>>>>>(-)*128])*22
20:57:06 <ais523> quintopia: that's... an 8-cell tripwire
20:57:14 <EgoBot> Score for quintopia_hmm: 4.0
20:57:36 -!- sebbu2 has changed nick to sebbu.
20:58:02 <cheater00> http://www.asciiartfarts.com/20110115.html
20:58:31 <quintopia> ais523: i was hoping it would beat wiggle3, but i must have missed something that one does
20:58:58 <Sgeo> Gah, Google is useless for grepping #esoteric logs
20:59:01 * Sgeo angers
20:59:10 <elliott_> hg clone ...
20:59:15 <elliott_> grep 'foo' *
20:59:35 <quintopia> wget works too :P
20:59:49 <Sgeo> Oh, site:codu.org works
20:59:56 <Sgeo> Instead of tunes.org
20:59:58 <elliott_> >_<
20:59:58 * Sgeo is lazy
21:00:33 <elliott_> Deewiant: What's a list zipper again?
21:00:38 <elliott_> a * [a] * [a]?
21:01:07 <Deewiant> Yes, typically ([a],a,[a])
21:02:16 <oerjan> Sgeo: yeah robots.txt has a Disallow: /~nef/logs/
21:02:21 <elliott_> Hmm, so I need "further :: ([a],a,[a]) -> ([a],a,[a])".
21:02:24 <elliott_> It needs to be cyclic, right?
21:02:49 <Sgeo> That's bizarre, especially considering I got some #haskell logs
21:03:01 <Deewiant> elliott_: If you create it using cycle you just need [a], don't you
21:03:03 <Sgeo> http://www.google.com/search?rlz=1C1TSND_enUS401US401&sourceid=chrome&ie=UTF-8&q=Atomo+site:tunes.org
21:03:07 <oerjan> yeah there are some occasional instances...
21:03:10 <Sgeo> Well, bbl
21:03:11 <elliott_> Deewiant: Don't I need to know the current number of IPs for something?
21:03:19 <Deewiant> Can't you store that separately? :-P
21:03:20 <ais523> !bfjoust slightly_less_stupid_defender_clearer [>[-.]+]
21:03:27 <elliott_> Deewiant: :/
21:03:32 <EgoBot> Score for ais523_slightly_less_stupid_defender_clearer: 26.8
21:03:32 <elliott_> Deewiant: That seems a bit ugly.
21:04:20 <elliott_> oerjan: What was that about Seq? :-P
21:05:32 -!- myndzi\ has changed nick to myndzi.
21:05:42 <myndzi> right so how do i get this version control stuff on windows
21:05:47 <oerjan> elliott_: Seq is a slightly restricted finger tree structure, constant whatchamacallit time appending at both ends
21:05:50 <elliott_> myndzi: Step one, install Linux.
21:05:52 <elliott_> Sorry.
21:05:55 <elliott_> I'm such a troll.
21:05:58 <myndzi> ,,|,_
21:06:05 <myndzi> :P
21:06:09 <elliott_> Step two, http://mercurial.selenic.com/
21:06:11 <myndzi> i know it works because it's on my oldass laptop
21:06:11 <elliott_> Step three, http://mercurial.selenic.com/
21:06:13 <elliott_> Step four, http://mercurial.selenic.com/
21:06:15 <elliott_> Step five, http://mercurial.selenic.com/
21:06:24 <oerjan> (it doesn't support FingerTree's general Monoid indexing
21:06:33 <elliott_> oerjan: hm can i do a cyclic queue with it :-P
21:06:45 <myndzi> the next question is going to be, "how do i download everything"
21:07:00 <oerjan> elliott_: um a cyclic queue is just appending after you pop off the beginning...
21:07:05 <oerjan> so sure
21:07:07 <impomatic> !bfjoust broken http://pastebin.com/raw.php?i=XVZqenNB
21:07:09 <elliott_> myndzi: hg clone someurliforgot-askgregor
21:07:09 <myndzi> and/or browse it
21:07:11 <elliott_> oerjan: well yeah
21:07:14 <myndzi> mk
21:07:15 <EgoBot> Score for impomatic_broken: 2.3
21:07:50 <ais523> Gregor: look at the line numbered 37 at the bottom on the scoreboard
21:07:56 <ais523> it has "nothing changed" in the middle of it
21:08:38 <myndzi> oh hey it looks like i already had it
21:08:41 <myndzi> i thought i only did it on my laptop
21:08:43 -!- Sgeo has quit (Ping timeout: 255 seconds).
21:08:48 <impomatic> !bfjoust broken http://pastebin.com/raw.php?i=vkwD6XRB
21:08:58 <EgoBot> Score for impomatic_broken: 2.3
21:09:15 <myndzi> !bfjoust keke2 ->>>>>>>>>(>[(-.+(-.)*256(+.)*256>)*20])*20
21:09:23 <EgoBot> Score for myndzi_keke2: 29.5
21:09:41 <myndzi> !bfjoust allornothing >>(+)*19>(-)*19>>>>>>>>>>>(>(-)*127-.-.)*21
21:09:48 <elliott_> oerjan: hm i don't actually see a simple way to pop off a Seq
21:09:49 <elliott_> oh wiat
21:09:50 <EgoBot> Score for myndzi_allornothing: 12.5
21:09:51 <elliott_> *wait
21:09:53 <elliott_> do you use viewl/viewr?
21:09:55 <ais523> myndzi: is that a deliberate minlength overshoot?
21:09:58 <oerjan> elliott_: yep
21:10:07 <myndzi> ais523: the second? yeah
21:10:11 <elliott_> oerjan: er, but how do you turn the view back
21:10:19 <myndzi> you don't need to win the smallest ones to win, it was supposed to be faster this way
21:10:30 <ais523> indeed
21:10:34 <ais523> and that used to be a valid strategy
21:10:40 <ais523> nowadays, it mostly seems to hurt rather than help
21:10:42 <myndzi> yeah, i'm just seeing how some old ones perform
21:10:45 <ais523> yep
21:10:49 <myndzi> also putting stuff on the hill
21:10:52 <myndzi> now how do i get at the archives
21:10:58 <myndzi> what's the hg url
21:11:04 <myndzi> and how do i like, search for stuff lol
21:11:10 <ais523> it's fun seeing my defend programs rise back through the ranking, anyway
21:11:13 <elliott_> myndzi: um when you check it out it just becomes a directory
21:11:17 <ais523> also, VCs aren't designed to be particularly searchable
21:11:22 <elliott_> you can specify a certain revision if you want
21:11:25 <elliott_> hg log might come in handy
21:11:25 <ais523> *VCSes
21:11:33 <elliott_> myndzi: the url is just the directory with all the warriors in
21:11:39 <myndzi> in_egobot
21:11:48 <oerjan> elliott_: <| and |>
21:11:57 <impomatic> !bfjoust broken http://pastebin.com/raw.php?i=Up0gHB7U
21:12:07 <EgoBot> Score for impomatic_broken: 2.2
21:12:07 <elliott_> oerjan: hmm
21:12:13 <impomatic> :-(
21:12:17 <ais523> !bfjoust death_to_no_ops (>)*8(>(-.)*256)*21
21:12:24 <elliott_> oerjan: i think i'm getting headache-clouded again >_<
21:12:29 <elliott_> hmmm
21:12:33 <myndzi> oshi, i just deltreed all the old stuff
21:12:36 <myndzi> but i can get it again i guess
21:12:37 <oerjan> elliott_: you probably don't want to turn back the _same_ view...
21:13:02 <impomatic> !bfjoust broken http://pastebin.com/raw.php?i=CxAYXwkA
21:14:04 <elliott_> oerjan: maybe figuring out how to do this as a zipper would be less confusing ;D
21:14:11 <myndzi> why is the command called 'hg' if the software is called mercurial anyway
21:14:18 <ais523> chemical symbol for mercury
21:14:19 <oerjan> elliott_: lessee you could do something like rotate s = case viewl s of a :< r -> r |> a
21:14:28 <myndzi> oh right
21:14:32 <myndzi> i feel like i lost nerd points there
21:14:32 <myndzi> :P
21:14:36 <quintopia> !bfjoust flyingleap >(+)*40>->+(>[(>)*6(+)*3[-]>(-)*3[+]>[(-)*128[-]>+])*20
21:14:44 <elliott_> oerjan: rotate s | a :< r <- viewl s -> r |> a
21:14:45 <oerjan> pops off left, appends to right
21:14:47 <elliott_> oerjan: CONFUSION SET TO MAXIMUM
21:15:04 -!- iconmaster has joined.
21:15:06 <elliott_> oerjan: shouldn't it pop off right, append to left, i generally think of movement as going left to right :D
21:15:44 <oerjan> elliott_: well you'd be running the leftmost IP next wouldn't you? so you'd pop that off.
21:15:59 <impomatic> !bfjoust sicilian_defence http://pastebin.com/raw.php?i=2eubcLyw
21:16:11 <elliott_> oerjan: surely i'd run the ip just to the right
21:16:20 <elliott_> and then at the end go back to the leftmost ip
21:16:24 <elliott_> [a,b,c,d] -> a b c d a b c d ...
21:16:42 * iconmaster has came up with around 5,000 commands for Onecode! Yay repition.
21:16:46 <myndzi> impomatic: why do you use +.
21:16:48 <oerjan> elliott_: um the point is after you run a, the new list will be [b, c, d, a]
21:16:58 <elliott_> oerjan: right
21:17:01 <elliott_> and?
21:17:14 <oerjan> to do that you pop a off the left and append it to the right.
21:17:14 <ais523> myndzi: ++ wouldn't leave the flag at 0 for two cycles
21:17:21 <myndzi> it has to be two cycles?
21:17:29 <myndzi> i totally forgot that
21:17:34 <ais523> yep
21:17:37 <myndzi> or else it changed and i didn't know
21:17:37 <myndzi> haha
21:17:44 <impomatic> myndzi: where, in the first line or the others?
21:17:49 <myndzi> the others
21:17:54 <myndzi> ais answered my question though
21:17:58 <ais523> impomatic: how does that differ from chainmail? use of the flag rather than a separate cell for locking?
21:18:00 <elliott_> oerjan: hm right
21:18:17 <elliott_> oerjan: but, otoh, I rarely want to pop
21:18:24 <elliott_> oerjan: usually I'd just want to look at the current one, and then at the end rotate it
21:19:01 <impomatic> ais523: yes, that's all. Just checking I haven't broken something (I'm still trying to limit the time it waits)
21:19:38 <ais523> impomatic: it loses to NOPs and to defence programs
21:19:40 <ais523> so it seems broken
21:20:20 <EgoBot> Score for ais523_death_to_no_ops: 16.9
21:20:20 <EgoBot> Score for impomatic_broken: 2.1
21:20:31 <elliott_> oerjan: so what's "head" on a seq?
21:20:32 <EgoBot> Score for impomatic_sicilian_defence: 0.0
21:20:32 <EgoBot> Score for quintopia_flyingleap: 1.1
21:20:49 <elliott_> headS s | a Seq.:< _ <- Seq.viewl s = a?
21:21:18 <oerjan> elliott_: the a in a :< r ?
21:21:27 <elliott_> oerjan: so (headS s | a Seq.:< _ <- Seq.viewl s = a)
21:21:49 -!- iconmaster has quit (Quit: Rooms • iPhone IRC Client • http://www.roomsapp.mobi).
21:22:08 -!- iconmaster has joined.
21:22:11 <oerjan> yeah
21:22:52 <quintopia> aw the scoreboard got cut off?
21:23:15 <oerjan> elliott_: mind you i don't know whether a zipper (i.e. two lists) would be less efficient in practice. it does have the need to reverse everything each time you get to the end...
21:23:29 -!- iconmaster has quit (Client Quit).
21:23:48 <elliott_> modifyCurrentIP :: (IP -> IP) -> Shiro ()
21:23:49 <elliott_> modifyCurrentIP f = modify $ \st ->
21:23:49 <elliott_> case Seq.viewl (ips st) of
21:23:49 <elliott_> ip Seq.:< ips -> st{ ips = f ip Seq.|> ips }
21:23:49 <elliott_> "yikes"
21:23:49 <oerjan> but fingertrees are probably pretty heavyweight
21:23:58 <elliott_> they are?
21:24:21 <elliott_> "the Yi text editor specializes finger trees to finger strings for efficient storage of buffer text"
21:24:24 <elliott_> oerjan: can't be that heavy-weight :-D
21:24:34 <ais523> quintopia: myndzi's spamming test programs in PM
21:24:45 <oerjan> elliott_: well heavier than lists
21:24:51 <impomatic> !bfjoust sicilian_defence http://pastebin.com/raw.php?i=HHuDwWmq
21:24:53 <elliott_> data FingerTree a
21:24:54 <elliott_> = Empty
21:24:54 <elliott_> | Single a
21:24:54 <elliott_> | Deep {-# UNPACK #-} !Int !(Digit a) (FingerTree (Node a)) !(Digit a)
21:24:59 <elliott_> oerjan: doesn't seem excessively heavy at least
21:24:59 <EgoBot> Score for impomatic_sicilian_defence: 0.0
21:25:07 <myndzi> yeah, i should just get the local EXE or something
21:25:08 <quintopia> ais523: i want to know if flyingleap beat wiggle3 ever.
21:25:14 <elliott_> viewl:: Seq a -> ViewL a
21:25:14 <elliott_> viewl (Seq xs)= case viewLTree xs of
21:25:14 <elliott_> Nothing2 -> EmptyL
21:25:14 <elliott_> Just2 (Elem x) xs' -> x :< Seq xs'
21:25:29 <elliott_> (|>):: Seq a -> a -> Seq a
21:25:29 <elliott_> Seq xs |> x= Seq (xs `snocTree` Elem x)
21:25:33 <elliott_> oerjan: viewl and (|>) look simple enough
21:25:58 <Gregor> Nobody's commented on how awesome my new concise report format is :(
21:26:06 <ais523> Gregor: I noticed, it's awesome
21:26:16 <ais523> impomatic: sicilian defence seems to be suiciding, but I can't see why
21:26:31 <elliott_> link?
21:26:50 -!- myndzi has changed nick to myndzi\.
21:27:13 <ais523> http://codu.org/eso/bfjoust/in_egobot/report.txt
21:27:24 <myndzi\> ah sorry i may have overwritten that
21:27:36 <myndzi\> i thought i already nuke this one off but had to retry
21:27:38 -!- myndzi\ has changed nick to myndzi.
21:29:09 <elliott_> modifyCurrentIP :: (IP -> IP) -> Shiro ()
21:29:09 <elliott_> modifyCurrentIP f = modifyIPs $ \is ->
21:29:09 <elliott_> case Seq.viewl is of
21:29:09 <elliott_> ip Seq.:< is' -> is' Seq.|> f ip
21:29:15 <elliott_> oerjan: is that correct? it's suspiciously close to your "rotate"
21:29:54 <oerjan> elliott_: well you'd always want to rotate after you've finished with an IP
21:30:16 <elliott_> oerjan: modifyCurrentIP can happen without the IP's tick finishing...
21:30:30 <elliott_> oerjan: is it impossible to just change the head of this queue?
21:30:32 <elliott_> without rotating?
21:30:43 <oerjan> elliott_: of course not, use <| instead
21:30:56 <elliott_> oerjan: what do you mean?
21:31:16 <oerjan> ip Seq.:< is' -> f ip Seq.<| is'
21:31:55 <elliott_> oerjan: how slow's that :P
21:32:12 <oerjan> elliott_: should be about the same as rotating?
21:32:26 <elliott_> oerjan: okay
21:32:39 <elliott_> oerjan: ideally i would process the ip and rotate simultaneously right?
21:32:45 <oerjan> yeah
21:32:51 <quintopia> !bfjoust antiwiggle3 (.)*48(>[>>>>>>>>(-)*128])*22
21:32:55 <elliott_> oerjan: that's not really possible with my code
21:33:13 <EgoBot> Score for quintopia_antiwiggle3: 13.6
21:33:32 <oerjan> elliott_: well there's nothing preventing you from popping the ip, doing whatever it needs to do, and then appending afterwards.
21:33:49 <elliott_> oerjan: who says i pop :)
21:33:56 <quintopia> wow...it didn't work :P
21:34:32 <oerjan> elliott_: well since the view work such that if you even _look_ at the head, you also get the tail, it seems inefficient not to remember the tail...
21:34:36 <quintopia> ais523: TELL ME WHY IT DIDN'T WORKED
21:34:38 <oerjan> *works
21:34:42 <Gregor> Darn, my mind-bogglingly slow rushes have been pushed back down by legit programs :P
21:34:49 <elliott_> oerjan: yeah, but my code is not structured like this at all
21:35:29 <impomatic> !bfjoust sicilian_defence http://pastebin.com/raw.php?i=jKHD8KvG
21:35:51 <elliott_> Deewiant: Does one space take a tick in stringmode?
21:35:55 <myndzi> ok i am reading the help but having trouble.. how do i just, like, search for files that have existed with a matching file name through all revisions?
21:36:03 <ais523> quintopia: wiggle3 leaves a trail behind as it moves
21:36:06 <Deewiant> elliott_: Yes
21:36:20 <elliott_> Deewiant: >_<
21:36:22 <ais523> so you need to ignore cells with value + or - 1
21:36:24 <elliott_> Deewiant: Wrong answer, man :P
21:36:40 <Deewiant> elliott_: This kind of twiddling is the main reason why t is not so simple :-)
21:37:14 <ais523> !bfjoust antiwiggle3 (.)*48(>[+[--[>>>>>>>>(-)*128]]])*21
21:37:19 <oerjan> elliott_: hm you _could_ store the queue in left view form, then you would always have quick access to the ip and could change it in the same form. then rotate would be a separate thing.
21:37:35 <elliott_> oerjan: wouldn't that essentially be the zipper solutio
21:37:36 <elliott_> n
21:37:44 <oerjan> no
21:38:07 <quintopia> ais523: oh, i missed that stupid + at the end of the decoy search :/
21:38:25 <elliott_> Deewiant: OK, I'll have to make toNextIns behave differently with string mode.
21:38:31 <oerjan> elliott_: rotate (ip :< is') = viewl (is' |> ip)
21:38:32 <ais523> also, egobot seems to have run one program then stopped
21:38:33 <ais523> which is weird
21:38:40 <elliott_> Deewiant: A space counts as an instruction, *unless* the previous instruction (delta-wise) is also a space.
21:38:45 <ais523> !bfjoust suicide <
21:39:00 <ais523> again, one program then stopped
21:39:02 <ais523> something seems broken
21:39:06 <quintopia> !bfjoust antiwiggle3 (.)*48(>[-[>>>>>>>>(-)*128]])*22
21:39:52 <ais523> Gregor: I think we broke EgoBot
21:39:59 <quintopia> D:
21:40:00 <Gregor> IMPOSSIBLE
21:40:15 <oerjan> elliott_: and then just modifyCurrentIP f = modifyIPs $ \(ip :< is') -> f ip :< is'
21:40:20 <Gregor> top reports that egojoust is running
21:40:35 <ais523> breakdown.txt doesn't
21:40:37 <Gregor> `run ps aux | grep ego
21:40:43 <ais523> and it normally updates quite quickly while egojoust is running
21:40:45 <Gregor> That wasn't smart :P
21:40:58 <ais523> sandboxed, surely?
21:41:04 <Gregor> ps isn't.
21:41:08 <oerjan> elliott_: well i guess it's a _tiny_ bit of zipping, just one element
21:41:10 <HackEgo> 5000 7247 0.0 0.0 3776 164 ? TN Feb07 0:00 ../report ../egojoust ../cache Deewiant_monorail.bfjoust Lymia_evo_1.bfjoust Patashu_rushpolarity.bfjoust Vorpal_shudder.bfjoust ais523_defend7.bfjoust ais523_large_decoy_attack.bfjoust ais523_stupid_defender_clearer.bfjoust ais523_tripstridewire.bfjoust
21:41:22 <elliott_> oerjan: do I even need finger trees at that point? :P
21:41:27 <Deewiant> Feb07?
21:41:38 <quintopia> !bf ++++++++>++++++<[>[>+>+<<-]>>[<<+>>-]<-].
21:42:10 <Gregor> Yes, the system seems overloaded, so let's throw more shit at it.
21:42:27 <ais523> I'm wondering if it's stuck in a loop or a quadratic algo or something
21:42:36 <quintopia> well, just checking whether it's ego or just the bf joust interp
21:42:44 * impomatic didn't break it!
21:43:30 <myndzi> i just want to search for old programs :(
21:43:34 <myndzi> why is it so hard
21:43:41 <myndzi> fu hg
21:43:43 <oerjan> elliott_: um the finger trees are to get the efficient appending of an element at the end
21:44:07 <elliott_> oerjan: I think I might just use a zipper until Deewiant adds tenbillionthreads.b98 to Fungicide
21:44:10 <elliott_> Or is that what fork.b98 is?
21:44:11 <ais523> Gregor: running a suicide program like mine or yours causes it to go almost instantly, and then get stuck
21:44:16 <Deewiant> Yes, that's what it is :-)
21:44:17 <ais523> `run ps aux | grep ego
21:44:18 <HackEgo> 5000 8915 0.0 0.0 9500 184 ? S Jan20 0:00 /bin/bash ./egobot \ 5000 15704 0.0 0.0 45960 980 ? S 20:10 0:00 su - egobot \ 5000 20832 0.0 0.0 33884 556 ? S Feb06 0:01 socat TCP4:irc.freenode.net:6667 EXEC:./multibot EgoBot egobot egobot.log \ 5000 20834 0.0 0.0
21:44:26 <elliott_> Deewiant: How many threads? :P
21:44:38 <Deewiant> I think 64K at most
21:44:41 <Deewiant> Can't remember
21:44:45 <Deewiant> See the web page :-P
21:45:12 <Gregor> Unfortunately I can't check what's going on right now as I've gotta go >_>
21:45:42 <elliott_> oerjan: *Main> let foo = replicate 64 0
21:45:43 <elliott_> *Main> foldr seq () (reverse foo)
21:45:43 <elliott_> ()
21:45:44 <elliott_> oerjan: Ran instantly.
21:45:45 <elliott_> Err.
21:45:50 <elliott_> *Main> let foo = replicate 64000 0
21:45:51 <elliott_> That is.
21:45:53 <elliott_> (Copied the wrong line)
21:46:03 <elliott_> oerjan: tl;dr I'm sure zippers will be fine :P
21:46:52 <oerjan> elliott_: O KAY. if you want a zipper, rotate ([ip], r) = (reverse r, [ip]); rotate ((ip:l), r) = (l, ip:r) . i think.
21:46:56 <ais523> !bfjoust suicide <
21:47:03 <ais523> `run ps aux | grep ego
21:47:04 <HackEgo> 5000 8915 0.0 0.0 9500 184 ? S Jan20 0:00 /bin/bash ./egobot \ 5000 15704 0.0 0.0 45960 980 ? S 20:10 0:00 su - egobot \ 5000 20832 0.0 0.0 33884 556 ? S Feb06 0:01 socat TCP4:irc.freenode.net:6667 EXEC:./multibot EgoBot egobot egobot.log \ 5000 20834 0.0 0.0 14468 332 ?
21:47:08 <elliott_> oerjan: well yes :P
21:47:15 <elliott_> oerjan: erm
21:47:20 <elliott_> oerjan: isn't it [a],a,[a]
21:47:22 <elliott_> not [a],a
21:48:00 <oerjan> elliott_: you don't need to store the ip separately from both lists but ok
21:48:19 <elliott_> oerjan: true.
21:49:58 -!- pikhq_ has joined.
21:50:00 -!- pikhq has quit (Ping timeout: 255 seconds).
21:50:11 <oerjan> elliott_: in fact it becomes more awkward if you split it: rotate (l, ip, []) | (ip':r') <- reverse l = ([ip], ip', r'); rotate (l, ip, ip':r) = (ip:l, ip', r)
21:50:17 * elliott_ wonders what started oerjan saying "O KAY"
21:50:19 <elliott_> oerjan: ew
21:50:43 <oerjan> because you need to extract the head at once
21:51:29 <oerjan> maybe ([], ip', r'++[ip]) is better for the first one
21:52:32 <quintopia> Gregor: give hackego root permissions and we'll gix it while you're gone
21:52:36 <quintopia> *fix
21:52:56 <oerjan> i guess my pair version above has the intuitively wrong order
21:53:13 <ais523> `run ps aux | grep ego
21:53:16 <HackEgo> 5000 1148 0.5 0.1 8908 1244 ? S 22:14 0:00 /bin/bash PRIVMSG/tr_60.cmd PRIVMSG #esoteric `run ps aux | grep ego \ 5000 1173 0.0 0.0 8908 536 ? S 22:14 0:00 /bin/bash PRIVMSG/tr_60.cmd PRIVMSG #esoteric `run ps aux | grep ego \ 5000 1176 0.0 0.0 8912 508 ? S 22:14
21:53:28 <ais523> /something/ is happening, at least
21:53:36 <ais523> those numbres are different
21:53:59 <ais523> `run ps aux | grep ego
21:54:00 <HackEgo> 5000 1496 0.0 0.1 8908 1244 ? S 22:15 0:00 /bin/bash PRIVMSG/tr_60.cmd PRIVMSG #esoteric `run ps aux | grep ego \ 5000 1576 0.0 0.0 8908 536 ? S 22:15 0:00 /bin/bash PRIVMSG/tr_60.cmd PRIVMSG #esoteric `run ps aux | grep ego \ 5000 1580 0.0 0.0 8912 508 ? S 22:15
21:54:05 <impomatic> !bfjoust dragon_variation http://pastebin.com/raw.php?i=GjATANq4
21:54:11 <elliott_> Deewiant: BTW, Mycology takes about 8-9 seconds for me right now, which is mostly spent in reading, i and o testing, and bounds shrinking.
21:54:21 <ais523> oh, the grep is finding itself
21:54:29 <ais523> `run ps aux | grep e\go
21:54:30 <HackEgo> 5000 1653 0.5 0.0 3640 388 ? SN 22:15 0:00 ../../../slox/slox 25 ../report ../egojoust ../cache Deewiant_farmhand.bfjoust Deewiant_maglev.bfjoust Deewiant_monorail.bfjoust Deewiant_sloth.bfjoust Deewiant_steamroller.bfjoust Deewiant_train2.bfjoust Gregor_mind_bogglingly_slow_rush.bfjoust
21:54:31 <elliott_> A pretty respectable speed if you ask me considering I've optimised it exactly twice :P
21:54:36 <Deewiant> elliott_: Now make it 1000x faster and it'll be competitive
21:54:47 -!- nescience has quit (Remote host closed the connection).
21:54:58 <quintopia> so it is running a report
21:55:01 -!- poiuy_qwert has joined.
21:55:09 <quintopia> we just don't know which report :/
21:55:13 <elliott_> Deewiant: Eh, if it took 1/100th of the time, it'd be just about the same as cfunge :P
21:55:18 <impomatic> What's the diagnosis? It ego being slow or broken?
21:55:26 <ais523> I think it's caught in an infinite loop
21:55:28 <ais523> `run ps aux | grep e\go
21:55:28 <Deewiant> elliott_: You have to compare against cfunge without fingerprints, not with
21:55:29 <HackEgo> 5000 1653 0.5 0.0 3640 388 ? SN 22:15 0:00 ../../../slox/slox 25 ../report ../egojoust ../cache Deewiant_farmhand.bfjoust Deewiant_maglev.bfjoust Deewiant_monorail.bfjoust Deewiant_sloth.bfjoust Deewiant_steamroller.bfjoust Deewiant_train2.bfjoust Gregor_mind_bogglingly_slow_rush.bfjoust
21:55:38 <quintopia> i concur with ais523
21:55:40 <elliott_> Deewiant: I was. OK, 0.08 vs 0.03, but come on.
21:55:46 <elliott_> Deewiant: Really I don't expect to go below 1 to 2 seconds on Mycology.
21:55:59 <ais523> `run ps aux | grep e\go | grep -v report
21:56:00 <HackEgo> 5000 1684 14.1 0.7 11984 8216 ? TN 22:15 0:15 ../egojoust Deewiant_farmhand.bfjoust impomatic_dragon_variation.bfjoust \ 1740149 2616 0.0 0.0 4324 904 ? SN 22:17 0:00 grep /bin/grep ego \ 5000 8915 0.0 0.0 9500 184 ? S Jan20 0:00 /bin/bash ./egobot \ 5000 15704
21:56:00 <impomatic> ais523: I'm pretty sure my loop stops just short of infinite. Not guilty!
21:56:02 <elliott_> Deewiant: Because Mycology does nothing intensive, frankly. And reading fungespace takes time unless you cheat.
21:56:06 <elliott_> Deewiant: (with a fixed area, say.)
21:56:11 <Vorpal> <elliott_> Deewiant: Really I don't expect to go below 1 to 2 seconds on Mycology. <-- aha, you don't aim as high as me then
21:56:15 <ais523> impomatic: it's dragon_variation that seems to be the issue
21:56:17 <elliott_> Vorpal: I aim higer.
21:56:19 <elliott_> *higher.
21:56:21 <elliott_> I'm going to beat your ass on Fungicide :P
21:56:24 <ais523> could you replace it with a suicide for the time being
21:56:30 <ais523> to see if it helps?
21:56:34 <Vorpal> elliott_, well right. But that doesn't represent real world use cases
21:56:35 <quintopia> too bad we can't `kill
21:56:35 <Deewiant> elliott_: On my machine cfunge is occasionally below 0.01 :-P
21:56:41 <elliott_> Vorpal: Nor does Mycology.
21:56:43 <elliott_> Vorpal: fungot does.
21:56:44 <fungot> elliott_: basically it fnord and recursively. but i just don't get what call/ cc... :) the drawback of always reminding me of how to bugger the tests to go to the display from the data it works on my machine
21:56:49 <ais523> then at least we'll know where the problem is
21:56:50 <elliott_> fungot's startup time is nearly irrelevant, you might note.
21:56:50 <fungot> elliott_: magic johnson? ( random-integer 2))
21:56:54 <Vorpal> elliott_, and cfunge does decently on fungot iirc
21:56:54 <fungot> Vorpal: hi gnomon :) hi bbls!
21:57:03 <Vorpal> elliott_, anyway the fungicide stuff is outdated for cfunge afaik
21:57:07 <elliott_> Vorpal: But I will beat it. Or at least equalise it.
21:57:12 <elliott_> I don't care, I'm going to beat you anyway :P
21:57:19 <Vorpal> elliott_, sure. why would I care
21:57:27 <Vorpal> oh and yeah, will implement your algorithm tomorrow
21:57:29 <elliott_> Vorpal: Because you'll have to optimise.
21:57:32 <Vorpal> it looks quite interesting
21:57:37 <Vorpal> elliott_, what?
21:57:44 <elliott_> Vorpal: Otherwise I'll have taken your crown!
21:57:44 <Vorpal> elliott_, I'm not competing with you
21:57:49 <elliott_> Suuuure
21:57:50 <impomatic> ais523: oh so you're blaming me! Oh well, I'm used to being in trouble for something... :-)
21:58:00 <elliott_> Hey ais523, what's the name of the best Funge interpreter ever.
21:58:05 <Vorpal> elliott_, no, ccbi2 still beats cfunge due to it's insane stuff with various boxes and such.
21:58:05 <ais523> impomatic: it may be egobot's fault, choking in something in your program
21:58:06 <elliott_> HINT: The answer is Shiro
21:58:08 <impomatic> ais523: http://pastebin.com/raw.php?i=GjATANq4 <- no infinite loops :-P
21:58:16 <Vorpal> elliott_, that is what you have to beat to take the crown.
21:58:21 <Vorpal> elliott_, or even beat jitfunge
21:58:21 <ais523> so think of killing the program as a way of debugging egobot
21:58:23 <elliott_> Vorpal: I don't see what's so interesting about my wrapper, anyway
21:58:29 <elliott_> It's just the loop, made loopless
21:58:41 <Vorpal> elliott_, indeed. But it saves thinking just looking at it :P
21:58:53 <Vorpal> elliott_, you are using BSD license right?
21:58:55 <ais523> impomatic: aha, egobot unrolls repetitions with unmatched [ or ]
21:58:56 <elliott_> Vorpal: tl;dr Obviously, there is a function that will tell us how many iterations the loop will take.
21:58:58 <Vorpal> or is it some other one?
21:59:05 <elliott_> Vorpal: The loop is just the subtraction of delta from the coordinates.
21:59:07 <ais523> which is obviously inefficient, but that's what's killing it, almost certainly
21:59:11 <elliott_> Vorpal: So this is obviously a minus-multiplication.
21:59:13 <elliott_> Done.
21:59:15 <Vorpal> elliott_, yes indeed that function was the key to thus
21:59:16 <Vorpal> this*
21:59:29 <Vorpal> (telling us how many iterations)
21:59:29 <elliott_> Vorpal: The function is public domain or whatever, you can't copyright that algo.
21:59:31 -!- zzo38 has joined.
21:59:33 <ais523> it would be nice if you'd unbreak it...
21:59:37 -!- kar8nga has quit (Remote host closed the connection).
21:59:43 <elliott_> ais523: egobot unrolls %
21:59:48 <quintopia> impomaticccccccccccccccccccccccccccc
21:59:50 <ais523> elliott_: yep, but also ([)*
21:59:54 <Vorpal> ais523, what did he do?
21:59:58 <elliott_> <impomatic> ais523: http://pastebin.com/raw.php?i=GjATANq4 <- no infinite loops :-P
22:00:01 <elliott_> impomatic: View source on that page.
22:00:04 <elliott_> impomatic: It's HTML.
22:00:05 <ais523> Vorpal: submitted a program that's perfectly fine, but that egojoust chokes on
22:00:06 <impomatic> ais523: oh :-( It really is my fault!
22:00:10 <elliott_> impomatic: Your program is starting with <
22:00:13 <elliott_> because of <!DOCTYPE html
22:00:23 <elliott_> impomatic: Use a pastebin that serves as text/plain.
22:00:23 <ais523> impomatic: that explains why all your programs got 0, at least
22:00:26 <elliott_> Because that just won't work X-D
22:00:58 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
22:01:20 -!- MigoMipo has quit (Read error: Connection reset by peer).
22:01:22 <quintopia> but ya, kill it make it better impomatic
22:01:33 <ais523> so given that we know the program will score 0, replacing it with a suicide will just save time
22:01:55 <zzo38> I think sprunge pastebin is serves as plain text (unless a syntax highlighter is specified)
22:02:05 <ais523> it does
22:02:05 <impomatic> !bfjoust dragon_variation <
22:02:09 <ais523> I used it earlier
22:02:13 <Vorpal> `help
22:02:13 <HackEgo> Runs arbitrary code in GNU/Linux. Type "`<command>", or "`run <command>" for full shell commands. "`fetch <URL>" downloads files. Files saved to $PWD are persistent, and $PWD/bin is in $PATH. $PWD is a mercurial repository, "`revert <rev>" can be used to revert to a revision. See http://codu.org/projects/hackbot/fshg/
22:02:20 <impomatic> !bfjoust sicilian_defence <
22:02:33 <zzo38> I know it does because I often use it in that way, to copy a file there and then download it elsewhere using the command-line tools.
22:02:33 <ais523> aha, it's running now
22:02:36 <elliott_> oerjan: modifyIPs :: (([IP],[IP]) -> ([IP],[IP])) -> Shiro ()
22:02:38 <elliott_> oerjan: impressive type
22:02:41 <Vorpal> `run echo a > b; sleep 2; echo c > b;
22:02:41 <Vorpal> `run echo d > b
22:02:42 <HackEgo> No output.
22:02:45 <Vorpal> lets see what that does
22:02:50 <HackEgo> No output.
22:02:54 <Vorpal> `cat b
22:02:58 <HackEgo> d
22:03:07 <quintopia> `rm b
22:03:07 <Vorpal> oh so it doesn't run them side by side
22:03:08 <HackEgo> No output.
22:03:19 <Vorpal> quintopia, since it uses hg to track the file system
22:03:25 <Vorpal> I wanted to see if that gave a collision
22:03:30 <elliott_> oerjan: rotate :: ([a],a) -> ([a],a)
22:03:30 <elliott_> rotate ([ip],r) = (reverse r, [ip])
22:03:31 <elliott_> Occurs check: cannot construct the infinite type: a = [a]
22:03:33 <elliott_> When generalising the type(s) for `rotate'
22:03:39 <ais523> quintopia: ais523_antiwiggle3.bfjoust vs jix_wiggle3.bfjoust: <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<
22:03:42 <Phantom_Hoover> `quote
22:03:42 <Phantom_Hoover> `quote
22:03:42 <Phantom_Hoover> `quote
22:03:48 <HackEgo> 103) <Warrigal> So, I'm inside a bottle which is being carried by a robot.
22:03:49 <HackEgo> 57) <GregorR> ??? <GregorR> Are the cocks actually just implanted dildos? <GregorR> Or are there monster dildos and cocks? <GregorR> Or are both the dildos and cocks monster?
22:03:49 <HackEgo> 290) <ais523> gah, why does lose keep winning?
22:03:59 <quintopia> ais523: and quintopia_antiwiggle3?
22:04:07 <Phantom_Hoover> Gregor, why were you saying that.
22:04:14 <ais523> hasn't processed yet
22:04:17 <Phantom_Hoover> I am trying to think of a context and cannot.
22:04:18 <quintopia> ah
22:04:36 <EgoBot> Score for quintopia_antiwiggle3: 14.4
22:04:36 <EgoBot> Score for impomatic_sicilian_defence: 0.0
22:04:36 <EgoBot> Score for impomatic_sicilian_defence: 0.0
22:04:36 <EgoBot> Score for ais523_suicide: 0.0
22:04:36 <Vorpal> http://codu.org/projects/hackbot/fshg/index.cgi/shortlog/07a7084dc9fc <-- heh the a, b one is missing
22:04:37 <EgoBot> Score for ais523_suicide: 0.0
22:04:37 <EgoBot> Score for impomatic_dragon_variation: 0.0
22:04:37 <quintopia> i don't really think the handling of -1 is necessary
22:04:37 <elliott_> google's logo today scares me
22:04:38 <EgoBot> Score for ais523_antiwiggle3: 18.0
22:04:38 <EgoBot> Score for impomatic_dragon_variation: 0.0
22:04:40 <elliott_> (requires js)
22:04:44 <quintopia> HELLO EGOBOT
22:04:59 <elliott_> <EgoBot> *cough* *splutter* *hack*
22:05:02 <ais523> quintopia: jix_wiggle3.bfjoust vs quintopia_antiwiggle3.bfjoust: >>>>>>>>>>>>>>>>>>>>> >>><<<<<<<<<<<<<<<<<> >>><<<<<<<<<<<<<<<<<> >>>>>>>>>>>>>>>>>>>>> quintopia_antiwiggle3.bfjoust wins
22:05:11 <ais523> not a perfect victory like mine is, but still a victory
22:05:19 <quintopia> interesting
22:05:28 <ais523> because you don't allow for polarity reversal on the decoy
22:05:35 <quintopia> ohhhhhh
22:05:44 <ais523> mine's a modification of yours that does
22:05:49 <quintopia> right, that's how it could be made -1
22:05:56 <elliott_> oerjan your code is WRONGGG
22:06:01 <elliott_> oh
22:06:02 <elliott_> no
22:06:03 <elliott_> my type is wrong
22:06:04 <elliott_> :D
22:06:35 <elliott_> Deewiant: An IP advances at the end of its tick, but only moves to the next instruction at the start of its next tick, right?
22:06:35 <ais523> so now the only problem is the scoreboard getting cut off on line 33
22:06:44 <Vorpal> <Phantom_Hoover> I am trying to think of a context and cannot. <-- you could grep logs. You might not want to.
22:06:48 <ais523> !bfjoust suicide <
22:06:59 <Deewiant> elliott_: Blargh... I forget
22:07:01 <EgoBot> Score for ais523_suicide: 0.0
22:07:07 <elliott_> <Phantom_Hoover> Gregor, why were you saying that. <Phantom_Hoover> I am trying to think of a context and cannot.
22:07:15 -!- nescience has joined.
22:07:26 <elliott_> The context is Gracenotes releasing an illegal copy of a film about monster cock dildos.
22:07:26 <nescience> my phone hates irc I guess
22:07:29 <Vorpal> <ais523> so now the only problem is the scoreboard getting cut off on line 33 <-- why did that happen
22:07:34 <ais523> we'll have to wait for Gregor to fix that, I suppose
22:07:35 <elliott_> Or something :-P
22:07:37 <oerjan> <elliott_> oerjan: rotate :: ([a],a) -> ([a],a) <-- you mean rotate :: ([a],[a]) -> ([a],[a])
22:07:38 <ais523> Vorpal: my guess is some sort of timeout
22:07:43 <ais523> on bytes output, perhaps
22:07:44 <elliott_> oerjan: MAYBE I DO
22:07:53 <Vorpal> ais523, why are there so many?
22:07:56 <elliott_> elliott@elliott-MacBookAir:~/mycology$ ~/Code/shiro/shiro mycology.b98
22:07:57 <elliott_> shiro: Shiro/Monad.hs:81:32-60: Non-exhaustive patterns in lambda
22:08:02 <ais523> Vorpal: the hill was expanded
22:08:07 <Vorpal> ais523, why
22:08:17 <ais523> to make it more interesting, when it fills up with decent programs
22:08:18 <Vorpal> hm
22:08:21 <olsner> elliott_: your patterns aren't exhausted yet! whip them some more
22:08:40 <Vorpal> !bfjoust shudder (++-)*1000000
22:09:06 <quintopia> !bfjoust hmm (.)*48(>[-[++[>>>>>[>(+)*3[-]+]]]])*22
22:09:23 <elliott_> modifyCurrentIP :: (IP -> IP) -> Shiro ()
22:09:24 <elliott_> modifyCurrentIP f = modifyIPs $ \(ip:xs, r) -> (f ip : xs, r)
22:09:31 <elliott_> Somehow, I have ended up with an empty list of IPs.
22:09:34 <Vorpal> ais523, it seems to run too slow
22:09:35 <elliott_> oerjan:
22:09:40 <elliott_> rotate :: ([a],[a]) -> ([a],[a])
22:09:41 <elliott_> rotate ([ip],r) = (reverse r, [ip])
22:09:41 <elliott_> rotate ((ip:xs), r) = (xs, ip:r)
22:09:43 <elliott_> oerjan: when r is empty, this fails
22:09:46 <ais523> Vorpal: it has lots of programs to run against, don't be impatient!
22:09:50 <elliott_> oerjan: consider the case where there's only one IP, ([ip],[])
22:09:52 <Vorpal> ais523, might have to shrink it to avoid combinatorial explosion
22:09:58 <elliott_> oerjan: rotate ([ip],[]) = ([],[ip])
22:10:01 <Vorpal> ais523, yes but I mean this current size of the board is too large
22:10:03 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
22:10:05 <elliott_> oerjan: meaning that you can't take the current ip any more
22:10:07 <Vorpal> ais523, when it comes to speed
22:10:12 <elliott_> oerjan: or am i doin it rong
22:10:15 <oerjan> <elliott_> google's logo today scares me <-- try the handle on the right
22:10:20 <elliott_> oerjan: SCARES
22:10:21 <quintopia> ais523: i don't think it unrolls + and -
22:10:25 <ais523> I think the issue is that the board never shrinks because it's so large that it crashes before cleaning up the old programs
22:10:27 <quintopia> *Vorpal
22:10:47 -!- impomatic has joined.
22:10:49 <quintopia> ais523: that doesn't sound right.
22:11:03 <ais523> quintopia: it's an error, I think
22:11:31 <oerjan> `addquote <elliott_> The context is Gracenotes releasing an illegal copy of a film about monster cock dildos.
22:11:35 <quintopia> ais523: but it should clean up old programs after the crash regardless, if i read the script right
22:11:35 <HackEgo> 300) <elliott_> The context is Gracenotes releasing an illegal copy of a film about monster cock dildos.
22:11:42 <EgoBot> Score for quintopia_hmm: 14.0
22:11:43 <EgoBot> Score for Vorpal_shudder: 23.2
22:11:47 <oerjan> (what do you mean the quote is without context, it's right in there!)
22:11:48 <ais523> quintopia: perhaps
22:11:52 <ais523> it depends on what causes the crash
22:12:11 <ais523> it cleaned up some, at least, and crashed on line 34 this time
22:13:33 <impomatic> !bfjoust sicilian_defence http://www.lichttuete.com/temp/a1.txt
22:13:44 <elliott_> http://www.lichttuete.com/
22:13:47 <elliott_> impomatic turned German overnight.
22:14:02 <Vorpal> <oerjan> <elliott_> google's logo today scares me <-- try the handle on the right <-- it's cool
22:14:08 <elliott_> lol german is such a funny language, maybe it's just because i'm pronouncing that page in a nazi voice
22:14:15 <oerjan> elliott_: i didn't think of that. try rotate ([ip],r) = (reverse r++[ip], []) instead
22:14:16 <Phantom_Hoover> `quote 75
22:14:21 <elliott_> LICHTTÜTEN VERLEIHEN JEDEM *ABEND*!!!!
22:14:32 <Vorpal> but dude, how much time did they spend on it
22:14:34 <quintopia> so hmm does beat wiggle3 and almost nothing else. needs more decoys ...
22:14:58 <Phantom_Hoover> elliott_, German is the funniest language ever.
22:15:01 <elliott_> Deewiant: UNDEF: the empty string wrapped around the edge of space is empty
22:15:05 <elliott_> Deewiant: I'm unique.
22:15:08 <quintopia> !bfjoust hmm >(+)*23(-)*24(>[-[++[>>>>>[>(+)*3[-]+]]]])*22
22:15:16 <elliott_> Deewiant: Actually that's probably a bug isn't it.
22:15:19 <Deewiant> elliott_: That's another of those that I think actually should be 1 space
22:15:28 <HackEgo> 75) <fungot> ehird: every set can be well-ordered. corollary: every set s has the same diagram used from famous program talisman with fnord windows to cascade, someone i would never capitalize " i"
22:15:29 <elliott_> Deewiant: Yeah. I can special-case that, I suppose :-P
22:15:31 <Deewiant> elliott_: I.e. it should be GOOD/BAD but I haven't bothered
22:15:35 <Phantom_Hoover> You can say anything in an angry voice and it'll sound like you want to kill someone and beat their children to death with a rusty hammer.
22:16:04 <ais523> !bfjoust attack7 (>)*5(+)*40<(-)*40(>)*4(>[+[+[+[+[-----[-[-[-[-](-)*122[-.]]]]]]]]])*21
22:16:10 <elliott_> Deewiant: I can't wait until you make absolute bounds GOOD/BAD, just to make Vorpal cry.
22:16:19 <elliott_> *exact bounds
22:16:19 <Deewiant> Absolute bounds?
22:16:21 <EgoBot> Score for impomatic_sicilian_defence: 18.7
22:16:22 <EgoBot> Score for quintopia_hmm: 10.6
22:16:26 <elliott_> Deewiant: Exact bounds.
22:16:26 <Deewiant> Aren't they already?
22:16:28 <elliott_> Deewiant: i.e. shrinking.
22:16:36 <elliott_> Deewiant: Oh right, they are, Vorpal just doesn't care :P
22:16:47 <elliott_> Deewiant: The # thing, then.
22:16:51 <impomatic> !bfjoust dragon_variation http://www.lichttuete.com/temp/a2.txt
22:16:52 <elliott_> UNDEF: # across left edge hits easternmost cell in file
22:16:52 <elliott_> UNDEF: # across left edge hits easternmost cell on line
22:16:54 <coppro> /w/win 2
22:17:09 <quintopia> interesting. the decoys weren't enough, so i do worse because now i don't beat tripwires
22:17:18 <Vorpal> <elliott_> Deewiant: The # thing, then. <-- I oppose since I believe the other behaviour is equally correct.
22:17:29 <EgoBot> Score for impomatic_dragon_variation: 34.7
22:17:30 <EgoBot> Score for ais523_attack7: 35.0
22:17:32 <elliott_> Vorpal: Is not.
22:17:39 <Vorpal> elliott_, why
22:17:40 <ais523> ais523_attack7.bfjoust vs myndzi_careless.bfjoust: <>>>>>>>>>><<<<<<<<<< <>>>>>>>>>>><<<<<<<<< <>>>>>>>>>>><<<<<<<<< <>>>>>>>>>><<<<<<<<<< Tie
22:17:42 <elliott_> Vorpal: It's only justifiable with the implementation detail of rectangle bounds.
22:17:44 <ais523> myndzi: heh, I'm amused at that one
22:17:50 <ais523> that's quite a precarious draw
22:17:51 <elliott_> Vorpal: From a Lahey-space point of view, # has only one behaviour, and it's that one.
22:17:53 <impomatic> !bfjoust defective http://www.lichttuete.com/temp/a3.txt
22:17:58 <ais523> looks like my program favours longer tapes, there
22:18:09 <quintopia> !bfjoust hmm >(+)*23(-)*24(>[-[++[>>>>>[>(+)*3[[-]]+]]]])*22
22:18:17 <elliott_> Deewiant: UNDEF: the empty string wrapped around the edge of space contains 1 character(s) (hopefully spaces)
22:18:22 <elliott_> Deewiant: Fix't (it was actually a trivial bug in my code).
22:18:36 <Vorpal> elliott_, shouldn't it contain a space?
22:18:55 <elliott_> Vorpal: Yes, it contains one space.
22:19:00 <Vorpal> indeed
22:19:21 <EgoBot> Score for quintopia_hmm: 11.2
22:19:21 <EgoBot> Score for impomatic_defective: 31.6
22:19:23 <impomatic> !bfjoust self_aware_brainfuck http://www.lichttuete.com/temp/a4.txt
22:19:37 <Vorpal> elliott_, what did fbbi do wrt # and edge
22:19:41 <EgoBot> Score for impomatic_self_aware_brainfuck: 27.5
22:20:09 <Gregor> lolwtf
22:20:12 <ais523> ooh, 48 programs on the hill now
22:20:17 <impomatic> !bfjoust sieg_heil http://www.lichttuete.com/temp/a5.txt
22:20:29 <ais523> Gregor: sometimes report.txt cuts off around line 33; also, the size of the hill seems to change at random
22:20:48 <EgoBot> Score for impomatic_sieg_heil: 22.2
22:21:05 <Gregor> ais523: The size is 47 + all programs submitted before it had time to finish, so 48 unless you submit fifty at once :P
22:21:13 <zzo38> I also noticed that sometimes files are saved and sometimes they are deleted, and sometimes they aren't saved.
22:21:19 <Gregor> That's the way it's always worked, btw, just with a different lowerbound.
22:21:20 <elliott_> <Vorpal> elliott_, what did fbbi do wrt # and edge
22:21:23 <ais523> Gregor: indeed
22:21:28 <elliott_> Probably go into an infinite loop.
22:21:32 <Vorpal> elliott_, haha :D
22:21:36 <elliott_> And then segfault, continually.
22:21:42 <Vorpal> :P
22:22:02 <Gregor> I believe it's official that everyone who isn't me hates http://codu.org/tmp/jungle-2011-02-08-1.ogg X-P
22:22:37 <zzo38> Gregor: How do I know? I have not listened to that file yet so I don't know.
22:22:38 <Vorpal> !bfjoust nop .
22:22:42 <Vorpal> Gregor, I will check it
22:22:52 <quintopia> Gregor: i need to hear superturing. y u no link.
22:22:59 <Vorpal> Gregor, do you like it?
22:23:08 <elliott_> Gregor: that is amazing
22:23:10 <Gregor> Vorpal: I think it's a nice start :P
22:23:12 <Vorpal> <Gregor> I believe it's official that everyone who isn't me hates http://codu.org/tmp/jungle-2011-02-08-1.ogg X-P <-- cool
22:23:18 <Vorpal> Gregor, awesome start
22:23:27 <Gregor> quintopia: HAVE YOUR MOFO LINK http://codu.org/music/e/superturing/superturing.ogg
22:23:29 <Vorpal> Gregor, a bit short yeah
22:23:39 <Gregor> Well it is just a start :P
22:23:46 <impomatic> !bfjoust spawn_of_evil http://www.lichttuete.com/temp/a6.txt
22:23:48 <quintopia> :D :D :D
22:24:09 <Gregor> I reaaaaally need to replace the trombone on that >_>
22:24:31 <Vorpal> impomatic, can we wait for the previous ones to finish?
22:24:42 <EgoBot> Score for Vorpal_nop: 7.8
22:24:43 <EgoBot> Score for impomatic_spawn_of_evil: 33.3
22:24:46 <impomatic> !bfjoust in_the_dark_of_night http://www.lichttuete.com/temp/a7.txt
22:25:07 <oerjan> technically he did wait
22:25:09 <ais523> impomatic: were you working on all those while egobot was down?
22:25:14 <impomatic> That's it for now... I daren't submit a8 or a9 :-(
22:25:34 <EgoBot> Score for impomatic_in_the_dark_of_night: 29.5
22:25:37 <elliott_> oerjan: hmm where do I put a new IP
22:25:39 <impomatic> ais523: no, they're all the submissions that I messed up by submitting HTML!
22:25:42 <elliott_> oerjan: I want to insert an element in the zipper-queue before the current one
22:25:46 <elliott_> oerjan: cons to the second list?
22:25:49 <ais523> impomatic: aha
22:25:53 <oerjan> elliott_: yeah
22:26:14 <ais523> wow, defend10 is shooting back up the leaderboard
22:26:18 <Vorpal> impomatic, that website looks very familiar! XD
22:26:24 <impomatic> Apart from the two which kill Egobot... (which I'm expecting to do well)
22:26:27 <Vorpal> impomatic, that is "http://www.lichttuete.com/"
22:26:34 <elliott_> Deewiant: Cloned IPs get the same storage offset, right?
22:26:48 <Deewiant> Right.
22:26:52 <Deewiant> I'm pretty sure, anyway.
22:27:31 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>>>[>(+)*20[[-]]+]]]](+)*9)*22
22:27:44 <impomatic> Vorpal: I'm slowly translating it to various languages. Started with German because it covers quite a few counties :-)
22:27:45 <Vorpal> elliott_, some fingerprints copy their IP specific data on clone. But not all
22:27:50 <EgoBot> Score for quintopia_juggernaut_bitch: 16.9
22:27:53 <elliott_> Vorpal: You're kidding me.
22:27:54 <Vorpal> elliott_, just something to considering when doing fingerprints later on
22:27:58 <Vorpal> elliott_, no I'm not
22:28:03 <elliott_> Wonderful!
22:28:16 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>>>[>(+)*5[[-]]+]]]](+)*5)*22
22:28:17 <elliott_> Good thing my fingerprint mechanism is SO ELEGANT that I can just make it part of the class.
22:28:24 * Phantom_Hoover → sleep
22:28:24 -!- Phantom_Hoover has left (?).
22:28:29 <Vorpal> elliott_, yeah better get that right from the start :P
22:28:32 <elliott_> Deewiant: Going to test concurrent execution with 2 IPs.
22:28:32 <elliott_> Assuming that instructions without any particular concurrency-related behaviour, such as ^>v<#, take one tick.
22:28:32 <elliott_> Will continue to produce textual output, so strings must work correctly where concurrency is concerned: "a b" should take 5 ticks, 'a should take 1.
22:28:34 <elliott_> [HANG]
22:28:35 <ais523> impomatic: is that your day job?
22:28:37 <EgoBot> Score for quintopia_juggernaut_bitch: 10.7
22:28:49 <elliott_> Vorpal: Actually it's pretty extensible.
22:29:02 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>>>[>(+)*20[[-]]+]]]](+)*5)*22
22:29:04 <elliott_> Vorpal: Since I plan to generate the instances with Template Haskell I can easily add in new bits to flip.
22:29:15 <Vorpal> elliott_, in particular I think HRTI reset it's data. But not completely sure.
22:29:17 <EgoBot> Score for quintopia_juggernaut_bitch: 12.0
22:29:19 <Vorpal> I do remember some did at least
22:29:27 <elliott_> Deewiant: What does it mean if concurrent testing hangs? :P
22:29:42 <Vorpal> elliott_, how will do you MODE? Will you at all?
22:29:44 <Deewiant> elliott_: You keep rerunning the same IP, maybe? One of them goes to a ><
22:29:50 <elliott_> Vorpal: What does MODE do?
22:29:53 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>>>[>(+)*20[[-]]+]]]]+)*22
22:29:54 <impomatic> ais523: yes. Only takes a couple of hours per day though so I spend the rest of the day messing with old computers ;-)
22:30:00 <elliott_> oerjan: modifyIPs $ \(xs,ys) -> (xs, newIP:ys)
22:30:09 <elliott_> rotate ([ip],r) = (reverse r ++ [ip], [])
22:30:11 <elliott_> So it turns into
22:30:14 <elliott_> ([newIP,ip], [])
22:30:19 <elliott_> And then possibly
22:30:22 <Vorpal> elliott_, it's feral. It adds mode where stuff behave differently. Like making > < ^ v "strafe" IP instead of turn it
22:30:23 <EgoBot> Score for quintopia_juggernaut_bitch: 4.5
22:30:25 <elliott_> ([ip], [newIP])
22:30:29 <elliott_> And so on.
22:30:30 <elliott_> So that looks fine.
22:30:38 <Vorpal> elliott_, I'm pretty sure ccbi implements it
22:30:41 <Gregor> Lesse if I just broke everything.
22:30:43 <Vorpal> it is catseye btw
22:30:49 <Gregor> !bfjoust suicide <
22:30:55 <elliott_> Vorpal: I plan to have some sort of feral mechanism for overloading core instructions.
22:30:58 <oerjan> elliott_: thought so. r is the set ip's already visited in this cycle.
22:31:03 <EgoBot> Score for Gregor_suicide: 0.0
22:31:06 <elliott_> Vorpal: And hooking into the interpreter loop.
22:31:12 <elliott_> oerjan: right. so that's correct.
22:31:15 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>>>[>(+)*20[[-]]+]]]](+)*13>[-[++[>>>>>[>(+)*20[[-]]+]]]](-)*13)*11
22:31:15 <Vorpal> elliott_, and isn't there one fingerprint that turn the stack into a double-ended queue
22:31:17 -!- pikhq_ has changed nick to pikhq.
22:31:19 * elliott_ tries printing the current ip
22:31:19 <Vorpal> elliott_, yes I think there is
22:31:21 <elliott_> Vorpal: Seriously?
22:31:24 <Vorpal> elliott_, yes
22:31:31 <elliott_> Vorpal: I'll just do that the inefficient way, because fuck that :P
22:31:33 <Vorpal> elliott_, I don't implement it though. But CCBI does
22:31:33 <EgoBot> Score for quintopia_juggernaut_bitch: 17.3
22:31:35 <oerjan> *+of
22:31:36 <ais523> Gregor: it leaves the old report up while the new one generates?
22:31:42 <quintopia> :D
22:31:44 <elliott_> Deewiant: Do you implement MVRS?
22:31:48 <Gregor> ais523: That was the plan, but it now seems to leave the old report up forever :P
22:31:55 <Vorpal> elliott_, you *know* the answer to that one
22:31:57 <Deewiant> Haven't done it
22:32:00 <elliott_> Vorpal: "Yes"?
22:32:09 <Vorpal> elliott_, oh I thought you said MKRY :P
22:32:11 <Deewiant> It shouldn't be too much trouble though
22:32:20 <elliott_> Deewiant: Do you/will you implement MKRY?
22:32:24 <impomatic> How much can my bfjoust program expand to without crashing Egobot? I want to try something...
22:32:24 <elliott_> I can clarify the spec if you would like :D
22:32:25 <Deewiant> No :-P
22:32:30 <elliott_> Deewiant: Why not
22:32:36 <elliott_> It'd take like 5 lines
22:32:38 <Deewiant> It's a new level of pointlessness
22:32:54 <elliott_> Deewiant: As opposed to writing pages and pages of efficient wrapping code for an obscure esoteric language with almost no users
22:32:56 <Deewiant> And it's really just a troll aimed at Mike :-P
22:33:19 <elliott_> Deewiant: Hey, I'm the one who defended RC/Funge :P
22:33:31 <oerjan> impomatic: note that ()* with matching parentheses doesn't expand
22:33:44 <ais523> I think that sort of trolling nowadays is in bad taste
22:33:47 <Deewiant> At least figuring out the AABB stuff was a fun mental exercise
22:33:52 <Vorpal> ais523, I agree
22:33:54 <Gregor> !bfjoust suicide_again <
22:34:02 <Vorpal> Deewiant, AABB?
22:34:13 <ais523> Gregor: did anything change?
22:34:15 <EgoBot> Score for Gregor_suicide_again: 0.0
22:34:26 <Deewiant> Vorpal: Axis-aligned bounding box.
22:34:29 <Gregor> ais523: Doesn't seem so.
22:34:30 <Vorpal> Deewiant, ah
22:34:33 <Gregor> Bleh, borklebork.
22:34:34 <elliott_> Deewiant: So is figuring out whether "3 to 15" is inclusive or exclusive on each end.
22:34:47 <ais523> Deewiant: it must go to war with the Allied-aligned bounding box!
22:34:49 <elliott_> Deewiant: And whether that one instruction pushes eeeeeeeeeeeeeeee or eheheehhhhhehe.
22:34:51 <Deewiant> elliott_: No, that's something that can be left to an RNG
22:35:01 <Vorpal> elliott_, this is why you write (3,15] or such
22:35:02 <Deewiant> ais523: Hah :-D
22:35:05 <Vorpal> if that is what you mean
22:35:17 <elliott_> Vorpal: Because MKRY was designed to be clear and unambiguous!
22:35:18 <Vorpal> ais523, "meh"
22:35:32 <Gregor> !bfjoust lol_that_script_didnt_parse <
22:35:41 <EgoBot> Score for Gregor_lol_that_script_didnt_parse: 0.0
22:35:50 <Vorpal> elliott_, <ais523> I think that sort of trolling nowadays is in bad taste
22:35:52 <nescience> !bfjoust test []->>>>>>>>>([-])*21
22:35:52 <Gregor> There we go.
22:36:04 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a10.txt
22:36:24 <elliott_> ais523: *shrug* I've never had any problem with Mike at all. :p
22:36:36 <EgoBot> Score for nescience_test: 8.4
22:36:59 <Vorpal> Gregor, yay it no longer blanks the scoreboard when running
22:37:01 <Vorpal> Gregor++
22:37:07 <ais523> `run ps aux | grep e\go | grep -v report
22:37:09 <HackEgo> 5000 10296 0.0 0.1 45960 1440 ? S 22:46 0:00 su - egobot \ 5000 11850 0.0 0.1 9516 1532 ? S 22:57 0:00 /bin/bash PRIVMSG/tr_21.cmd PRIVMSG #esoteric !bfjoust egodeath http://www.lichttuete.com/temp/a10.txt \ 5000 11861 0.0 0.1 9532 1616 ? S 22:57 0:00 /bin/bash
22:37:30 <elliott_> Deewiant: Yay, I forgot to do all the things I need to do
22:37:30 <ais523> `run ps aux | grep e\go | grep -v report | grep -v PRIVMSG
22:37:31 <HackEgo> 5000 10296 0.0 0.1 45960 1440 ? S 22:46 0:00 su - egobot \ 5000 11890 21.0 1.2 20176 12612 ? RN 22:57 0:17 ../egojoust Deewiant_maglev.bfjoust impomatic_egodeath.bfjoust \ 1208341 12162 0.0 0.0 4324 904 ? SN 22:58 0:00 grep /bin/grep ego \ 5000 20832 0.0 0.0 33884
22:37:45 <ais523> yep, egodeath really does seem to give it problems
22:37:46 <Vorpal> ais523, nice but somewhat verbose status report
22:37:52 <nescience> !bfjoust test <
22:37:54 <ais523> a pity, because I want to write that sort of program too
22:38:03 <Deewiant> elliott_: Which ones
22:38:09 <Vorpal> `run ps aux | grep PRIVMSG
22:38:12 <HackEgo> 5000 11850 0.0 0.1 9516 1532 ? S 22:57 0:00 /bin/bash PRIVMSG/tr_21.cmd PRIVMSG #esoteric !bfjoust egodeath http://www.lichttuete.com/temp/a10.txt \ 5000 11861 0.0 0.1 9532 1616 ? S 22:57 0:00 /bin/bash scmds/bfjoust bfjoust egodeath http://www.lichttuete.com/temp/a10.txt PRIVMSG
22:38:16 <ais523> maybe I can figure out a way to patch the interp
22:38:17 <Vorpal> aha
22:38:18 <elliott_> Deewiant: Thingsy things
22:38:31 <impomatic> !bfjoust egodeath <
22:38:38 <nescience> lol I have avoided that kind of expansion because it's too evil
22:38:41 <Vorpal> impomatic, won't help when running
22:38:46 <EgoBot> Score for impomatic_egodeath: 0.0
22:38:47 <EgoBot> Score for nescience_test: 0.0
22:38:47 <EgoBot> Score for impomatic_egodeath: 0.0
22:38:48 <oerjan> `run ps aux | grep -i porn
22:38:53 <Vorpal> ah
22:38:56 <Vorpal> Gregor, that seems wrong
22:39:01 * oerjan whistles innocently
22:39:05 <Vorpal> how could it score 0.0 (the original one)
22:39:08 <ais523> `run ps aux | grep e\go | grep -v report | grep -v PRIVMSG
22:39:09 <HackEgo> 5000 12576 0.0 0.1 8908 1244 ? S 23:00 0:00 /bin/bash PRIVMSG/tr_60.cmd PRIVMSG #esoteric `run ps aux | grep -i porn \ 5000 12595 0.0 0.0 8908 536 ? S 23:00 0:00 /bin/bash PRIVMSG/tr_60.cmd PRIVMSG #esoteric `run ps aux | grep -i porn \ 5000 12598 0.0 0.0 8912 508 ?
22:39:10 <HackEgo> 5000 10296 0.0 0.1 45960 1440 ? S 22:46 0:00 su - egobot \ 5000 11890 19.9 1.2 20176 12708 ? TN 22:57 0:36 ../egojoust Deewiant_maglev.bfjoust impomatic_egodeath.bfjoust \ 5000 12251 17.1 1.2 20176 12584 ? RN 22:59 0:13 ../egojoust Deewiant_maglev.bfjoust impomatic_egodeath.bfjoust
22:39:13 <nescience> I was thinking earlier you could add an instruction like
22:39:14 <Vorpal> aha
22:39:14 <ais523> Vorpal: cache effects
22:39:21 <Vorpal> ais523, what?
22:39:33 <nescience> "if zero break loop"
22:39:42 <Gregor> If you run it twice with the same name, it'll switch partway through and go crazy X_X
22:39:50 <Vorpal> nescience, like "goto" in brainfuck XD
22:39:51 <nescience> so that you don't need to do ridiculous nested [] expansions
22:40:06 <Vorpal> Gregor, ouch
22:40:07 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a10.txt
22:40:15 <impomatic> I think I fixed my program :-)
22:40:17 <nescience> except it'd only goto the appropriate ]
22:40:20 <Vorpal> impomatic, let it run to end?
22:40:20 <elliott_> Gregor: :D
22:40:27 <elliott_> Gregor: omg you could make a program that wins on half
22:40:30 <elliott_> and one that wins on the other half
22:40:31 <elliott_> and swap it
22:40:36 <ais523> impomatic: that was the sort of use I envisaged when I added % to the lang
22:40:38 <elliott_> nescience: The point of BF Joust is to stay close to Brainfuck
22:40:40 <ais523> on the basis that interps could optimise it
22:40:41 <elliott_> nescience: Not doing that leads to FYB :P
22:40:44 <Vorpal> elliott_, somewhat tricky to get timing right
22:40:50 <Vorpal> elliott_, but sure could be done
22:40:56 <nescience> alternatel evaluate % loops without expansion
22:41:02 <ais523> elliott_: you can actually produce arbitrary control flow by making 2^n copies of your program
22:41:06 <elliott_> Deewiant: The IP's location after t, and the location that the created IP will start at, are the same, yes?
22:41:17 -!- oerjan has quit (Quit: Good night).
22:41:18 <ais523> it seems egodeath is still killing egobot, though
22:41:26 <Vorpal> ais523, they can't optimise it very well when you need to interleave turns
22:41:26 <elliott_> <nescience> alternatel evaluate % loops without expansion
22:41:27 <elliott_> lance did thaaat
22:41:28 <Gregor> >_<
22:41:29 <impomatic> Used ( [ { something } ] something )%xxxx and hopefully it doesn't kill egobot
22:41:32 <nescience> anyway it would be close to brainfuck though
22:41:33 <Deewiant> elliott_: Er, no? One reverses, one doesn't?
22:41:42 <elliott_> Deewiant: ...oh :-D
22:41:44 <ais523> impomatic: egojoust unrolls all %-loops
22:41:51 <ais523> it may be patchable not to
22:41:51 <nescience> oh that was the guy I was explaining it to I think
22:41:52 <nescience> lance
22:42:07 <nescience> it dedfinitely is doable
22:42:12 <nescience> I worked it out before
22:42:17 <ais523> my original bf joust interp expanded % loops lazily
22:42:31 <elliott_> nescience: that was the guy?
22:42:45 <elliott_> lance was the name of my bf joust interpreter, but egojoust got finished first, with the features i invented for lance
22:42:50 <nescience> I remember explaining it to someone who used it
22:43:03 <ais523> impomatic: try changing the 10000 to 100, to see if it helps
22:43:04 <elliott_> GOOD: basic concurrency seems to work
22:43:05 <elliott_> BAD: reflected IP didn't copy stack
22:43:05 <elliott_> PCahrielndt IIPP:: IIDD 0
22:43:05 <elliott_> 1
22:43:05 <elliott_> BAD: parent IP executed prior to child IP
22:43:05 <elliott_> baADD: tBaAkDe:s ]l edsose stnh'atn w5o rtki cakts a
22:43:06 <elliott_> lask1eap B
22:43:08 <nescience> oh, maybe I am confused. it sounded familiar like a name
22:43:08 <impomatic> ais523: ah, I guess I'd can't get egodeath to work then :-/
22:43:08 <elliott_> :
22:43:10 <elliott_> GOO)OGO:elliott@elliott-MacBookAir:~/mycology$
22:43:13 <elliott_> Deewiant: For your entertainment ^
22:43:19 <ais523> impomatic: I know, I'm upset for the same reason, as I wanted to do something much like that
22:43:19 <Deewiant> elliott_: Wait'll you get to TRDS
22:43:25 <Vorpal> <elliott_> baADD: tBaAkDe:s ]l edsose stnh'atn w5o rtki cakts a
22:43:27 <Vorpal> awesome
22:43:49 <Vorpal> elliott_, I seen this sort of things too (though not this exact one)
22:43:54 <elliott_> Deewiant: Whoo boy :P
22:43:55 <Vorpal> <elliott_> lask1eap B
22:43:58 <Vorpal> like flask but not lask
22:43:59 <Deewiant> That's only two threads outputting, that's not that bad
22:44:24 <Vorpal> <ais523> impomatic: I know, I'm upset for the same reason, as I wanted to do something much like that <-- get Gregor to fix it?
22:44:31 <elliott_> let newIP =
22:44:31 <elliott_> ip{ ipNum = maxIPNum + 1
22:44:31 <elliott_> , ray = Ray (pos + reflection delta) (reflection delta) }
22:44:31 <elliott_> modify $ \fs -> fs{ maxIPNumber = maxIPNum + 1 }
22:44:33 <Vorpal> ais523, or send him a patch!
22:44:33 <ais523> it's far from a trivial fix
22:44:33 <elliott_> modifyIPs $ \(xs,ys) -> (xs, newIP:ys)
22:44:36 <ais523> it'd make more sense to send a patch
22:44:38 <elliott_> Deewiant: I SEE NOTHING WRONG
22:44:40 <elliott_> Deewiant: Or, wai
22:44:41 <elliott_> *wait
22:44:46 <elliott_> Deewiant: Is (pos + reflection delta) wrong there?
22:44:55 <elliott_> Well
22:44:58 <elliott_> Apart from it being pos - delta >_<
22:45:04 <Vorpal> elliott_, aren't you doing the fork bomb literal spec variant?
22:45:06 <elliott_> Cool, reflection is just negate now
22:45:18 <pikhq> Deewiant: TRDS would be easy with the time travel monad. :P
22:45:24 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a10.txt changed to 100
22:45:27 <Vorpal> pikhq, :D
22:45:46 -!- amca has joined.
22:46:09 <ais523> impomatic: at least it's running now
22:46:13 <elliott_> Vorpal: Not that I know of.
22:46:19 <elliott_> Vorpal: That's why I move the IP on spawn.
22:46:21 <ais523> but it's tying with defend7, etc, so there's probably a logic error somewhere
22:46:24 <EgoBot> Score for impomatic_egodeath: 8.4
22:46:25 <EgoBot> Score for impomatic_egodeath: 8.4
22:46:29 <Vorpal> elliott_, YOU MUST FOLLOW SPEC!
22:46:30 <Vorpal> ;P
22:46:50 <impomatic> ais523: I use a lot of ( {} ) - maybe I can replace most of them with () ()
22:46:56 <elliott_> Vorpal: I've long since realised that Mycology is Deewiant's sneaky tool to make everyone think the spec says what he wants it to say :P
22:47:06 <Deewiant> elliott_: Shh!
22:47:15 <elliott_> Test suite my ass
22:47:18 <Vorpal> elliott_, hah :P
22:47:21 <ais523> impomatic: yep, it's probably best to use () () if there are no square brackets, and ({}) if there are
22:47:33 <ais523> and (a{b}c)%n == (a)*nb(c)*n
22:47:52 <Vorpal> elliott_, in part you are right in fact. In part it is a good test suite. Besides he did the sensible thing in many cases.
22:47:56 <Vorpal> (though not all)
22:48:17 <elliott_> To be fair, when he does differently to the spec it's because the spec is downright useless.
22:48:24 <elliott_> Although I still think that form feeds should be read into fungespace.
22:48:48 <Vorpal> elliott_, I think form feed handling is more consistent this way
22:48:56 <elliott_> Vorpal: But the spec doesn't even begin to say that.
22:48:58 <Vorpal> elliott_, since for unefunge \n is skipped
22:49:19 <elliott_> Again, I'd prefer it only disagree with the spec when taking the spec's side would result in an absolutely useless language :P
22:49:20 <Vorpal> elliott_, for befunge form feed should be skipped since form feed is for trefunge what \n is for befunge
22:49:29 <elliott_> Again, I'd prefer it only disagree with the spec when taking the spec's side would result in an absolutely useless language :P
22:49:42 <Vorpal> elliott_, I read what you said and repeating it won't help
22:49:54 <elliott_> Again, I'd prefer it only disagree with the spec when taking the spec's side would result in an absolutely useless language :PAgain, I'd prefer it only disagree with the spec when taking the spec's side would result in an absolutely useless language :PAgain, I'd prefer it only disagree with the spec when taking the spec's side would result in an absolutely useless language :P
22:49:56 <elliott_> Whee
22:49:57 <Deewiant> elliott_: Your _ annoys me
22:50:07 -!- elliott_ has changed nick to elliott__.
22:50:09 <elliott__> Is that better?
22:50:18 <Vorpal> elliott__, besides it started with rc/funge incrementing the z coord in befunge mode!
22:50:19 <Deewiant> Actually it is a bit
22:50:21 <Vorpal> on form feed
22:50:25 <elliott__> Vorpal: :-D
22:51:09 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
22:51:15 <Vorpal> elliott__, anyway do you handle the truncation-instead-of-overflow thing for & correctly yet?
22:51:26 <elliott__> Not yet.
22:51:50 <Vorpal> elliott__, you might want to do it base-agnostic. Then you can reuse it when implementing the fingerprint BASE
22:52:00 <ais523> $ ./egojoust defend7.bj impomatic_egodeath.bj 21 1
22:52:01 <ais523> realloc: Cannot allocate memory
22:52:02 <elliott__> Reuse all 5 lines?
22:52:07 <ais523> and that's with %100, not %10000
22:52:10 <Vorpal> elliott__, oh right. Not C :P
22:52:27 <EgoBot> Score for impomatic_egodeath: 42.9
22:52:39 <ais523> impomatic: aha, that looks much better
22:52:41 <ais523> what did you fix?
22:53:02 <elliott__> I blame oerjan for this
22:53:22 <Deewiant> impomatic: Stop making things that beat monorail but lose to steamroller
22:53:31 <elliott__> Deewiant: Seriously though... when you spawn the new IP, you spawn it one delta backwards, right?
22:53:37 <elliott__> *one of your delta
22:53:40 <elliott__> With its delta negated.
22:53:48 <Deewiant> Yeah, I'd say so
22:53:53 <elliott__> Deewiant: And then it goes to the next instruction (toNextIns, not advance) on its first tick?
22:53:57 <elliott__> i.e. skips over spaces.
22:54:12 <Deewiant> Presumably
22:54:23 <impomatic> ais523: Increased the count to 300 which should wait long enough for some opponents some of the time. Need it higher really, not sure how high I can go. Also got rid of as many ( {} ) % n as possible
22:54:33 <ais523> ah, I assumed there was a logic fix there too
22:54:39 <elliott__> Deewiant: So, uh, "reflected IP didn't copy stack" ... wait
22:54:40 <elliott__> WAIT
22:54:45 <elliott__> The stack is per-IP, isn't it?
22:54:48 <Deewiant> Stop the presses!!
22:54:52 * elliott__ EPIC FUCKING FACEPALM
22:54:53 <Deewiant> Yes, it is
22:55:01 <elliott__> Deewiant: Is the stack-stack per-IP?
22:55:03 <Deewiant> Yes, it is
22:55:03 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
22:55:08 <elliott__> Deewiant: :D
22:55:11 <elliott__> Deewiant: Am I retarded?
22:55:14 <Deewiant> Yes, it is
22:55:18 <elliott__> Yes, it am.
22:55:39 <elliott__> Deewiant: Stop laughing.
22:55:47 <Vorpal> ahahahahahahahahahahahahaha....
22:55:50 <Vorpal> sorry can't stop
22:55:53 <elliott__> X-D
22:55:56 <ais523> Vorpal: *ehehehehhehehhhehehe
22:56:02 <elliott__> ais523: I thought that was in poor taste
22:56:03 <Vorpal> ais523, no I'm not him
22:56:14 <ais523> elliott__: it's mocking you mocking Mike
22:56:20 <elliott__> ais523: Nice excuse :P
22:56:29 <Deewiant> Mike used commas, not periods
22:56:31 <EgoBot> Score for impomatic_egodeath: 41.7
22:56:36 <elliott__> Deewiant: Both
22:56:41 <Deewiant> Mostly commas
22:56:43 <elliott__> But commas more often after (e|h)^n, yes.
22:57:12 -!- sixdej1 has joined.
22:57:12 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
22:58:32 <EgoBot> Score for impomatic_egodeath: 42.6
22:58:40 -!- Mathnerd314 has quit (Ping timeout: 240 seconds).
22:59:06 <ais523> !bfjoust defend11 http://sprunge.us/gdOE
22:59:08 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
22:59:08 <elliott__> Shiro/Monad.hs:127:0:
22:59:08 <elliott__> Couldn't match expected type `IP'
22:59:08 <elliott__> against inferred type `FungeState'
22:59:08 <elliott__> When using functional dependencies to combine
22:59:08 <elliott__> MonadState s (StateT s m),
22:59:09 <elliott__> arising from the dependency `m -> s'
22:59:11 <elliott__> That's what I like to hear!
23:00:14 -!- sixdej has quit (Ping timeout: 240 seconds).
23:00:30 <ais523> impomatic: breakdown.txt's got all confused, somehow
23:01:01 <ais523> I think it's writing in the middle of the file
23:01:04 <ais523> seems to be running, though
23:01:47 <impomatic> Hmmm... I never noticed breakdown.txt before!
23:01:57 <elliott__> Deewiant: All concurrency tests passed.
23:01:57 -!- sixdej1 has changed nick to sixdej.
23:02:00 <elliott__> impomatic: It's new.
23:02:03 <Deewiant> elliott__: Now do TRDS!
23:02:06 <elliott__> Deewiant: FUCK YEA, THAT WAS ACTUALLY PRETTY EASY -- NO
23:02:08 <ais523> and apparently broken in a really odd way
23:02:17 <elliott__> Deewiant: So, I have one single BAD now (o doesn't do text mode yet).
23:02:27 <elliott__> Deewiant: The rest are all GOOD, or UNDEFs that you agree with.
23:02:43 <elliott__> real0m1.783s
23:02:43 <elliott__> Oh.
23:02:43 <EgoBot> Score for impomatic_egodeath: 42.6
23:02:43 <EgoBot> Score for ais523_defend11: 5.8
23:02:50 <elliott__> Deewiant: GUESS WHY IT'S SO FAST
23:02:53 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
23:02:59 <Deewiant> elliott__: ghc -O2 instead of ghci? :-D
23:03:00 <elliott__> -- TODO: @ for multiple IPs
23:03:00 <elliott__> doCharIns '@' = io exitSuccess
23:03:03 <elliott__> Deewiant: ^
23:03:06 <elliott__> Nope, I always use -O2.
23:03:07 <Deewiant> Ha :-D
23:03:55 <EgoBot> Score for impomatic_egodeath: 43.5
23:03:59 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
23:04:34 <ais523> wow, defend9's shot up the leaderboard
23:04:59 <EgoBot> Score for impomatic_egodeath: 47.0
23:05:02 <ais523> it's even overtaken defend10
23:05:08 <Deewiant> Most of impomatic's stuff appears to lose to it
23:05:10 <coppro> where's the leaderboard?
23:05:25 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
23:05:34 <ais523> http://codu.org/eso/bfjoust/report.txt
23:05:46 <ais523> I guess the new programs are starting to be all too predictable again
23:06:24 <EgoBot> Score for impomatic_egodeath: 43.7
23:06:28 -!- FireFly has quit (Quit: swatted to death).
23:07:13 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
23:07:24 <coppro> where did mine go :(
23:07:46 <coppro> !bfjoust dumdum (>(+..)*254)*100
23:08:10 <elliott__> Deewiant: I pass all concurrency tests and don't fail afterwards, woo
23:08:22 <coppro> EgoBot is ignoring me :(
23:08:23 <Deewiant> All you need is TRDS
23:08:27 <elliott__> About to test, using ROMA, whether t copies the parent IP's loaded fingerprint semantics to the child IP.
23:08:28 <elliott__> This is unmentioned in the specification, and thus is UNDEF.
23:08:30 <elliott__> Deewiant: What should I aim for
23:08:30 <EgoBot> Score for impomatic_egodeath: 46.4
23:08:32 <EgoBot> Score for coppro_dumdum: 19.0
23:08:53 <Deewiant> elliott__: ccbi mycology.b98
23:09:01 <elliott__> Deewiant: Not biased I see
23:09:08 -!- Mathnerd314 has joined.
23:09:10 <elliott__> UNDEF: IVXLCDM didn't reflect: child IP has ROMA loaded
23:09:12 <elliott__> Agreed :P
23:09:12 <Deewiant> elliott__: You asked for my "should aim for" on an UNDEF
23:09:13 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
23:09:19 <ais523> !bfjoust defend11 http://sprunge.us/CBFF
23:09:22 <Deewiant> elliott__: There is no unbiased answer to such a question
23:09:31 <elliott__> Deewiant: CCBI could fail to live up to your perfect expectations, I guess
23:09:46 <Deewiant> elliott__: Sure, but you can't complain about bias whether I answer with ccbi or not
23:10:00 <elliott__> Shaddap :P
23:10:12 <elliott__> Okay hm.
23:10:26 <elliott__> Deewiant: Should I add text mode support to o or start with cleanup and fingerprints
23:10:27 <EgoBot> Score for impomatic_egodeath: 44.6
23:10:48 <Deewiant> elliott__: Go for TRDS if you want to do the least work
23:10:59 <EgoBot> Score for ais523_defend11: 5.3
23:11:01 <elliott__> Deewiant: What kind of definition of "work" are you using here
23:11:07 -!- Sgeo has joined.
23:11:26 <Deewiant> elliott__: I mean that you'll give up on Befunge-98 if you start doing it
23:11:34 <elliott__> :-D
23:11:51 <impomatic> !bfjoust egodeath http://www.lichttuete.com/temp/a11.txt
23:11:52 <elliott__> Deewiant: I do love how tiny the original TRDS spec is compared to the implementation guide.
23:11:59 <elliott__> Time travel, no big deal, we all know how to do that right?
23:12:11 <Deewiant> The guide doesn't actually add that much, it mostly restates a bunch of the original
23:12:21 <elliott__> Deewiant: And hey -- this is my third day of constant work on it. This is *unprecedented* project commitment for me.
23:12:46 <Deewiant> Hence I'm pushing you towards TRDS, to prevent the fourth
23:12:55 <elliott__> Deewiant: Do you not like Shiro? :-P
23:13:10 <Deewiant> I'm just testing you :-D
23:13:25 <elliott__> Deewiant: I'll try TRDS, but not before I get everything else done :p
23:13:25 <EgoBot> Score for impomatic_egodeath: 45.5
23:13:44 <impomatic> !bfjoust control http://www.lichttuete.com/temp/a12.txt
23:13:53 <elliott__> Deewiant: Do you implement text-mode IO in a more clever way than just preprocessing the binary mode output?
23:13:58 <elliott__> I want to know whether to feel bad about doing it like that.
23:14:22 <Deewiant> I don't think there is another way
23:14:34 <Deewiant> By "everything else", do you mean all other fingerprints? :-D
23:14:44 <Deewiant> Because if so, that should take a while
23:15:28 <EgoBot> Score for impomatic_control: 24.5
23:16:14 <elliott__> Deewiant: Pretty much, yes.
23:16:23 <elliott__> Deewiant: I can't imagine there's any fingerprints more difficult to implement than MVRS and TRDS.
23:16:24 <ais523> !bfjoust defend11 http://sprunge.us/aTNI
23:16:37 <EgoBot> Score for ais523_defend11: 0.0
23:16:41 <Deewiant> Hmm
23:17:00 <Deewiant> elliott__: IFFI? ;-)
23:17:13 <elliott__> Deewiant: Vorpal did IFFI and he won't do TRDS :-P
23:17:16 <ais523> !bfjoust defend11 http://sprunge.us/WXfE
23:17:24 <Deewiant> elliott__: Aye, but for Shiro in particular
23:17:40 <elliott__> Deewiant: First, implement INTERCAL in Haskell. Second, ...
23:17:45 -!- ais523 has quit (Remote host closed the connection).
23:17:54 <Deewiant> elliott__: IPMD, potentially
23:18:04 <elliott__> What's IPMD
23:18:13 <Deewiant> Switching between unefunge/befunge/trefunge at runtime
23:18:13 <elliott__> Interestingly Phucked Multiple-Dimensionality?
23:18:18 <elliott__> Hey, I was right.
23:18:23 <elliott__> ...I wasn't even trying to be right.
23:18:24 <Deewiant> "IP dimension modes"
23:18:31 <elliott__> Yeah, but I got it right :P
23:18:34 <Deewiant> Yep
23:18:45 <elliott__> Deewiant: Welp, I don't plan to implement 3D/1D/etc. soon.
23:18:53 <elliott__> Deewiant: Probably before TRDS though :-P
23:19:19 <elliott__> Deewiant: Ideally I'll get runtime N-dimensionality without non-negligible overhead
23:19:20 <Deewiant> CCBI2's architecture makes IPMD enough of a pain that I probably won't do it
23:19:32 <elliott__> Switching sounds like a bitch though.
23:19:50 <Deewiant> It'd have to copy over all of Funge-Space to a different structure whenever the dimensionality is switched
23:19:52 <EgoBot> Score for ais523_defend11: 14.0
23:19:57 <Deewiant> Which is just a bit silly
23:20:13 <Deewiant> Rc/Funge-98 gets by because it always uses a 3D funge-space
23:20:18 <elliott__> Heh.
23:20:28 <elliott__> Maybe I'll just always use an infinite-dimensional fungespace.
23:20:32 <elliott__> [1,2,0,0,0,0,0,0,0,...
23:20:38 <elliott__> (That's a coordinate.)
23:20:52 <Vorpal> elliott__, ooh yes you MUST do IFFI or you haven't taken the crown from cfunge :P
23:20:55 <Vorpal> as you said
23:21:03 <elliott__> I'd rather take the crown from CCBI :-P
23:21:08 <elliott__> Or at least be throne buddies.
23:21:38 <elliott__> OK, time to do a bit of cleanup, and then start on fingerprints.
23:21:42 <impomatic> !bfjoust dont_wait http://www.lichttuete.com/temp/a12.txt
23:21:59 <Deewiant> MACR may be tricky as well
23:22:48 -!- augur has quit (Remote host closed the connection).
23:22:49 <elliott__> Deewiant: Mini-Funge I doubt I'll do :P
23:22:58 <Deewiant> That too
23:23:11 <Deewiant> But yeah, that's not very relevant especially given the two conflicting specs
23:23:18 <elliott__> Eh?
23:23:25 <Deewiant> For Mini-Funge
23:23:39 <elliott__> "S ('Shelled') pushes a 0 on the stack if the Perl language is already loaded (e.g. the interpreter is written in Perl). It pushes a 1 on the stack otherwise, indicating that the Perl language will be shelled when needed."
23:23:42 <elliott__> That is the most braindead...
23:23:55 <Deewiant> Why's that
23:24:00 <elliott__> Because it's irrelevant?
23:24:10 <Deewiant> It tells you how fast it is to call to Perl
23:24:21 <Deewiant> You might want to do less of it if S is 1
23:24:23 <elliott__> Who cares about performance :P
23:24:28 -!- poiuy_qwert has joined.
23:24:31 <Deewiant> Everybody
23:24:44 <elliott__> ORTH... RAGE
23:24:55 <Deewiant> What's wrong with ORTH? :-D
23:24:58 <elliott__> I love how it fails to specify what the Orthogonal instructions do, you know, in case there's AMBIGUITY.
23:25:05 <Deewiant> Oh, that :-D
23:25:06 <EgoBot> Score for impomatic_dont_wait: 46.8
23:25:08 <Deewiant> Just dig up the ORTH spec
23:25:10 <Deewiant> Er
23:25:11 <elliott__> >>>Z?ramp if zero
23:25:11 <elliott__> WHAT THE FUCK IS RAMP
23:25:12 <Deewiant> Orthogonal*
23:25:17 <Deewiant> It's #
23:25:56 <elliott__> Does any fingerprint store global state independent of IPs?
23:26:02 <Deewiant> Yes
23:26:06 <elliott__> >_<
23:26:07 <elliott__> e.g.?
23:26:16 <Deewiant> Hmm
23:26:30 <Deewiant> REFC
23:26:46 <Deewiant> SUBR
23:26:48 <Deewiant> TIME
23:26:49 <Deewiant> TRDS
23:26:58 <elliott__> Deewiant: FML
23:27:07 <elliott__> New fingerprint:
23:27:08 <elliott__> HATE
23:27:09 <impomatic> !bfjoust dont_wait http://www.lichttuete.com/temp/a12.txt
23:27:09 <Deewiant> TRDS shouldn't've been a surprise, at least ;-)
23:27:33 <elliott__> A-Z all take on random Funge-98 meanings. Every other instruction gets remapped so that it has a 1/10 chance of going to the start of program execution,
23:27:44 <Deewiant> TRDS actually adds four fields to my FungeState struct
23:27:45 <elliott__> and repeating the program as if all operations that take two arguments took them in the wrong order,
23:27:58 <elliott__> and as if every vector popped was negated.
23:28:03 <Deewiant> Well, three, if the tracer's compiled in
23:28:10 <Deewiant> version (tracer) ulong tick = 0;
23:28:11 <Deewiant> else version (TRDS) ulong tick = 0;
23:28:24 <elliott__> When program execution completes or the program goes into any kind of infinite loop, the instruction reflects in the present, and the stack generated by the re-run is pushed to the stack stack.
23:28:30 <elliott__> (ANY kind of infinite loop.)
23:28:46 <elliott__> Deewiant: When will it be implemented
23:28:53 <Deewiant> Never
23:28:57 <elliott__> Deewiant: Why
23:29:03 <elliott__> Is it because you're lame?
23:29:04 <Deewiant> Not very useful
23:29:11 <elliott__> Deewiant: You forgot "requires halting oracle"
23:29:19 <elliott__> Or is that no problem for CBBI
23:29:29 <Deewiant> I actually didn't read the last two lines at all
23:29:41 <elliott__> :-D
23:29:50 <Deewiant> Oh, and then there's the IO stuff that adds state
23:29:54 <Deewiant> FILE, for instance
23:30:09 <Vorpal> Deewiant, FILE handles *may* be local to an IP
23:30:14 <elliott__> X-D
23:30:14 <Vorpal> it isn't really specced
23:30:19 <Deewiant> True
23:30:23 <elliott__> I'm going to clean up my code and then integrate my fingerprint code.
23:30:26 <Deewiant> But that doesn't seem like useful behaviour
23:30:49 <elliott__> I wonder what to split interpreter into
23:30:50 <Vorpal> Deewiant, I planned a DS9K implementation of FILE in efunge. Adding tagged funge space values. So you can't just create that handle anyhow
23:30:52 <elliott__> Interpreter and CoreInstructions?
23:31:13 <Vorpal> Deewiant, basically passing the whole FILE data required along with the value
23:31:30 <Vorpal> Deewiant, would you hate that?
23:31:37 <Vorpal> Deewiant, would mycology survive it?
23:31:49 <Deewiant> I don't understand what you mean
23:31:54 -!- yorick has quit (Read error: Connection reset by peer).
23:31:56 <Deewiant> A typed funge-space, instead of everything being a cell?
23:32:00 <Vorpal> Deewiant, yep
23:32:04 <EgoBot> Score for impomatic_dont_wait: 46.6
23:32:11 <Deewiant> I don't think that's valid
23:32:11 <elliott__> Vorpal: That disobeys the spec.
23:32:13 <elliott__> Any questions?
23:32:19 <Vorpal> elliott__, not the FILE spec
23:32:28 <elliott__> Vorpal: No, but it wouldn't be a Funge-98 implementation.
23:32:49 <Vorpal> elliott__, but FILE is of course feral in this model!
23:32:53 <Deewiant> I guess he could argue that his FILE is feral and messes up all other instructions
23:32:59 <Vorpal> Deewiant, quite :P
23:33:08 <elliott__> Feral != breaks the spec
23:33:11 <Vorpal> anyway it is too much work to do it that way
23:33:14 <elliott__> Feral == obeys the spec but breaks all kinds of sanity
23:33:17 <Vorpal> elliott__, feral *might* break the spec
23:33:28 <elliott__> Really? So FNGR is just feral, not broken?
23:33:30 <elliott__> I don't think so.
23:33:31 <Vorpal> elliott__, it is perfectly legal for it. But only when in use
23:33:32 <Deewiant> Yes
23:33:36 <Deewiant> MODE is similar
23:33:45 <Vorpal> elliott__, correct since it is now defined to enter a separate mode
23:33:52 <Deewiant> MODE changes how just about every instruction works
23:33:57 <Vorpal> yeah
23:34:14 <Deewiant> And that's even a Cat's Eye fingerprint, so you can't make too strong an argument against it ;-)
23:34:18 <elliott__> How many fingerprints did HsFunge implement?
23:34:24 <Deewiant> None, I believe
23:34:27 <Deewiant> Or maybe NULL and ROMA or so
23:34:35 <elliott__> Ha, Shiro is going to be like ten times better
23:34:41 <elliott__> Deewiant: How fast did it run Mycology? :-P
23:34:49 <Deewiant> Okay, scratch that
23:34:54 <impomatic> !bfjoust dont_wait http://www.lichttuete.com/temp/a12.txt
23:35:07 <elliott__> I'm scratching it
23:35:36 <elliott__> Deewiant: "None"
23:35:41 <Deewiant> $ wc -l Fingerprints.hs
23:35:41 <Deewiant> 1376 Fingerprints.hs
23:35:45 <Deewiant> I thought it was none :-P
23:35:47 <elliott__> Deewiant: How fast did HsFunge pass mycology? Like, without fingerprints :P
23:35:51 <elliott__> Deewiant: Fingerprints.hs? Pfft
23:35:55 <elliott__> I see he doesn't use my amazing system
23:36:04 <Deewiant> I don't see a way of disabling fingerprints
23:36:07 <Deewiant> $ ./Main --help
23:36:07 <Deewiant> Main: --help: openFile: does not exist (No such file or directory)
23:36:14 <Vorpal> Deewiant, anyway I argue that doing 0,1,2 and such for normal values but then doing surprises like {0,<file data>} for a file handle is perfectly okay. If funge code tries to output or increment or anything then the first member of the tuple gets modified. But the whole tuple is copied, written with p, fetched with g and so on
23:36:32 <elliott__> Deewiant: With fingerprints, then?
23:36:34 <Vorpal> Deewiant, might give all open files the value 0 this way
23:36:36 <Vorpal> Deewiant, :D
23:36:45 <Deewiant> Main: mycology.b98: hGetContents: invalid argument (Invalid or incomplete multibyte or wide character)
23:36:49 <Deewiant> Guess it doesn't run it at all
23:36:57 <Deewiant> Maybe it will with a recompile from 6.12
23:36:57 <elliott__> Deewiant: Designed for older GHC
23:37:03 <elliott__> Deewiant: Try 6.8
23:37:10 <Deewiant> It's built in 2010-05
23:37:10 <elliott__> Deewiant: You need a pre-Unicode IO system
23:37:18 <Vorpal> elliott__, why don't you your self
23:37:24 <Vorpal> yourself*
23:37:25 <elliott__> Vorpal: Umm, because he's the one who wants to test HsFunge
23:37:27 <Vorpal> ah
23:37:30 <elliott__> Well
23:37:32 <elliott__> I want to know the answer
23:37:34 <elliott__> But he's the one doing it
23:37:36 <elliott__> s/ $//
23:37:36 <Vorpal> elliott__, :P
23:37:45 <EgoBot> Score for impomatic_dont_wait: 49.1
23:37:51 <elliott__> impomatic: congratulations
23:38:04 <Deewiant> elliott__: I thought handles defaulted to latin1?
23:38:15 <elliott__> Deewiant: Nope, UTF-8
23:38:26 <elliott__> Deewiant: Try hSetBinaryMode fileHandle True
23:38:30 <elliott__> Deewiant: Or s/openFile/openBinaryFile/
23:38:33 <elliott__> :t readBinaryFile
23:38:34 <lambdabot> Not in scope: `readBinaryFile'
23:38:38 <elliott__> You might have to make it manually open the file.
23:38:42 <elliott__> If it uses readFile.
23:38:49 <Deewiant> runFile file = readFile file >>= runString
23:39:08 <elliott__> Deewiant: runFile file = do fh <- openBinaryFile file; poop <- hGetContents fh; runString poop
23:39:12 <elliott__> That's a bit unfair, since it loads lazily
23:39:19 <elliott__> Deewiant: runFile file = do fh <- openBinaryFile file; poop <- hGetContents fh; print poop; runString poop
23:39:20 <elliott__> There
23:39:24 <Deewiant> readFile loads lazily
23:39:29 <elliott__> Deewiant: Oh, right
23:39:32 <elliott__> The first then
23:39:39 <impomatic> elliott__: thanks :-) It was supposed to score worse than egodeath though to prove egodeath is effective :-(
23:40:41 <Deewiant> runFile file = withBinaryFile file ReadMode (hGetContents >=> runString)
23:40:53 <elliott__> Deewiant: Deewiant "Fancy McFancyPants" Deewiant
23:41:03 <Vorpal> elliott__, wtf is >=>
23:41:08 <elliott__> :t (>=>)
23:41:09 <lambdabot> forall a (m :: * -> *) b c. (Monad m) => (a -> m b) -> (b -> m c) -> a -> m c
23:41:15 <elliott__> One of the 2398723498723947239479234 functor-applicative-or-monad combinators.
23:41:19 <Vorpal> elliott__, :D
23:41:27 <Deewiant> elliott__: 2.3 seconds and it crashes in the FING test
23:41:31 <elliott__> Vorpal: One exists for every purpose except the one thing you're trying to accomplish now.
23:41:33 <Vorpal> elliott__, I believe that count was a bit on the low side
23:41:36 <elliott__> Deewiant: Gut Fingerprints.hs :P
23:41:51 <Deewiant> 4.5 seconds after removing *.tmp
23:42:29 <elliott__> Deewiant: How is it faster than me.
23:42:38 <elliott__> Deewiant: Does it shrink bounds?
23:42:42 -!- Ilari_antrcomp has quit (Ping timeout: 260 seconds).
23:42:42 -!- Ilari has quit (Ping timeout: 260 seconds).
23:42:48 <Deewiant> No fingerprints: 4.12 seconds
23:42:53 <elliott__> <elliott__> Deewiant: Does it shrink bounds?
23:42:57 <Vorpal> elliott__, does >=> have some descriptive name? I'm still not that good at figuring out what stuff does from the type signature alone
23:43:08 <Deewiant> There's noticeable lag between BAD: form feed reflects and BAD: after spacing top-left corner, y should report greatest point as ( 182 910 ), not ( 181 910 )
23:43:21 <elliott__> Vorpal: (someMonadicFunction >=> someMonadicFunctionTakingTheFirstOne'sResult) inputToFirstOne
23:43:27 <elliott__> --> result of second function
23:43:40 <elliott__> Deewiant: Good, so it's shit and Shiro is 10x better
23:43:42 <Deewiant> It also says That the greatest point, relative to that point, is ( 181 910 ) BAD: should have been ( 183 911 )
23:43:49 <elliott__> Ha ha ha
23:43:50 <elliott__> It's SHIT
23:43:54 <elliott__> Worst shit in the history of: shit
23:43:56 <Deewiant> UNDEF: # across left edge skips easternmost cell in file, tut-tut
23:43:58 <Vorpal> elliott__, I get "not in scope" for >=> locally
23:44:03 <Vorpal> :i (>=>)
23:44:03 <elliott__> Vorpal: import Control.Monad
23:44:07 <Vorpal> elliott__, aha
23:44:12 <elliott__> Deewiant: God
23:44:16 <elliott__> Deewiant: It's like someone decided
23:44:18 <elliott__> HEY I'MMA MAKE THE WORST FUNGE
23:44:20 <elliott__> AND THEN DID IT
23:44:20 <elliott__> SHIRO
23:44:21 <impomatic> !bfjoust Nyarlathotep http://www.lichttuete.com/temp/a12.txt
23:44:22 <elliott__> SHIRO IS WHAT YOU NEED
23:44:22 -!- augur has joined.
23:44:24 <elliott__> FOREVER SHIRO
23:44:28 <impomatic> !bfjoust dont_wait <
23:44:59 <Vorpal> impomatic, dont_wait was good
23:45:01 <Vorpal> impomatic, why remote it
23:45:21 <impomatic> Vorpal: the name was rubbish, just renaming it ;-)
23:45:35 <Vorpal> impomatic, also is "Nyarlathotep" a pharaoh or something?
23:45:41 <Vorpal> it sounds like it might be
23:45:56 <impomatic> A friend of Cthulhu :-)
23:46:00 <Vorpal> oh
23:46:09 <Deewiant> Having an Egyptian-sounding name does not one a pharaoh make
23:47:24 <elliott__> Totally does
23:47:25 <nescience> !bfjoust hopscotch (>[(>[([>[-]])*31])*31])*31
23:47:55 <nescience> this is hard to mess about with on a phone!
23:47:59 <impomatic> Strangely enough Nyarlathotep is known as the Black Pharaoh in one of the books :-)
23:48:38 <elliott__> Woo, Shiro is becoming a real program
23:48:42 <Deewiant> They all have a billion names so I'm hardly surprised
23:48:43 <elliott__> i.e. main is moving out of Interpreter.hs
23:48:44 <Vorpal> impomatic, it *sounds* very Egyptian
23:48:53 <elliott__> I'm even giving it
23:48:54 <elliott__> wait for it
23:48:56 <elliott__> COMMAND LINE ARGUMENTS
23:48:58 <elliott__> HOLY SHIT
23:49:14 -!- Ilari has joined.
23:49:16 <Vorpal> elliott__, fix the y stuff then!
23:49:18 <Vorpal> night →
23:49:25 <elliott__> Vorpal: It does the environment.
23:49:28 <EgoBot> Score for impomatic_Nyarlathotep: 49.1
23:49:28 <EgoBot> Score for impomatic_dont_wait: 0.0
23:49:29 <Vorpal> elliott__, tell me when you put it in version control
23:49:31 <elliott__> It'll do arguments after this cleanup is through.
23:49:32 <EgoBot> Score for nescience_hopscotch: 20.7
23:49:34 <Vorpal> night!
23:49:35 <elliott__> Vorpal: That won't happen until 1.0.
23:49:36 -!- Ilari_antrcomp has joined.
23:49:41 <elliott__> I'm like Deewiant in that respect :P
23:49:42 <coppro> wtf
23:49:59 <Deewiant> I didn't version control CCBI until 1.0.4a
23:49:59 <coppro> elliott__: you aren't registered
23:50:03 <nescience> !bfjoust hopscotch (>[(>[([>[[-]]+])*31])*31])*31
23:50:15 <Deewiant> And I didn't save old zips so I don't have anything older
23:50:18 <EgoBot> Score for nescience_hopscotch: 28.0
23:51:22 <elliott__> Deewiant: DING DING DING NEW DEPENDENCY
23:52:49 <Deewiant> elliott__: Does http://tar.us.to:1234/forks.b98 work?
23:53:02 <elliott__> Deewiant: Let me finish moving Main out first :P
23:53:06 <elliott__> Deewiant: I'm scared though.
23:53:27 <elliott__> Deewiant: How long will it take with a slow-ish t?
23:53:29 <impomatic> !bfjoust hound_of_tindalos (-)*999999(>)*9([-]>)*21
23:53:42 <Deewiant> elliott__: If that takes long, good luck with Fungicide :-D
23:53:56 <Deewiant> Spent: 21 ticks
23:53:56 <Deewiant> Encountered: 292 instructions
23:54:16 <elliott__> Deewiant: Oh, that should work then.
23:54:29 <elliott__> Let me get a command-line first :P
23:55:18 -!- joo has joined.
23:55:22 <EgoBot> Score for impomatic_hound_of_tindalos: 17.3
23:57:07 <elliott__> Module imports form a cycle for modules:
23:57:07 <elliott__> Shiro.Instructions (./Shiro/Instructions.hs)
23:57:07 <elliott__> imports: Shiro.Interpreter
23:57:07 <elliott__> Shiro.Interpreter (./Shiro/Interpreter.hs)
23:57:07 <elliott__> imports: Shiro.Instructions
23:57:09 <elliott__> Gah, that isn't allowed?
23:57:26 <Deewiant> You need .hs-boot files
23:57:31 <Deewiant> Or preferably, a lack of cycles